init

repositories/task_repo.go

@@ -0,0 +1,124 @@
+package repositories
+
+import (
+    "fmt"
+    "time"
+    "xorm.io/xorm"
+    "xps/datamodels"
+    "xps/viewmodels"
+)
+
+type TaskRepo struct {
+    engine *xorm.Engine
+}
+
+func NewTaskRepo(engine *xorm.Engine) *TaskRepo {
+    return &TaskRepo{
+        engine: engine,
+    }
+}
+
+func (d *TaskRepo) GetPage(m map[string]interface{}) (*viewmodels.PageResult, error) {
+    ocId      := m["ocId"].(int64)
+    limit     := m["limit"].(int)
+    page      := m["page"].(int)
+    
+    sqlSelect := ` SELECT A.*             `
+    sqlFrom   := ` FROM   task   AS A `
+    sqlWhere  := ` WHERE  A.deleted_flag = 0  and A.oc_id = ` + fmt.Sprintf("%d", ocId)
+    
+    if keywords, ok := m["keywords"]; ok {
+        sqlWhere += ` AND   A.task_title like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
+    }
+    
+    sqlCount    := ` SELECT COUNT(*)   `
+    total, err1 := d.engine.SQL(sqlCount + sqlFrom + sqlWhere).Count(new(datamodels.Task))
+    if err1 != nil {
+        return nil, err1
+    }
+    
+    sqlOrderBy := " ORDER BY A.task_id DESC "
+    pageStart  := (page - 1) * limit
+    sqlLimit   := fmt.Sprintf(" LIMIT %d OFFSET %d ", limit, pageStart)
+    
+    datalist   := make([]datamodels.Task, 0)
+    err2 := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy + sqlLimit).Find(&datalist)
+    if err2 != nil {
+        return nil, err2
+    }
+    
+    pageResult := &viewmodels.PageResult{}
+    pageResult.Data     = datalist
+    pageResult.Total    = total
+    pageResult.PageSize = limit
+    pageResult.Page     = page
+    return pageResult, nil
+    
+}
+
+func (d *TaskRepo) GetList(m map[string]interface{}) ([]viewmodels.TaskInfo, error) {
+    ocId := m["ocId"].(int64)
+    
+    sqlSelect := ` SELECT A.* `
+    sqlFrom   := ` FROM  task   AS A    `
+    sqlWhere  := ` WHERE A.deleted_flag = 0  AND A.oc_id =` + fmt.Sprintf("%d", ocId)
+    if keywords, ok := m["keywords"]; ok {
+        sqlWhere += ` AND A.task_title like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
+    }
+    
+    sqlOrderBy := " ORDER BY A.task_id DESC "
+    datalist   := make([]viewmodels.TaskInfo, 0)
+    err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy).Find(&datalist)
+    if err != nil {
+        return nil, err
+    } else {
+        return datalist, nil
+    }
+}
+
+func (d *TaskRepo) GetById(ocId int64, taskId int64) (*viewmodels.TaskInfo, error) {
+    sqlSelect := ` SELECT A.* `
+    sqlFrom   := ` FROM  task   AS A    `
+    sqlWhere  := ` WHERE A.deleted_flag = 0`
+    sqlWhere  += fmt.Sprintf(" AND A.oc_id = %d", ocId)
+    sqlWhere  += fmt.Sprintf(" AND A.task_id = %d", taskId)
+    
+    data := &viewmodels.TaskInfo{}
+    has, err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).Get(data)
+    if !has || err != nil {
+        return nil, err
+    } else {
+        return data, nil
+    }
+}
+
+func (d *TaskRepo) Create(t *datamodels.Task) error {
+    t.CreatedAt = time.Now()
+    _, err := d.engine.Insert(t)
+    return err
+}
+
+func (d *TaskRepo) Update(t *datamodels.Task) error {
+    ocId   := t.OcId
+    taskId := t.TaskId
+    
+    t.UpdatedAt = time.Now()
+    _, err := d.engine.
+        Where("oc_id = ?", ocId).
+        Where("task_id = ?", taskId).
+        Update(t)
+    return err
+}
+
+func (d *TaskRepo) Delete(m map[string]interface{}) error {
+    ocId      := m["ocId"].(int64)
+    taskId    := m["taskId"].(int64)
+    deletedBy := m["deletedBy"].(int64)
+    
+    data := &datamodels.Task{}
+    data.DeletedFlag = 1
+    data.DeletedBy = deletedBy
+    data.DeletedAt = time.Now()
+    _, err := d.engine.Where("oc_id = ?", ocId).Where("task_id = ?", taskId).Update(data)
+    return err
+}

service/task_service.go

@@ -0,0 +1,52 @@
+package service
+
+import (
+    "xps/datamodels"
+    "xps/datasource"
+    "xps/repositories"
+    "xps/viewmodels"
+)
+
+type TaskService interface {
+    GetList(m map[string]interface{}) ([]viewmodels.TaskInfo, error)
+    GetPage(m map[string]interface{}) (*viewmodels.PageResult, error)
+    GetById(ocId int64, taskId int64) (*viewmodels.TaskInfo, error)
+    Create(d *datamodels.Task) error
+    Update(d *datamodels.Task) error
+    Delete(m map[string]interface{}) error
+}
+
+type taskService struct {
+    repo *repositories.TaskRepo
+}
+
+func NewTaskService() TaskService {
+    return &taskService{
+        repo: repositories.NewTaskRepo(datasource.InstanceMaster()),
+    }
+}
+
+func (s *taskService) GetList(m map[string]interface{}) ([]viewmodels.TaskInfo, error) {
+    return s.repo.GetList(m)
+}
+
+func (s *taskService) GetPage(m map[string]interface{}) (*viewmodels.PageResult, error) {
+    return s.repo.GetPage(m)
+}
+
+func (s *taskService) GetById(ocId int64, taskId int64) (*viewmodels.TaskInfo, error) {
+    return s.repo.GetById(ocId, taskId)
+}
+
+func (s *taskService) Create(d *datamodels.Task) error {
+    d.TaskId = NewID()
+    return s.repo.Create(d)
+}
+
+func (s *taskService) Update(d *datamodels.Task) error {
+    return s.repo.Update(d)
+}
+
+func (s *taskService) Delete(m map[string]interface{}) error {
+    return s.repo.Delete(m)
+}

viewmodels/task_info.go

@@ -0,0 +1,25 @@
+package viewmodels
+
+type TaskInfo struct {
+    OcId                int64       `json:"ocId"                  xorm:"'oc_id'                bigint       comment('OC ID')       " `
+    TaskId              int64       `json:"taskId"                xorm:"'task_id'              bigint    pk comment('主键ID')       " `
+    TaskCode            string      `json:"taskCode"              xorm:"'task_code'            varchar(127) comment('TASK编码')     " `
+    TaskTitle           string      `json:"taskTitle"             xorm:"'task_title'           varchar(127) comment('TASK类型名称')  " `
+    TaskDesc            string      `json:"taskDesc"              xorm:"'task_desc'            varchar(127) comment('描述')         " `
+    TaskCatId           int64       `json:"taskCatId"             xorm:"'task_cat_id'          bigint       comment('类别ID')       " `
+    TaskTypeId          int64       `json:"taskTypeId"            xorm:"'task_type_id'         bigint       comment('类别ID')       " `
+    ExpectedStartTime   string      `json:"expectedStartTime"     xorm:"'expected_start_time'  datetime     comment('TASK类型名称')  " `
+    ExpectedEndTime     string      `json:"expectedEndTime"       xorm:"'expected_end_time'    datetime     comment('TASK类型名称')  " `
+    ActualStartTime     string      `json:"actualStartTime"       xorm:"'actual_start_time'    datetime     comment('实际开始时间')  " `
+    ActualEndTime       string      `json:"actualEndTime"         xorm:"'actual_end_time'      datetime     comment('实际结束时间')  " `
+    TaskPriority        int64       `json:"taskPriority"          xorm:"'task_priority'        bigint       comment('优先级')       " `
+    TaskUrgency         int64       `json:"taskUrgency"           xorm:"'task_urgency'         bigint       comment('紧急程序')     " `
+    Status           	int64       `json:"status"                xorm:"'status'               bigint       comment('状态')        " `
+    TaskLevel           int64       `json:"taskLevel"             xorm:"'task_level'           bigint       comment('任务级别')     " `
+    ParentId            int64       `json:"parentId"              xorm:"'parent_id'            bigint       comment('父任务')       " `
+    TaskOrigin          int64       `json:"taskOrigin"            xorm:"'task_origin'          bigint       comment('任务来源')     " `
+}
+
+func (t *TaskInfo) TableName() string {
+    return "task_cat"
+}

web/controllers/task_controller.go

@@ -0,0 +1,102 @@
+package controllers
+
+import (
+    "github.com/kataras/iris/v12/mvc"
+    "xps/datamodels"
+    "xps/service"
+)
+
+type TaskController struct {
+    Base
+    Service service.TaskService
+}
+
+func (c *TaskController) BeforeActivation(b mvc.BeforeActivation) {
+    b.Handle("GET",     "/",                    "GetList" )
+    b.Handle("GET",     "/page",                "GetPage" )
+    b.Handle("GET",     "/{taskId:int64}",      "GetById"   )
+    b.Handle("POST",    "/add",                 "Create"    )
+    b.Handle("PUT",     "/update",              "Update"    )
+    b.Handle("DELETE",  "/{taskId:int64}",      "DeleteByID")
+}
+
+func (c *TaskController) GetList() *JsonResult {
+    params    := c.buildParams()
+    data, err := c.Service.GetList(params)
+    if err != nil {
+        return ResultErr(err.Error(), nil)
+    } else {
+        return ResultOk("获取成功", data)
+    }
+}
+
+func (c *TaskController) GetPage() *JsonResult {
+    params    := c.buildParams()
+    data, err := c.Service.GetPage(params)
+    if err != nil {
+        return ResultErr(err.Error(), nil)
+    } else {
+        return ResultOk("获取成功", data)
+    }
+}
+
+func (c *TaskController) GetById(taskId int64) *JsonResult {
+    ocId      := c.GetCurOcId()
+    data, err := c.Service.GetById(ocId, taskId)
+    if err != nil {
+        return ResultErr(err.Error(), nil)
+    } else {
+        return ResultOk("获取成功", data)
+    }
+}
+
+func (c *TaskController) Create() *JsonResult {
+    ocId    := c.GetCurOcId()
+    userId  := c.GetCurUserId()
+    
+    task   := &datamodels.Task{}
+    if err := c.Ctx.ReadJSON(task); err != nil {
+        return ResultErr("读取数据失败", nil)
+    }
+    
+    task.OcId      = ocId
+    task.CreatedBy = userId
+    if err := c.Service.Create(task); err != nil {
+        return ResultErr(err.Error(), nil)
+    } else {
+        return ResultOk("新增成功", nil)
+    }
+}
+
+func (c *TaskController) Update() *JsonResult {
+    ocId    := c.GetCurOcId()
+    userId  := c.GetCurUserId()
+    
+    task := &datamodels.Task{}
+    if err  := c.Ctx.ReadJSON(task); err != nil {
+        return ResultErr("读取数据失败", nil)
+    }
+    
+    task.OcId      = ocId
+    task.UpdatedBy = userId
+    if err := c.Service.Update(task); err != nil {
+        return ResultErr(err.Error(), nil)
+    } else {
+        return ResultOk("更新成功", nil)
+    }
+}
+
+func (c *TaskController) DeleteByID(taskId int64) *JsonResult {
+    ocId   := c.GetCurOcId()
+    userId := c.GetCurUserId()
+    
+    m := make(map[string]interface{})
+    m["ocId"]      = ocId
+    m["taskId"]    = taskId
+    m["deletedBy"] = userId
+    if err := c.Service.Delete(m); err != nil {
+        return ResultErr(err.Error(), nil)
+    } else {
+        return ResultOk("删除成功", nil)
+    }
+}

web/router/routes.go

@@ -109,12 +109,17 @@ func Configure(b *bootstrap.Bootstrapper) {
 		appPermitApp.Handle(new(controllers.AppPermitController))
 	}
 
-	// TaskCat
-	taskCatParty := b.Party("/task", crs).AllowMethods(iris.MethodOptions)
+	// Task
+	taskParty := b.Party("/task", crs).AllowMethods(iris.MethodOptions)
 	{
-		taskCatParty.Use(middleware.AuthToken)
+		taskParty.Use(middleware.AuthToken)
+		taskService := service.NewTaskService()
+		taskApp := mvc.New(taskParty.Party(""))
+		taskApp.Register(taskService)
+		taskApp.Handle(new(controllers.TaskController))
+		
 		taskCatService := service.NewTaskCatService()
-		taskCatApp := mvc.New(taskCatParty.Party("/cat"))
+		taskCatApp := mvc.New(taskParty.Party("/cat"))
 		taskCatApp.Register(taskCatService)
 		taskCatApp.Handle(new(controllers.TaskCatController))
 	}
@@ -246,6 +251,41 @@ func Configure(b *bootstrap.Bootstrapper) {
 		
 	}
 	
+	// Art
+	artParty := b.Party("/art", crs).AllowMethods(iris.MethodOptions)
+	{
+		artParty.Use(middleware.AuthToken)
+		artService := service.NewArtService()
+		artApp := mvc.New(artParty.Party(""))
+		artApp.Register(artService)
+		artApp.Handle(new(controllers.ApiController))
+		
+		artCatService := service.NewArtCatService()
+		artCatApp := mvc.New(artParty.Party("/cat"))
+		artCatApp.Register(artCatService)
+		artCatApp.Handle(new(controllers.ArtCatController))
+	}
+	
+	// Doc
+	docParty := b.Party("/doc", crs).AllowMethods(iris.MethodOptions)
+	{
+		docParty.Use(middleware.AuthToken)
+		docCatService := service.NewDocCatService()
+		docCatApp := mvc.New(artParty.Party("/cat"))
+		docCatApp.Register(docCatService)
+		docCatApp.Handle(new(controllers.DocCatController))
+		
+		docDirService := service.NewDocDirService()
+		docDirApp := mvc.New(artParty.Party("/dir"))
+		docDirApp.Register(docDirService)
+		docDirApp.Handle(new(controllers.DocDirController))
+		
+		docFileService := service.NewDocFileService()
+		docFileApp := mvc.New(artParty.Party("/file"))
+		docFileApp.Register(docFileService)
+		docFileApp.Handle(new(controllers.DocFileController))
+	}
+	
 	// x
 	xParty := b.Party("/x", crs).AllowMethods(iris.MethodOptions)
 	{