init

datamodels/oc.go

@@ -11,15 +11,14 @@ type Oc struct {
 	RootId      int64       `json:"rootId"        form:"rootId"        xorm:"'root_id'     bigint        comment('Root ID')     " `
 	ParentId    int64       `json:"parentId"      form:"parentId"      xorm:"'parent_id'   bigint        comment('Parent ID')   " `
 	AdminId     int64       `json:"adminId"       form:"adminId"       xorm:"'admin_id'    bigint        comment('Admin ID')    " `
-	AdminName   string      `json:"adminName"     form:"adminName"     xorm:"'admin_name'  varchar(127)  comment('Admin Name')  " `
 	GroupId     int64       `json:"groupId"       form:"groupId"       xorm:"'group_id'    bigint        comment('Root Group Id')" `
-	IfLic       int         `json:"ifLic"         form:"ifLic"         xorm:"'if_lic'      int           comment('Admin ID')    " `
+	IfLic       int64       `json:"ifLic"         form:"ifLic"         xorm:"'if_lic'      int           comment('Admin ID')    " `
 
 	NodeLeft    int         `json:"nodeLeft"      form:"nodeLeft"      xorm:"'node_left'   int           comment('Admin ID')    " `
 	NodeRight   int         `json:"nodeRight"     form:"nodeRight"     xorm:"'node_right'  int           comment('Admin ID')    " `
 	IsLeaf      int         `json:"isLeaf"        form:"isLeaf"        xorm:"'is_leaf'     int           comment('Admin ID')    " `
 	NodeLevel   int         `json:"nodeLevel"     form:"nodeLevel"     xorm:"'node_level'  int           comment('Admin ID')    " `
-	Status      int         `json:"status"        form:"status"        xorm:"'status'      int           comment('OC Status')   " `
+	Status      int64       `json:"status"        form:"status"        xorm:"'status'      int           comment('OC Status')   " `
 
 	CreatedBy   int64       `json:"createdBy"     xorm:"'created_by'"`
 	CreatedAt   time.Time   `json:"createdAt"     xorm:"'created_at'"`

repositories/oc_repo.go

@@ -220,19 +220,18 @@ func (d *OcRepo) CountOfChildren(iRoot, iid int64) (int64, error) {
 	return count, nil
 }
 
-func (d *OcRepo) GetAdmin(ocId int64)(*datamodels.Account, error) {
+func (d *OcRepo) GetAdmin(ocId int64)(*viewmodels.OcAdminInfo, error) {
 	sqlSelect := ` SELECT A.*       ,
                           B.*            `
 	sqlFrom   := ` FROM       oc           AS A
                    LEFT  JOIN account      AS B ON(A.oc_id = B.oc_id AND A.admin_id = B.account_id) `
 	sqlWhere  := ` WHERE A.deleted_flag = 0  AND A.oc_id = ` + fmt.Sprintf("%d", ocId)
 	
-	data := &datamodels.Account{}
+	data := &viewmodels.OcAdminInfo{}
 	has, err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).Get(data)
-
 	if !has || err != nil {
 		return nil, err
 	} else {
 		return data, nil
 	}
-}
+}

service/oc_service.go

@@ -1,6 +1,8 @@
 package service
 
 import (
+    "time"
+    "xps/constant"
     "xps/datamodels"
     "xps/datasource"
     "xps/repositories"
@@ -14,39 +16,268 @@ type OcService interface {
     Create(d *datamodels.Oc) error
     Update(d *datamodels.Oc) error
     Delete(m map[string]interface{}) error
+    
+    GetAdmin(ocId int64) (*viewmodels.OcAdminInfo, error)
+    CreateAdmin(d *viewmodels.OcAdminInfo) error
+    UpdateAdmin(d *viewmodels.OcAdminInfo) error
+    ResetAdminPwd(ocId, accountId int64) error
+    
+    UpdateStatus(ocId, status int64) error
+    UpdateLicStatus(ocId, status int64) error
 }
 
 type ocService struct {
-    repo *repositories.OcRepo
+    ocRepo *repositories.OcRepo
+    groupCatRepo *repositories.GroupCatRepo
+    groupRepo *repositories.GroupRepo
+    accountRepo *repositories.AccountRepo
+    positionRepo *repositories.PositionRepo
+    groupMemberRepo *repositories.GroupMemberRepo
+    groupMemberPositionRepo *repositories.GroupMemberPositionRepo
+    roleMemberRepo *repositories.RoleMemberRepo
 }
 
 func NewOcService() OcService {
     return &ocService{
-        repo: repositories.NewOcRepo(datasource.InstanceMaster()),
+        ocRepo: repositories.NewOcRepo(datasource.InstanceMaster()),
     }
 }
 
 func (s *ocService) GetList(m map[string]interface{}) ([]viewmodels.OcInfo, error) {
-    return s.repo.GetList(m)
+    return s.ocRepo.GetList(m)
 }
 
 func (s *ocService) GetPage(m map[string]interface{}) (*viewmodels.PageResult, error) {
-    return s.repo.GetPage(m)
+    return s.ocRepo.GetPage(m)
 }
 
 func (s *ocService) GetById(ocId int64) (*viewmodels.OcInfo, error) {
-    return s.repo.GetById(ocId)
+    return s.ocRepo.GetById(ocId)
 }
 
-func (s *ocService) Create(Oc *datamodels.Oc) error {
-    Oc.OcId = NewID()
-    return s.repo.Create(Oc)
+func (s *ocService) Create(o *datamodels.Oc) error {
+    ocId   := NewID()
+    ocName := o.OcName
+    userId := o.CreatedBy
+    
+    // 1.Create OC
+    o.OcId      = ocId
+    o.RootId    = ocId
+    o.ParentId  = 0
+    o.GroupId   = ocId
+    o.NodeLeft  = 1
+    o.NodeRight = 2
+    o.NodeLevel = 1
+    o.IsLeaf    = 1
+    o.Status    = 1
+    o.CreatedAt = time.Now()
+    err1 := s.ocRepo.Create(o)
+    if err1 != nil {
+        return err1
+    }
+    
+    // 2.Group Cat
+    groupCat := &datamodels.GroupCat{
+        OcId: ocId,
+        GroupCatId: ocId,
+        GroupCatTitle: "公司",
+        IsFixed: 1,
+        GroupCatDesc: "公司",
+        CreatedAt: time.Now(),
+        CreatedBy: userId,
+    }
+    err2 := s.groupCatRepo.Create(groupCat)
+    if err2 != nil {
+        return err1
+    }
+    
+    // 3.Group
+    group := &datamodels.Group{
+        OcId: ocId,
+        GroupId: ocId,
+        GroupName: ocName,
+        GroupCatId: ocId,
+        NodeLeft: 1,
+        NodeRight: 2,
+        NodeLevel: 1,
+        RootId: ocId,
+        ParentId: 0,
+        IsFixed: 1,
+        IsLeaf: 1,
+        GroupCode: "",
+        GroupPath: "",
+        CreatedBy: userId,
+        CreatedAt: time.Now(),
+    }
+    err3 := s.groupRepo.Create(group)
+    if err3 != nil {
+        return err3
+    }
+    
+    return nil
 }
 
-func (s *ocService) Update(Oc *datamodels.Oc) error {
-    return s.repo.Update(Oc)
+func (s *ocService) Update(o *datamodels.Oc) error {
+    ocId   := o.OcId
+    ocName := o.OcName
+    userId := o.UpdatedBy
+    
+    // 1. Update OC
+    o.UpdatedAt = time.Now()
+    err1 := s.ocRepo.Update(o)
+    if err1 != nil {
+        return err1
+    }
+    
+    // 2.Group
+    group := &datamodels.Group{
+        OcId: ocId,
+        GroupId: ocId,
+        GroupName: ocName,
+        UpdatedAt: time.Now(),
+        UpdatedBy: userId,
+    }
+    err2 := s.groupRepo.Update(group)
+    if err2 != nil {
+        return err2
+    }
+    return nil
 }
 
 func (s *ocService) Delete(m map[string]interface{}) error {
-    return s.repo.Delete(m)
+    return s.ocRepo.Delete(m)
+}
+
+func (s *ocService) GetAdmin(ocId int64) (*viewmodels.OcAdminInfo, error) {
+    return s.ocRepo.GetAdmin(ocId)
+}
+
+func (s *ocService) CreateAdmin(a *viewmodels.OcAdminInfo) error {
+    ocId    := a.OcId
+    adminId := ocId
+    userId  := a.CreatedBy
+    
+    //1.Account
+    account := &datamodels.Account{
+        OcId: ocId,
+        AccountId: adminId,
+        AccountName: a.AdminName,
+        Password: "21218cca77804d2ba1922c33e0151105",
+        AccountPhone: a.AdminPhone,
+        AccountType: 0,
+        AccountAvatar: "",
+        IsFixed: 1,
+        Status: 1,
+        CreatedBy: userId,
+        CreatedAt: time.Now(),
+    }
+    err1 := s.accountRepo.Create(account)
+    if err1 != nil {
+        return err1
+    }
+    
+    //2.OC Admin
+    oc := &datamodels.Oc{
+        OcId: ocId,
+        AdminId: adminId,
+    }
+    err2 := s.ocRepo.Update(oc)
+    if err2 != nil {
+        return err2
+    }
+    
+    //3.Role Member
+    roleMember := &datamodels.RoleMember{
+        OcId: ocId,
+        RmId: ocId,
+        RoleId: constant.ENT_ROLE_ADMIN,
+        AccountId: adminId,
+    }
+    err3 := s.roleMemberRepo.Create(roleMember)
+    if err3 != nil {
+        return err3
+    }
+    
+    //4.Position
+    position := &datamodels.Position{
+        OcId: ocId,
+        PositionId: ocId,
+        PositionName: "管理员",
+        PositionDesc: "管理员",
+        IsFixed: 1,
+        CreatedAt: time.Now(),
+        CreatedBy: userId,
+    }
+    err4 := s.positionRepo.Create(position)
+    if err4 != nil {
+        return err4
+    }
+    
+    //5.Group Member
+    groupMember := &datamodels.GroupMember{
+        OcId: ocId,
+        GmId: ocId,
+        GroupId: ocId,
+        AccountId: adminId,
+        IsFixed: 1,
+    }
+    err5 := s.groupMemberRepo.Create(groupMember)
+    if err5 != nil {
+        return err5
+    }
+    
+    //6.Group Member Position
+    groupMemberPosition := &datamodels.GroupMemberPosition{
+        OcId: ocId,
+        GmpId: ocId,
+        GroupId: ocId,
+        AccountId: adminId,
+        PositionId: ocId,
+        IsFixed: 1,
+    }
+    err6 := s.groupMemberPositionRepo.Create(groupMemberPosition)
+    return err6
+}
+
+func (s *ocService) UpdateAdmin(a *viewmodels.OcAdminInfo) error {
+    ocId    := a.OcId
+    adminId := a.AdminId
+    userId  := a.UpdatedBy
+    
+    //1. Account
+    account := &datamodels.Account{
+        OcId: ocId,
+        AccountId: adminId,
+        AccountName: a.AdminName,
+        AccountPhone: a.AdminPhone,
+        UpdatedBy: userId,
+        UpdatedAt: time.Now(),
+    }
+    return s.accountRepo.Update(ocId, adminId, account)
 }
+
+func (s *ocService) ResetAdminPwd(ocId, accountId int64) error{
+    //1. Account
+    account := &datamodels.Account{
+        OcId: ocId,
+        AccountId: accountId,
+        Password: "21218cca77804d2ba1922c33e0151105",
+    }
+    return s.accountRepo.Update(ocId, accountId, account)
+}
+
+func (s *ocService) UpdateStatus(ocId, status int64) error {
+    oc := &datamodels.Oc{
+        OcId: ocId,
+        Status: status,
+    }
+    return s.ocRepo.Update(oc)
+}
+
+func (s *ocService) UpdateLicStatus(ocId, status int64) error{
+    oc := &datamodels.Oc{
+        OcId: ocId,
+        IfLic: status,
+    }
+    return s.ocRepo.Update(oc)
+}

viewmodels/oc_admin_info.go

@@ -0,0 +1,10 @@
+package viewmodels
+
+type OcAdminInfo struct {
+    OcId            int64     `json:"ocId"          xorm:"'oc_id'          bigint     pk comment('Oc ID')          "`
+    AdminId         int64     `json:"adminId"       xorm:"'admin_id'       bigint     pk comment('主键ID')          "`
+    AdminName       string    `json:"adminName"     xorm:"'admin_name'     varchar(50)   comment('Admin Name')     "`
+    AdminPhone      string    `json:"adminPhone"    xorm:"'admin_phone'    varchar(50)   comment('Admin Phone')    "`
+    CreatedBy       int64     `json:"createdBy"     xorm:"'created_by'     bigint        comment('Created By')     "`
+    UpdatedBy       int64     `json:"updatedBy"     xorm:"'updated_by'     bigint        comment('Updated By')     "`
+}

web/controllers/oc_controller.go

@@ -4,6 +4,7 @@ import (
     "github.com/kataras/iris/v12/mvc"
     "xps/datamodels"
     "xps/service"
+    "xps/viewmodels"
 )
 
 type OcController struct {
@@ -12,12 +13,18 @@ type OcController struct {
 }
 
 func (c *OcController) BeforeActivation(b mvc.BeforeActivation) {
-    b.Handle("GET",         "/",                                "GetList"       )
-    b.Handle("GET",         "/page",                            "GetPage"       )
-    b.Handle("GET",         "/{ocId:int64}",                    "GetById"       )
-    b.Handle("POST",        "/add",                             "Create"        )
-    b.Handle("PUT",         "/update",                          "Update"        )
-    b.Handle("DELETE",      "/{ocId:int64}",                    "DeleteByID"    )
+    b.Handle("GET",         "/",                                            "GetList"         )
+    b.Handle("GET",         "/page",                                        "GetPage"         )
+    b.Handle("GET",         "/{ocId:int64}",                                "GetById"         )
+    b.Handle("POST",        "/add",                                         "Create"          )
+    b.Handle("PUT",         "/update",                                      "Update"          )
+    b.Handle("DELETE",      "/{ocId:int64}",                                "DeleteByID"      )
+    b.Handle("GET",         "/getAdmin/{ocId:int64}",                       "GetAdmin"        )
+    b.Handle("POST",        "/addAdmin",                                    "CreateAdmin"     )
+    b.Handle("PUT",         "/updateAdmin",                                 "UpdateAdmin"     )
+    b.Handle("PUT",         "/resetAdminPwd/{ocId:int64}/{adminId:int64}",  "ResetAdminPwd"   )
+    b.Handle("PUT",         "/updateStatus/{ocId:int64}/{status:int64}",    "UpdateStatus"    )
+    b.Handle("PUT",         "/updateLicStatus/{ocId:int64}/{status:int64}", "UpdateLicStatus" )
 }
 
 func (c *OcController) GetList() *JsonResult {
@@ -111,3 +118,75 @@ func (c *OcController) DeleteByID(ocId int64) *JsonResult {
         return ResultOk("删除成功", nil)
     }
 }
+
+func (c *OcController) GetAdmin(ocId int64) *JsonResult {
+    data, err := c.Service.GetAdmin(ocId)
+    if err != nil {
+        return ResultErr(err.Error(), nil)
+    } else {
+        return ResultOk("获取成功", data)
+    }
+}
+
+func (c *OcController) CreateAdmin() *JsonResult {
+    userId := c.GetCurUserId()
+    
+    o := viewmodels.OcAdminInfo{}
+    o.CreatedBy = userId
+    if err := c.Ctx.ReadJSON(&o); err != nil {
+        return ResultErr("读取数据失败", nil)
+    }
+    
+    if err := c.Service.CreateAdmin(&o); err != nil {
+        return ResultErr(err.Error(), nil)
+    } else {
+        return ResultOk("新增成功", nil)
+    }
+}
+
+func (c *OcController) UpdateAdmin() *JsonResult {
+    userId := c.GetCurUserId()
+    
+    a  := viewmodels.OcAdminInfo{}
+    if err := c.Ctx.ReadJSON(&a); err != nil {
+        return ResultErr("读取数据失败", nil)
+    }
+    
+    a.UpdatedBy = userId
+    if err := c.Service.UpdateAdmin(&a); err != nil {
+        return ResultErr(err.Error(), nil)
+    } else {
+        return ResultOk("更新成功", nil)
+    }
+}
+
+func (c *OcController) ResetAdminPwd(ocId, adminId int64) *JsonResult {
+    if err := c.Service.ResetAdminPwd(ocId, adminId); err != nil {
+        return ResultErr(err.Error(), nil)
+    } else {
+        return ResultOk("更新成功", nil)
+    }
+}
+
+func (c *OcController) UpdateStatus(ocId, status int64) *JsonResult {
+    if err := c.Service.UpdateStatus(ocId, status); err != nil {
+        return ResultErr(err.Error(), nil)
+    }
+    if status == 1 {
+        return ResultOk("激活成功", nil)
+    } else {
+        return ResultOk("锁定成功", nil)
+    }
+}
+
+
+func (c *OcController) UpdateLicStatus(ocId, status int64) *JsonResult {
+    if err := c.Service.UpdateLicStatus(ocId, status); err != nil {
+        return ResultErr(err.Error(), nil)
+    }
+    if status == 1 {
+        return ResultOk("使能成功", nil)
+    } else {
+        return ResultOk("关闭成功", nil)
+    }
+}