init

datamodels/partner_cat.go

@@ -0,0 +1,21 @@
+package datamodels
+
+import "time"
+
+type PartnerCat struct {
+	PartnerCatId    int64     `json:"partnerCatId"        xorm:"'partner_cat_id'      bigint     pk comment('主键ID')         "`
+	PartnerCatTitle string    `json:"partnerCatTitle"     xorm:"'partner_cat_title'   varchar(50)   comment('群组类型名称')     "`
+	PartnerCatDesc  string    `json:"partnerCatDesc"      xorm:"'partner_cat_desc'    varchar(50)   comment('描述')            "`
+	IsFixed         int64     `json:"isFixed"         xorm:"'is_fixed'        int           comment('是否可修改')         "`
+	CreatedBy       int64     `json:"createdBy"       xorm:"'created_by'"`
+	CreatedAt       time.Time `json:"createdAt"       xorm:"'created_at'"`
+	UpdatedBy       int64     `json:"updatedBy"       xorm:"'updated_by'"`
+	UpdatedAt       time.Time `json:"updatedAt"       xorm:"'updated_at'"`
+	DeletedFlag     int64     `json:"deletedFlag"     xorm:"'deleted_flag'"`
+	DeletedBy       int64     `json:"deletedBy"       xorm:"'deleted_by'"`
+	DeletedAt       time.Time `json:"deletedAt"       xorm:"'deleted_at'"`
+}
+
+func (t *PartnerCat) TableName() string {
+	return "partner_cat"
+}

datamodels/task_cat.go

@@ -0,0 +1,22 @@
+package datamodels
+
+import "time"
+
+type TaskCat struct {
+	OcId         int64     `json:"ocId"            xorm:"'oc_id'           bigint    pk comment('主键ID')       " `
+	TaskCatId    int64     `json:"taskCatId"       xorm:"'task_cat_id'     bigint    pk comment('主键ID')       " `
+	TaskCatTitle string    `json:"taskCatTitle"    xorm:"'task_cat_title'  varchar(127) comment('TASK类型名称')  " `
+	TaskCatDesc  string    `json:"taskCatDesc"     xorm:"'task_cat_desc'   varchar(127) comment('描述')         " `
+	IsFixed      int64     `json:"isFixed"         xorm:"'is_fixed'        bigint       comment('是否可修改')    " `
+	CreatedBy    int64     `json:"createdBy"       xorm:"'created_by'  " `
+	CreatedAt    time.Time `json:"createdAt"       xorm:"'created_at'  " `
+	UpdatedBy    int64     `json:"updatedBy"       xorm:"'updated_by'  " `
+	UpdatedAt    time.Time `json:"updatedAt"       xorm:"'updated_at'  " `
+	DeletedFlag  int64     `json:"deletedFlag"     xorm:"'deleted_flag'" `
+	DeletedBy    int64     `json:"deletedBy"       xorm:"'deleted_by'  " `
+	DeletedAt    time.Time `json:"deletedAt"       xorm:"'deleted_at'  " `
+}
+
+func (m *TaskCat) TableName() string {
+	return "task_cat"
+}

repositories/system/partner_cat_repo.go

@@ -0,0 +1,110 @@
+package system
+
+import (
+	"fmt"
+	"time"
+	"xorm.io/xorm"
+	"xps/datamodels"
+	"xps/viewmodels"
+)
+
+type PartnerCatRepo struct {
+	engine *xorm.Engine
+}
+
+func NewPartnerCatRepo(engine *xorm.Engine) *PartnerCatRepo {
+	return &PartnerCatRepo{
+		engine: engine,
+	}
+}
+
+func (d *PartnerCatRepo) GetByPage(m map[string]interface{}) (*viewmodels.PageResult, error) {
+	keywords := m["keywords"].(string)
+	limit := m["limit"].(int)
+	page := m["page"].(int)
+
+	sqlSelect := `SELECT A.*`
+	sqlFrom := `FROM   partner_cat   AS A `
+	sqlWhere := `WHERE A.deleted_flag = 0 `
+	if keywords != "" {
+		sqlWhere += ` AND A.partner_cat_title like ` + "'%" + keywords + "%'"
+	}
+
+	sqlCount := `SELECT COUNT(*) `
+	total, err1 := d.engine.SQL(sqlCount + sqlFrom + sqlWhere).Count(new(datamodels.PartnerCat))
+	if err1 != nil {
+		return nil, err1
+	}
+
+	sqlOrderBy := " ORDER BY partner_cat_id DESC "
+	pageStart := (page - 1) * limit
+	sqlLimit := fmt.Sprintf(" LIMIT %d OFFSET %d ", limit, pageStart)
+
+	datalist := make([]datamodels.PartnerCat, 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 *PartnerCatRepo) GetByList(m map[string]interface{}) ([]viewmodels.PartnerCatInfo, error) {
+	keywords := m["keywords"].(string)
+
+	sqlSelect := `SELECT A.* `
+	sqlFrom := `FROM  partner_cat   AS A    `
+	sqlWhere := `WHERE A.deleted_flag = 0 `
+	if keywords != "" {
+		sqlWhere += ` AND   A.partner_cat_title like ` + "'%" + keywords + "%'"
+	}
+
+	sqlOrderBy := " ORDER BY partner_cat_id DESC "
+	datalist := make([]viewmodels.PartnerCatInfo, 0)
+	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy).Find(&datalist)
+	if err != nil {
+		return nil, err
+	}
+	return datalist, nil
+}
+
+func (d *PartnerCatRepo) GetById(partnerCatId int64) (*viewmodels.PartnerCatInfo, error) {
+	data := &viewmodels.PartnerCatInfo{}
+	ok, err := d.engine.Where("partner_cat_id = ?", partnerCatId).Get(data)
+	if !ok && err == nil {
+		return nil, err
+	} else {
+		return data, nil
+	}
+}
+
+func (d *PartnerCatRepo) Create(data *datamodels.PartnerCat) error {
+	data.CreatedAt = time.Now()
+	_, err := d.engine.Insert(data)
+	return err
+}
+
+func (d *PartnerCatRepo) Update(data *datamodels.PartnerCat) error {
+	partnerCatId := data.PartnerCatId
+
+	data.UpdatedAt = time.Now()
+	_, err := d.engine.Where("partner_cat_id = ?", partnerCatId).Update(data)
+	return err
+}
+
+func (d *PartnerCatRepo) Delete(m map[string]interface{}) error {
+	partnerCatId := m["partnerCatId"].(int64)
+	deletedBy := m["deletedBy"].(int64)
+
+	data := &datamodels.PartnerCat{}
+	data.DeletedFlag = 1
+	data.DeletedBy = deletedBy
+	data.DeletedAt = time.Now()
+	_, err := d.engine.Where("partner_cat_id = ?", partnerCatId).Update(data)
+	return err
+}

repositories/system/task_cat_repo.go

@@ -0,0 +1,116 @@
+package system
+
+import (
+	"fmt"
+	"time"
+	"xorm.io/xorm"
+	"xps/datamodels"
+	"xps/viewmodels"
+)
+
+type TaskCatRepo struct {
+	engine *xorm.Engine
+}
+
+func NewTaskCatRepo(engine *xorm.Engine) *TaskCatRepo {
+	return &TaskCatRepo{
+		engine: engine,
+	}
+}
+
+func (d *TaskCatRepo) GetByPage(m map[string]interface{}) (*viewmodels.PageResult, error) {
+	ocId := m["ocId"].(int64)
+	keywords := m["keywords"].(string)
+	limit := m["limit"].(int)
+	page := m["page"].(int)
+
+	sqlSelect := `SELECT A.*`
+	sqlFrom := `FROM   task_cat   AS A `
+	sqlWhere := `WHERE A.deleted_flag = 0  and A.oc_id = ` + fmt.Sprintf("%d", ocId)
+
+	if keywords != "" {
+		sqlWhere += ` AND   A.task_cat_title like ` + "'%" + keywords + "%'"
+	}
+
+	sqlCount := `SELECT COUNT(*) `
+	total, err1 := d.engine.SQL(sqlCount + sqlFrom + sqlWhere).Count(new(datamodels.TaskCat))
+	if err1 != nil {
+		return nil, err1
+	}
+
+	sqlOrderBy := " ORDER BY task_cat_id DESC "
+	pageStart := (page - 1) * limit
+	sqlLimit := fmt.Sprintf(" LIMIT %d OFFSET %d ", limit, pageStart)
+
+	datalist := make([]datamodels.TaskCat, 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 *TaskCatRepo) GetByList(m map[string]interface{}) ([]viewmodels.TaskCatInfo, error) {
+	ocId := m["ocId"].(int64)
+	keywords := m["keywords"].(string)
+
+	sqlSelect := ` SELECT A.* `
+	sqlFrom := ` FROM  task_cat   AS A    `
+	sqlWhere := ` WHERE A.deleted_flag = 0  AND A.oc_id =` + fmt.Sprintf("%d", ocId)
+	if keywords != "" {
+		sqlWhere += ` AND   A.task_cat_title like ` + "'%" + keywords + "%'"
+	}
+
+	sqlOrderBy := " ORDER BY task_cat_id DESC "
+	datalist := make([]viewmodels.TaskCatInfo, 0)
+	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy).Find(&datalist)
+	if err != nil {
+		return nil, err
+	}
+	return datalist, nil
+}
+
+func (d *TaskCatRepo) GetById(ocId int64, taskCatId int64) (*viewmodels.TaskCatInfo, error) {
+	data := &viewmodels.TaskCatInfo{}
+	ok, err := d.engine.Where("oc_id = ?", ocId).Where("task_cat_id = ?", taskCatId).Get(data)
+	if !ok && err == nil {
+		return nil, err
+	} else {
+		return data, nil
+	}
+}
+
+func (d *TaskCatRepo) Create(data *datamodels.TaskCat) error {
+	data.CreatedAt = time.Now()
+	_, err := d.engine.Insert(data)
+	return err
+}
+
+func (d *TaskCatRepo) Update(data *datamodels.TaskCat) error {
+	ocId := data.OcId
+	taskCatId := data.TaskCatId
+
+	data.UpdatedAt = time.Now()
+	_, err := d.engine.Where("oc_id = ?", ocId).Where("task_cat_id = ?", taskCatId).Update(data)
+	return err
+}
+
+func (d *TaskCatRepo) Delete(m map[string]interface{}) error {
+	ocId := m["ocId"].(int64)
+	taskCatId := m["taskCatId"].(int64)
+	deletedBy := m["deletedBy"].(int64)
+
+	data := &datamodels.TaskCat{}
+	data.DeletedFlag = 1
+	data.DeletedBy = deletedBy
+	data.DeletedAt = time.Now()
+	_, err := d.engine.Where("oc_id = ?", ocId).Where("task_cat_id = ?", taskCatId).Update(data)
+	return err
+}

service/system/partner_cat_service.go

@@ -0,0 +1,52 @@
+package system
+
+import (
+	"xps/datamodels"
+	"xps/datasource"
+	"xps/repositories/system"
+	"xps/viewmodels"
+)
+
+type PartnerCatService interface {
+	GetByList(m map[string]interface{}) ([]viewmodels.PartnerCatInfo, error)
+	GetByPage(m map[string]interface{}) (*viewmodels.PageResult, error)
+	GetById(partnerCatId int64) (*viewmodels.PartnerCatInfo, error)
+	Create(d *datamodels.PartnerCat) error
+	Update(d *datamodels.PartnerCat) error
+	Delete(m map[string]interface{}) error
+}
+
+type partnerCatService struct {
+	repo *system.PartnerCatRepo
+}
+
+func NewPartnerCatService() PartnerCatService {
+	return &partnerCatService{
+		repo: system.NewPartnerCatRepo(datasource.InstanceMaster()),
+	}
+}
+
+func (s *partnerCatService) GetByList(m map[string]interface{}) ([]viewmodels.PartnerCatInfo, error) {
+	return s.repo.GetByList(m)
+}
+
+func (s *partnerCatService) GetByPage(m map[string]interface{}) (*viewmodels.PageResult, error) {
+	return s.repo.GetByPage(m)
+}
+
+func (s *partnerCatService) GetById(partnerCatId int64) (*viewmodels.PartnerCatInfo, error) {
+	return s.repo.GetById(partnerCatId)
+}
+
+func (s *partnerCatService) Create(PartnerCat *datamodels.PartnerCat) error {
+	PartnerCat.PartnerCatId = NewID()
+	return s.repo.Create(PartnerCat)
+}
+
+func (s *partnerCatService) Update(PartnerCat *datamodels.PartnerCat) error {
+	return s.repo.Update(PartnerCat)
+}
+
+func (s *partnerCatService) Delete(m map[string]interface{}) error {
+	return s.repo.Delete(m)
+}

service/system/task_cat_service.go

@@ -0,0 +1,52 @@
+package system
+
+import (
+	"xps/datamodels"
+	"xps/datasource"
+	"xps/repositories/system"
+	"xps/viewmodels"
+)
+
+type TaskCatService interface {
+	GetByList(m map[string]interface{}) ([]viewmodels.TaskCatInfo, error)
+	GetByPage(m map[string]interface{}) (*viewmodels.PageResult, error)
+	GetById(ocId int64, taskCatId int64) (*viewmodels.TaskCatInfo, error)
+	Create(d *datamodels.TaskCat) error
+	Update(d *datamodels.TaskCat) error
+	Delete(m map[string]interface{}) error
+}
+
+type taskCatService struct {
+	repo *system.TaskCatRepo
+}
+
+func NewTaskCatService() TaskCatService {
+	return &taskCatService{
+		repo: system.NewTaskCatRepo(datasource.InstanceMaster()),
+	}
+}
+
+func (s *taskCatService) GetByList(m map[string]interface{}) ([]viewmodels.TaskCatInfo, error) {
+	return s.repo.GetByList(m)
+}
+
+func (s *taskCatService) GetByPage(m map[string]interface{}) (*viewmodels.PageResult, error) {
+	return s.repo.GetByPage(m)
+}
+
+func (s *taskCatService) GetById(ocId int64, taskCatId int64) (*viewmodels.TaskCatInfo, error) {
+	return s.repo.GetById(ocId, taskCatId)
+}
+
+func (s *taskCatService) Create(TaskCat *datamodels.TaskCat) error {
+	TaskCat.TaskCatId = NewID()
+	return s.repo.Create(TaskCat)
+}
+
+func (s *taskCatService) Update(TaskCat *datamodels.TaskCat) error {
+	return s.repo.Update(TaskCat)
+}
+
+func (s *taskCatService) Delete(m map[string]interface{}) error {
+	return s.repo.Delete(m)
+}

viewmodels/partner_cat_info.go

@@ -0,0 +1,12 @@
+package viewmodels
+
+type PartnerCatInfo struct {
+	PartnerCatId    int64  `json:"partnerCatId"      xorm:"'partner_cat_id'      bigint     pk comment('主键ID')         "`
+	PartnerCatTitle string `json:"partnerCatTitle"   xorm:"'partner_cat_title'   varchar(50)   comment('群组类型名称')     "`
+	PartnerCatDesc  string `json:"partnerCatDesc"    xorm:"'partner_cat_desc'    varchar(50)   comment('描述')            "`
+	IsFixed         int64  `json:"isFixed"           xorm:"'is_fixed'        int           comment('是否可修改')         "`
+}
+
+func (t *PartnerCatInfo) TableName() string {
+	return "partner_cat"
+}

viewmodels/task_cat_info.go

@@ -0,0 +1,13 @@
+package viewmodels
+
+type TaskCatInfo struct {
+	OcId         int64  `json:"-"                xorm:"'oc_id'             bigint     pk comment('组织ID:公司或机构或单位ID')"`
+	TaskCatId    int64  `json:"taskCatId"        xorm:"'task_cat_id'       bigint     pk comment('主键ID')         "`
+	TaskCatTitle string `json:"taskCatTitle"     xorm:"'task_cat_title'    varchar(50)   comment('类型名称')     "`
+	TaskCatDesc  string `json:"taskCatDesc"      xorm:"'task_cat_desc'     varchar(50)   comment('描述')            "`
+	IsFixed      int64  `json:"isFixed"          xorm:"'is_fixed'          int           comment('是否可修改')         "`
+}
+
+func (t *TaskCatInfo) TableName() string {
+	return "task_cat"
+}

web/router/routes.go

@@ -18,30 +18,29 @@ func Configure(b *bootstrap.Bootstrapper) {
 		ExposedHeaders:   []string{"Accept", "Content-Type", "Content-Length", "Accept-Encoding", "X-CSRF-Token", "Authorization"},
 		AllowCredentials: true,
 	})
-	
+
 	// Static Resource
 	b.HandleDir("/", "./web/public")
-	
+
 	// Login
 	loginService := system.NewLoginService()
 	loginApp := mvc.New(b.Party("/", crs).AllowMethods(iris.MethodOptions))
 	loginApp.Register(loginService)
 	loginApp.Handle(new(controllers.LoginController))
-	
+
 	// role
 	sys := b.Party("/sys", crs).AllowMethods(iris.MethodOptions)
 	{
 		sys.Use(middleware.AuthToken)
-		
+
 		// Role
 		roleService := system.NewRoleService()
 		roleApp := mvc.New(sys.Party("/role"))
 		roleApp.Register(roleService)
 		roleApp.Handle(new(controllers.RoleController))
-		
 
 	}
-	
+
 	// Company Profile
 	company := b.Party("/company", crs).AllowMethods(iris.MethodOptions)
 	{
@@ -51,7 +50,7 @@ func Configure(b *bootstrap.Bootstrapper) {
 		companyProfileApp.Register(companyProfileService)
 		companyProfileApp.Handle(new(controllers.CompanyProfileController))
 	}
-	
+
 	// Group
 	group := b.Party("/group", crs).AllowMethods(iris.MethodOptions)
 	{
@@ -61,25 +60,25 @@ func Configure(b *bootstrap.Bootstrapper) {
 		groupApp.Register(groupService)
 		groupApp.Handle(new(controllers.GroupController))
 	}
-	
+
 	// User
 	user := b.Party("/user", crs).AllowMethods(iris.MethodOptions)
 	{
 		user.Use(middleware.AuthToken)
-		
+
 		// user
 		userService := system.NewUserService()
 		userApp := mvc.New(user.Party(""))
 		userApp.Register(userService)
 		userApp.Handle(new(controllers.UserController))
-		
+
 		// Permit
 		appPermitService := system.NewAppPermitService()
 		appPermitApp := mvc.New(user.Party("/permit"))
 		appPermitApp.Register(appPermitService)
 		appPermitApp.Handle(new(controllers.AppPermitController))
 	}
-	
+
 	// Position
 	position := b.Party("/position", crs).AllowMethods(iris.MethodOptions)
 	{
@@ -89,7 +88,7 @@ func Configure(b *bootstrap.Bootstrapper) {
 		positionApp.Register(positionService)
 		positionApp.Handle(new(controllers.PositionController))
 	}
-	
+
 	// GroupCat
 	groupCat := b.Party("/group", crs).AllowMethods(iris.MethodOptions)
 	{
@@ -99,7 +98,6 @@ func Configure(b *bootstrap.Bootstrapper) {
 		groupCatApp.Register(groupCatService)
 		groupCatApp.Handle(new(controllers.GroupCatController))
 	}
-	
 
 	// AppCat
 	app := b.Party("/app", crs).AllowMethods(iris.MethodOptions)
@@ -110,4 +108,24 @@ func Configure(b *bootstrap.Bootstrapper) {
 		appCatApp.Register(appCatService)
 		appCatApp.Handle(new(controllers.AppCatController))
 	}
+
+	// TaskCat
+	taskCat := b.Party("/task", crs).AllowMethods(iris.MethodOptions)
+	{
+		taskCat.Use(middleware.AuthToken)
+		taskCatService := system.NewTaskCatService()
+		taskCatApp := mvc.New(taskCat.Party("/cat"))
+		taskCatApp.Register(taskCatService)
+		taskCatApp.Handle(new(controllers.TaskCatController))
+	}
+
+	// PartnerCat
+	partnerCat := b.Party("/partner", crs).AllowMethods(iris.MethodOptions)
+	{
+		partnerCat.Use(middleware.AuthToken)
+		partnerCatService := system.NewTaskCatService()
+		partnerCatApp := mvc.New(partnerCat.Party("/cat"))
+		partnerCatApp.Register(partnerCatService)
+		partnerCatApp.Handle(new(controllers.PartnerCatController))
+	}
 }