dsMin/dsBaseRpc/RpcService/BaseOrganization/BaseOrganizationService/BaseOrganizationService.go

package BaseOrganizationService

import (
	"context"
	"dsBaseRpc/Const"
	"dsBaseRpc/Const/ErrorConst"
	"dsBaseRpc/RpcService/BaseClass/BaseClassDao"
	"dsBaseRpc/RpcService/BaseOrganization/BaseOrganizationDao"
	"dsBaseRpc/RpcService/BaseOrganization/BaseOrganizationProto"
	"dsBaseRpc/RpcService/BaseOrganizationManager/BaseOrganizationManagerDao"
	"dsBaseRpc/RpcService/BaseRolePerson/BaseRolePersonDao"
	"dsBaseRpc/RpcService/BaseTeacher/BaseTeacherDao"
	"dsBaseRpc/RpcService/BaseTeacher/BaseTeacherProto"
	GovAreaDao2 "dsBaseRpc/RpcService/GovArea/GovAreaDao"
	"dsBaseRpc/RpcService/SysLoginperson/SysLoginpersonDao"
	"dsBaseRpc/RpcService/SysLoginperson/SysLoginpersonService"
	"dsBaseRpc/Utils/CommonUtil"
	"dsBaseRpc/Utils/DateUtil"
	"dsBaseRpc/Utils/DbUtil"
	"dsBaseRpc/Utils/LogUtil"
	"dsBaseRpc/Utils/PinYinUtil"
	"dsBaseRpc/Utils/SqlKit"
	"dsBaseRpc/models"
	"errors"
	"fmt"
)

type Rpc struct{} //服务对象

//选择单条
func (s *Rpc) GetBaseOrganization(ctx context.Context, in *BaseOrganizationProto.ModelArg) (*BaseOrganizationProto.Reply, error) {
	//异常处理
	defer func() {
		if err := recover(); err != nil {
			fmt.Printf("%s\n", err)
		}
	}()
	//rpc响应
	var reply BaseOrganizationProto.Reply
	//使用通用方法获取单条记录
	list := SqlKit.QueryByIds([]string{in.OrgId}, "t_base_organization")
	if len(list) > 0 {
		//扩展一下附设班信息
		fsbArray, err := BaseOrganizationDao.GetFsb(in.OrgId)
		if err != nil {
			reply.Success = false
			reply.Message = Const.DataBaseActionError
			LogUtil.Error(ErrorConst.SqlQueryError, "执行GetFsb时发生严重错误："+err.Error())
			return &reply, err
		}
		list[0]["fsb"] = fsbArray
	}
	//将结果序列化
	reply.Success = true
	reply.Count = 1
	reply.Message = Const.SuccessDataBaseAction
	reply.List = CommonUtil.SerializeToString(list)
	return &reply, nil
}

//增加
func (s *Rpc) AddBaseOrganization(ctx context.Context, in *BaseOrganizationProto.ModelArg) (*BaseOrganizationProto.Reply, error) {
	//异常处理
	defer func() {
		if err := recover(); err != nil {
			fmt.Printf("%s\n", err)
		}
	}()
	//rpc响应
	var reply BaseOrganizationProto.Reply
	//是不是部门
	isBuMen := false

	//1:教育局,2:学校，7:教辅单位，8:大学区,不在1,2，7，8中，应该就是指部门
	if in.OrgType == 1 || in.OrgType == 2 || in.OrgType == 7 || in.OrgType == 8 {
		//1、检查非空
		if len(in.OrgCode) == 0 {
			reply.Success = false
			reply.Message = "代码为空，不能创建！"
			return &reply, nil
		}
		//2、检查AreaCode是否存在，不存在需要提示
		exist, err := GovAreaDao2.ExistAreaCode(in.AreaCode)
		if err != nil {
			reply.Success = false
			reply.Message = Const.DataBaseActionError
			LogUtil.Error(ErrorConst.SqlQueryError, "执行ExistAreaCode时发生严重错误："+err.Error())
			return &reply, err
		}
		if !exist {
			reply.Success = false
			reply.Message = "区域代码不存在，不能创建！"
			return &reply, nil
		}
	} else {
		isBuMen = true
	}

	//3、指定的org_code是否存在
	//如果添加的是单位，那么bureauId是空
	//如果添加的是部门，那么bureauId不是空
	exist, err := BaseOrganizationDao.IsExistOrgCode(in.OrgCode, in.BureauId, in.OrgType, "")
	if err != nil {
		LogUtil.Error(ErrorConst.SqlQueryError, "执行IsExistOrgCode时发生严重错误："+err.Error())
		reply.Success = false
		reply.Message = Const.DataBaseActionError
		return &reply, err
	}
	if exist {
		reply.Success = false
		if isBuMen {
			reply.Message = "部门代码已存在，无法创建！"
		} else {
			reply.Message = "单位代码已存在，无法创建！"
		}
		return &reply, err
	}

	//4、检查机构名称是否存在,否则在导入人员时，不知道向哪个单位下进行导入
	exist, err = BaseOrganizationDao.IsExistOrgName(in.OrgName, in.BureauId, in.OrgType, "")
	if err != nil {
		reply.Success = false
		reply.Message = Const.DataBaseActionError
		LogUtil.Error(ErrorConst.SqlQueryError, "执行IsExistOrgName时发生严重错误："+err.Error())
		return &reply, err
	}
	if exist {
		reply.Success = false
		if isBuMen {
			reply.Message = "部门名称已存在，不能创建！"
		} else {
			reply.Message = "单位名称已存在，不能创建！"
		}
		return &reply, err
	}
	//5、调用dao
	areaCode := in.AreaCode
	//如果是部门，没有给我区域码，我就取它父亲的区域码,不给areaCode,那么in.BureauId就一定要有啊
	if len(areaCode) == 0 {
		areaCode, _, _, _, _, err = BaseOrganizationDao.GetBureauAdministrativeDivision(in.BureauId)
		if err != nil {
			reply.Success = false
			reply.Message = err.Error()
			return &reply, err
		}
	}
	model := new(models.TBaseOrganization)
	model.OrgId = CommonUtil.GetUUID()
	//是市，还是区？
	model.ProvinceCode, model.CityCode, model.DistrictCode = BaseOrganizationDao.GetGovAreaInfo(areaCode)
	//组织机构类型 1：教育局 2：学校 3：部门 4：院 5：系 6：专业 7：教辅单位,8:大学区
	model.OrgType = in.OrgType
	switch model.OrgType {
	case 1, 2, 7, 8:
		model.ParentId = Const.ZeroGuid //默认是一组0的GUID号
		model.BureauId = model.OrgId    //默认是自己的单位号
		break
	default:
		model.ParentId = in.ParentId
		model.BureauId = in.BureauId
		break
	}
	model.OrgCode = in.OrgCode
	model.OrgName = in.OrgName
	model.AreaCode = in.AreaCode
	model.EduAssistType = in.EduAssistType
	//主校ID不传默认是一堆0
	if in.MainSchoolId == "" {
		model.MainSchoolId = model.BureauId
	} else {
		//否则听传入的
		model.MainSchoolId = in.MainSchoolId
	}
	//没有是否分校标识
	if in.IsBranchSchool == 0 {
		//指教育局，教辅单位或部门时
		model.MainSchoolType = 100
	} else if in.IsBranchSchool == -1 { //不是分校,普通学校
		model.MainSchoolType = 1
	} else {
		//分校,
		model.MainSchoolType = 3
		//设置它的父校ID和修改父校的主分校标识
		_, err = BaseOrganizationDao.UpdateMainSchoolTypeById(model.MainSchoolId, 2)
		if err != nil {
			reply.Success = false
			reply.Message = err.Error()
			return &reply, err
		}
	}
	model.Xxbxlxm = in.Xxbxlxm
	model.Szdcxlxm = in.Szdcxlxm
	model.Xxjbzm = in.Xxjbzm
	model.Fzr = in.Fzr
	model.Fddbr = in.Fddbr
	model.Fddbrdh = in.Fddbrdh
	model.Address = in.Address
	model.Lxdh = in.Lxdh
	model.OrgLng = in.OrgLng
	model.OrgLat = in.OrgLat
	model.SortId = in.SortId
	model.ManagerAreaCode = in.ManagerAreaCode
	//如果不传递排序号
	if in.SortId == 0 {
		model.SortId, err = BaseOrganizationDao.MaxOrgSortId(in.ParentId)
		if err != nil {
			reply.Success = false
			reply.Message = Const.DataBaseActionError
			LogUtil.Error(ErrorConst.SqlUpdateError, "执行MaxOrgSortId时发生严重错误："+err.Error())
			return nil, err
		}
		//如果添加了一个部门，排序号是9999，那么再增加一个，不写排序号，就应该是10000，但前端要求不能大于9999，所以~
		if model.SortId > 9999 {
			model.SortId = 9999
		}
	}
	model.BUse = 1

	_, err = BaseOrganizationDao.AddBaseOrganization(*model)
	if err != nil {
		reply.Success = false
		reply.Message = Const.DataBaseActionError
		LogUtil.Error(ErrorConst.SqlUpdateError, "执行AddBaseOrganization时发生严重错误："+err.Error())
		return nil, err
	}
	//保存附设班信息
	BaseOrganizationDao.UpdateFsb(model.BureauId, in.FsbIds)
	// *********************************************************************//
	// 组织机构类型 1：教育局 2：学校 3：部门 4：院 5：系 6：专业 7：教辅单位,8:大学区
	// 如果是学校，教辅单位，大学区的话，需要生成管理员账号
	// *********************************************************************//
	if CommonUtil.IsContainInt32([]int32{2, 7, 8}, model.OrgType) {
		err = UpdateManager(model.OrgId, 1)
		if err != nil {
			reply.Success = false
			reply.Message = Const.DataBaseActionError
			LogUtil.Error(ErrorConst.SqlUpdateError, "执行updateManager时发生严重错误："+err.Error())
			return nil, err
		}
	}
	//记录日志
	err = BaseOrganizationDao.ActionLog([]models.TBaseOrganization{*model}, Const.ActionInsert, in.ActionPersonId, in.ActionIpAddress)
	if err != nil {
		reply.Success = false
		reply.Message = Const.DataBaseActionError
		LogUtil.Error(ErrorConst.SqlUpdateError, "执行ActionLog时发生严重错误："+err.Error())
		return nil, err
	}
	//是否传递了部门管理员 ,黄海添加于2020-06-04
	if len(in.OrgManagerIds) > 0 {
		err = BaseOrganizationManagerDao.UpdateOrgManager(model.OrgId, in.OrgManagerIds)
		if err != nil {
			reply.Success = false
			reply.Message = Const.DataBaseActionError
			LogUtil.Error(ErrorConst.SqlUpdateError, "执行UpdateOrgManager时发生严重错误："+err.Error())
			return nil, err
		}
	}
	//返回信息
	reply.Success = true
	reply.Message = Const.SuccessDataBaseAction
	return &reply, err
}

//删除
func (s *Rpc) DeleteBaseOrganization(ctx context.Context, in *BaseOrganizationProto.DeleteIdsArg) (*BaseOrganizationProto.Reply, error) {
	//异常处理
	defer func() {
		if err := recover(); err != nil {
			fmt.Printf("%s\n", err)
		}
	}()
	//rpc响应
	var reply BaseOrganizationProto.Reply

	//遍历每一个单位+部门进行检查
	for i := range in.Ids {
		//判断部门下是不是有可用的人员
		var inTeacher BaseTeacherProto.QueryArg
		inTeacher.Page = 1
		inTeacher.Limit = 1
		inTeacher.OrgId = in.Ids[i]
		inTeacher.Xm = ""
		_, count, err := BaseTeacherDao.PageBaseTeacher(&inTeacher)
		if err != nil {
			LogUtil.Error(ErrorConst.SqlUpdateError, "执行PageBaseTeacher时发生严重错误："+err.Error())
			reply.Success = false
			reply.Message = Const.DataBaseActionError
			return &reply, err
		}
		if count > 0 {
			reply.Success = false
			//判断是单位还是部门
			if BaseOrganizationDao.IsBuMen(inTeacher.OrgId) {
				reply.Message = "部门下存在教工数据，无法删除！"
			} else {
				reply.Message = "单位下存在教工数据，无法删除！"
			}
			return &reply, err
		}
		//判断部门下是不是有可用的子部门
		_, count, err = BaseOrganizationDao.GetChildOrg(in.Ids[i])
		if err != nil {
			LogUtil.Error(ErrorConst.SqlUpdateError, "执行GetChildOrg时发生严重错误："+err.Error())
			reply.Success = false
			reply.Message = Const.DataBaseActionError
			return &reply, err
		}
		if count > 0 {
			reply.Success = false
			//判断是单位还是部门
			if BaseOrganizationDao.IsBuMen(inTeacher.OrgId) {
				reply.Message = "部门下存在子部门，无法删除！"
			} else {
				reply.Message = "单位下存在子部门，无法删除！"
			}
			return &reply, err
		}
		//判断是不是有可用的班级
		exist, err := BaseClassDao.ExistClass(in.Ids[i])
		if err != nil {
			LogUtil.Error(ErrorConst.SqlUpdateError, "执行ExistClass时发生严重错误："+err.Error())
			reply.Success = false
			reply.Message = Const.DataBaseActionError
			return &reply, err
		}
		if exist {
			reply.Success = false
			//判断是单位还是部门
			if BaseOrganizationDao.IsBuMen(inTeacher.OrgId) {
				reply.Message = "部门下存在班级，无法删除！"
			} else {
				reply.Message = "单位下存在班级，无法删除！"
			}
			return &reply, err
		}
	}
	//记录日志
	ms, err := BaseOrganizationDao.GetByIds(in.Ids)
	if err != nil {
		LogUtil.Error(ErrorConst.SqlUpdateError, "执行FindModelsByIds时发生严重错误："+err.Error())
		reply.Success = false
		reply.Message = Const.DataBaseActionError
		return &reply, err
	}
	err = BaseOrganizationDao.ActionLog(ms, Const.ActionDelete, in.ActionPersonId, in.ActionIpAddress)
	if err != nil {
		LogUtil.Error(ErrorConst.SqlUpdateError, "执行ActionLog时发生严重错误："+err.Error())
		reply.Success = false
		reply.Message = Const.DataBaseActionError
		return &reply, err
	}
	//删除部门管理员
	err = BaseOrganizationManagerDao.DeleteOrgManagerByOrgIds(in.Ids)
	//错误处理
	if err != nil {
		LogUtil.Error(ErrorConst.SqlUpdateError, "执行DeleteOrgManagerByOrgIds时发生严重错误："+err.Error())
		reply.Success = false
		reply.Message = Const.DataBaseActionError
		return &reply, err
	}
	//调用通用删除命令进行删除
	err = SqlKit.DeleteIds("t_base_organization", in.Ids)
	//错误处理
	if err != nil {
		LogUtil.Error(ErrorConst.SqlUpdateError, "执行DeleteBaseOrganization时发生严重错误："+err.Error())
		reply.Success = false
		reply.Message = Const.DataBaseActionError
		return &reply, err
	}
	//对此单位管理员设置为不可用，包括三个内容，t_base_teacher,t_sys_loginperson,t_base_role_person
	err = BaseOrganizationDao.DisableBureauManager(in.Ids)
	if err != nil {
		LogUtil.Error(ErrorConst.SqlUpdateError, "执行DisableBureauManager时发生严重错误："+err.Error())
		reply.Success = false
		reply.Message = Const.DataBaseActionError
		return &reply, err
	}
	reply.Success = true
	reply.Message = Const.SuccessDataBaseAction
	return &reply, err
}

//修改
func (s *Rpc) UpdateBaseOrganization(ctx context.Context, in *BaseOrganizationProto.ModelArg) (*BaseOrganizationProto.Reply, error) {
	//异常处理
	defer func() {
		if err := recover(); err != nil {
			fmt.Printf("%s\n", err)
		}
	}()
	//rpc响应
	var reply BaseOrganizationProto.Reply
	//1、指定的org_code是否存在
	list := SqlKit.QueryByIds([]string{in.OrgId}, "t_base_organization")
	if list == nil || len(list) == 0 {
		reply.Success = false
		reply.Message = "输入的OrgId无法找到对应的单位ID！"
		return &reply, nil
	}
	//根据OrgId换取回bureau_id 黄海修改于2020-07-16
	bureauId := list[0]["bureau_id"].(string)
	exist, err := BaseOrganizationDao.IsExistOrgCode(in.OrgCode, bureauId, in.OrgType, in.OrgId)
	if err != nil {
		reply.Success = false
		reply.Message = ""
		LogUtil.Error(ErrorConst.SqlQueryError, "执行IsExistOrgCode时发生严重错误："+err.Error())
		return &reply, err
	}

	if exist {
		reply.Success = false
		if BaseOrganizationDao.IsBuMen(in.OrgId) {
			reply.Message = "部门代码已存在，无法修改！"
		} else {
			reply.Message = "单位代码已存在，无法修改！"
		}

		return &reply, err
	}
	//2、检查机构名称是否存在,否则在导入人员时，不知道向哪个单位下进行导入
	exist, err = BaseOrganizationDao.IsExistOrgName(in.OrgName, bureauId, in.OrgType, in.OrgId)
	if err != nil {
		reply.Success = false
		reply.Message = Const.DataBaseActionError
		LogUtil.Error(ErrorConst.SqlQueryError, "执行IsExistOrgName时发生严重错误："+err.Error())
		return &reply, err
	}
	if exist {
		reply.Success = false
		if BaseOrganizationDao.IsBuMen(in.OrgId) {
			reply.Message = "部门名称已存在，无法修改！"
		} else {
			reply.Message = "单位名称已存在，无法修改！"
		}
		return &reply, err
	}
	//3、修改
	model := new(models.TBaseOrganization)
	model.OrgId = in.OrgId
	model.OrgCode = in.OrgCode
	model.OrgName = in.OrgName
	model.ParentId = in.ParentId
	model.BureauId = bureauId
	model.OrgType = in.OrgType
	model.EduAssistType = in.EduAssistType
	model.MainSchoolId = in.MainSchoolId
	model.ManagerAreaCode = in.ManagerAreaCode
	//如果需要修改AreaCode
	if in.AreaCode != "" {
		model.AreaCode = in.AreaCode
	}
	//如果没有是否分校标识时，
	if in.IsBranchSchool == 0 {
		model.MainSchoolType = 99
	} else if in.IsBranchSchool == -1 {
		//普通学校
		model.MainSchoolType = 1
		//查看它有没有父校？
		mainSchoolId := list[0]["main_school_id"]
		if mainSchoolId != "" {
			//如果有父校，父校ID是不是还有其它孩子
			count, err := BaseOrganizationDao.GetChildSchoolCount(mainSchoolId.(string))
			if err != nil {
				reply.Success = false
				reply.Message = Const.DataBaseActionError
				LogUtil.Error(ErrorConst.SqlUpdateError, "执行GetChildSchoolCount时发生严重错误："+err.Error())
				return &reply, err
			}
			if count == 1 {
				//都没有，需要修改父校ID为普通校
				_, err = BaseOrganizationDao.UpdateMainSchoolTypeById(list[0]["main_school_id"].(string), 1)
				if err != nil {
					reply.Success = false
					reply.Message = err.Error()
					return &reply, err
				}
			}
		}
	} else if in.IsBranchSchool == 1 { //分校
		//分校
		model.MainSchoolType = 3
		//设置它的父校ID和修改父校的主分校标识
		_, err = BaseOrganizationDao.UpdateMainSchoolTypeById(model.MainSchoolId, 2)
		if err != nil {
			reply.Success = false
			reply.Message = Const.DataBaseActionError
			LogUtil.Error(ErrorConst.SqlUpdateError, "执行UpdateMainSchoolTypeById时发生严重错误："+err.Error())
			return nil, err
		}
	}
	model.Xxbxlxm = in.Xxbxlxm
	model.Szdcxlxm = in.Szdcxlxm
	model.Xxjbzm = in.Xxjbzm
	model.Fzr = in.Fzr
	model.Fddbr = in.Fddbr
	model.Fddbrdh = in.Fddbrdh
	model.Address = in.Address
	model.Lxdh = in.Lxdh
	model.OrgLng = in.OrgLng
	model.OrgLat = in.OrgLat
	model.SortId = in.SortId
	model.BUse = in.BUse
	_, err = BaseOrganizationDao.UpdateBaseOrganization(*model, in.ForceUpdateFields)
	if err != nil {
		reply.Success = false
		reply.Message = Const.DataBaseActionError
		LogUtil.Error(ErrorConst.SqlUpdateError, "执行UpdateBaseOrganization时发生严重错误："+err.Error())
		return nil, err
	}
	//保存附设班信息
	BaseOrganizationDao.UpdateFsb(model.BureauId, in.FsbIds)

	//是否传递了部门管理员 ,黄海添加于2020-06-04
	if len(in.OrgManagerIds) > 0 && len(in.OrgManagerIds[0]) > 0 {
		err = BaseOrganizationManagerDao.UpdateOrgManager(model.OrgId, in.OrgManagerIds)
		if err != nil {
			reply.Success = false
			reply.Message = Const.DataBaseActionError
			LogUtil.Error(ErrorConst.SqlUpdateError, "执行UpdateOrgManager时发生严重错误："+err.Error())
			return nil, err
		}
	} else {
		//删除部门领导
		BaseOrganizationManagerDao.DeleteOrgManagerByOrgIds([]string{in.OrgId})
	}
	//记录日志
	ms, err := BaseOrganizationDao.GetByIds([]string{in.OrgId})
	if err != nil {
		LogUtil.Error(ErrorConst.SqlUpdateError, "执行FindModelsByIds时发生严重错误："+err.Error())
		reply.Success = false
		reply.Message = Const.DataBaseActionError
		return &reply, err
	}
	err = BaseOrganizationDao.ActionLog(ms, Const.ActionUpdate, in.ActionPersonId, in.ActionIpAddress)
	if err != nil {
		reply.Success = false
		reply.Message = Const.DataBaseActionError
		LogUtil.Error(ErrorConst.SqlUpdateError, "执行ActionLog时发生严重错误："+err.Error())
		return nil, err
	}
	reply.Success = true
	reply.Message = Const.SuccessDataBaseAction
	return &reply, nil
}

//分页查询显示
func (s *Rpc) PageBaseOrganization(ctx context.Context, in *BaseOrganizationProto.QueryArg) (*BaseOrganizationProto.Reply, error) {
	//异常处理
	defer func() {
		if err := recover(); err != nil {
			fmt.Printf("%s\n", err)
		}
	}()
	//rpc响应
	var reply BaseOrganizationProto.Reply
	//检查传入的area_code是否存在
	exist, err := GovAreaDao2.ExistAreaCode(in.AreaCode)
	//错误处理
	if err != nil {
		reply.Success = false
		reply.Message = Const.DataBaseActionError
		LogUtil.Error(ErrorConst.SqlQueryError, "执行ExistAreaCode时发生严重错误："+err.Error())
		return &reply, err
	}
	if !exist {
		reply.Success = false
		reply.Message = "传入的区域代码不存在！"
		return &reply, nil
	}
	list, count, err := BaseOrganizationDao.PageBaseOrganization(in)
	//错误处理
	if err != nil {
		reply.Success = false
		reply.Message = Const.DataBaseActionError
		LogUtil.Error(ErrorConst.SqlQueryError, "执行PageBaseOrganization时发生严重错误："+err.Error())
		return &reply, err
	}
	if list != nil {
		reply.Count = count
		reply.Success = true
		reply.Message = Const.SuccessDataBaseAction
		reply.List = CommonUtil.SerializeToString(list)
		return &reply, nil
	} else {
		reply.Count = 0
		reply.Success = false
		reply.Message = Const.DataBaseBlankResult
		reply.List = Const.BlankArrayString
		return &reply, nil
	}
}

//一次查询多个
func (s *Rpc) GetMultipleBaseOrganization(ctx context.Context, in *BaseOrganizationProto.MultipleQueryArg) (*BaseOrganizationProto.Reply, error) {
	//异常处理
	defer func() {
		if err := recover(); err != nil {
			fmt.Printf("%s\n", err)
		}
	}()
	//rpc响应
	var reply BaseOrganizationProto.Reply

	list, count, err := BaseOrganizationDao.GetMultipleBaseOrganization(in.Ids)
	//错误处理
	if err != nil {
		reply.Success = false
		reply.Message = Const.DataBaseActionError
		LogUtil.Error(ErrorConst.SqlQueryError, "执行GetMultipleBaseOrganization时发生严重错误："+err.Error())
		return &reply, err
	}
	if list != nil {
		reply.Count = count
		reply.Success = true
		reply.Message = Const.SuccessDataBaseAction
		reply.List = CommonUtil.SerializeToString(list)
		return &reply, nil
	} else {
		reply.Count = 0
		reply.Success = false
		reply.Message = Const.DataBaseBlankResult
		reply.List = Const.BlankArrayString
		return &reply, nil
	}
}

//通过单位ID，获取单位及单位下所有的部门信息，组装成结构体返回，用于构建树
func (s *Rpc) GetBureauOrgTree(ctx context.Context, in *BaseOrganizationProto.ModelArg) (*BaseOrganizationProto.Reply, error) {
	//异常处理
	defer func() {
		if err := recover(); err != nil {
			fmt.Printf("%s\n", err)
		}
	}()
	//rpc响应
	var reply BaseOrganizationProto.Reply
	//调用Dao层方法获取数据
	list, count, err := BaseOrganizationDao.GetBureauOrgTree(in.BureauId)
	//错误处理
	if err != nil {
		reply.Success = false
		reply.Message = Const.DataBaseActionError
		LogUtil.Error(ErrorConst.SqlQueryError, "执行GetBureauOrgTree时发生严重错误："+err.Error())
		return &reply, err
	}
	if list != nil {
		//返回结果
		reply.Count = count
		reply.Success = true
		reply.Message = Const.SuccessDataBaseAction
		reply.List = CommonUtil.SerializeToString(list)
		return &reply, nil
	} else {
		//返回结果
		reply.Count = 0
		reply.Success = false
		reply.Message = Const.DataBaseBlankResult
		reply.List = Const.BlankArrayString
		return &reply, nil
	}
}

//根据一个或多个部门ID获取部门领导
func (s *Rpc) GetOrgManager(ctx context.Context, in *BaseOrganizationProto.MultipleQueryArg) (*BaseOrganizationProto.Reply, error) {
	//异常处理
	defer func() {
		if err := recover(); err != nil {
			fmt.Printf("%s\n", err)
		}
	}()
	//rpc响应
	var reply BaseOrganizationProto.Reply
	//调用Dao层方法获取数据
	list, count, err := BaseOrganizationDao.GetOrgManager(in.Ids)
	//错误处理
	if err != nil {
		reply.Success = false
		reply.Message = Const.DataBaseActionError
		LogUtil.Error(ErrorConst.SqlQueryError, "执行GetOrgManager时发生严重错误："+err.Error())
		return &reply, err
	}
	if list != nil {
		//返回结果
		reply.Count = count
		reply.Success = true
		reply.Message = Const.SuccessDataBaseAction
		reply.List = CommonUtil.SerializeToString(list)
		return &reply, nil
	} else {
		//返回结果
		reply.Count = 0
		reply.Success = false
		reply.Message = Const.SuccessDataBaseAction
		reply.List = Const.BlankArrayString
		return &reply, nil
	}
}

/***************************************************************************************************/
/**
功能：维护教育局、单位、学校管理员
作者：黄海
时间：2020-05-30
*/
func UpdateManager(bureauId string, bUse int32) error {
	//使用通用方法获取单条记录
	list := SqlKit.QueryByIds([]string{bureauId}, "t_base_organization")
	if list == nil || len(list) == 0 {
		return errors.New("无法找到指定的单位ID")
	}
	bureauName := list[0]["org_name"].(string)
	orgType := int32(list[0]["org_type"].(float64))
	//组织机构类型 1：教育局 2：学校 3：部门 4：院 5：系 6：专业 7：教辅单位,8:大学区
	//1、维护t_base_teacher
	//检查这个单位的管理员，是不是已经创建，如果不存在则创建，如果存在， 修改可用状态为1
	exist, personId := BaseRolePersonDao.VirtualManagerExist(bureauId)
	//如果不存在
	if !exist {
		//(1)插入基本人员信息
		model := new(models.TBaseTeacher)
		personId = CommonUtil.GetUUID()
		model.PersonId = personId
		model.IdentityId = 1
		model.Xm = bureauName + "管理员"
		model.Xmpy = PinYinUtil.PinYin("管理员")
		model.Cym = model.Xm
		model.Xbm = "男"
		model.Csrq = DateUtil.ConvertDate("1977-10-11")
		model.Mzm = "1"
		model.Zzmmm = "13"
		model.Sfzjlxm = "4"
		model.Sfzjh = "220223197805221125"
		model.Xlm = "90"
		model.Xwm = "0"
		model.Zcm = "5"
		model.Bzlbm = "9"
		model.Cjny = DateUtil.ConvertDate("1999-09-01")
		model.StageId = "Z"
		model.SubjectId = "99"
		model.Gwzym = "80"
		model.Lxdh = "18888888888"
		model.Dzxx = "xx@dsideal.com"
		model.BUse = 1
		var db = DbUtil.Engine
		var session = db.NewSession()
		_, err := BaseTeacherDao.AddBaseTeacher(session, *model)
		if err != nil {
			session.Rollback()
			return err
		}
		//生成人员的组织机构数据
		_, _, _, err = BaseTeacherDao.AddTeacherOrgInfo(session, []string{personId}, bureauId, 1, 1)
		if err != nil {
			session.Rollback()
			return err
		}
		//(2)生成登录名和密码
		accountArray := SysLoginpersonService.GenerateLoginAccount(1, 1)
		modelLoginPerson := new(models.TSysLoginperson)
		modelLoginPerson.Id = CommonUtil.GetUUID()
		modelLoginPerson.LoginName = accountArray[0].LoginName
		modelLoginPerson.Pwd = accountArray[0].Pwd
		modelLoginPerson.OriginalPwd = accountArray[0].OriginalPwd
		modelLoginPerson.IdentityId = 1
		modelLoginPerson.PersonId = personId
		modelLoginPerson.PersonName = model.Xm
		modelLoginPerson.BUse = 1
		_, err = SysLoginpersonDao.AddSysLoginPerson(session, *modelLoginPerson)
		if err != nil {
			session.Rollback()
			return err
		}
		session.Commit()

		//(3)、t_base_role
		modelBaseRolePerson := new(models.TBaseRolePerson)
		modelBaseRolePerson.Id = CommonUtil.GetUUID()
		var RoleId string
		if orgType == 2 {
			//学校
			RoleId = Const.SchoolManager
		} else {
			RoleId = Const.EduOrgManager
		}
		modelBaseRolePerson.RoleId = RoleId
		modelBaseRolePerson.IdentityId = 1
		modelBaseRolePerson.PersonId = model.PersonId
		modelBaseRolePerson.RuleId = bureauId //具体管辖是哪个省、市、区或大学区ID，单位ID
		modelBaseRolePerson.BUse = 1
		_, err = BaseRolePersonDao.AddBaseRolePerson(*modelBaseRolePerson)
		if err != nil {
			return err
		}
	} else {
		//存在，则需要修改bUse
		_, err := BaseRolePersonDao.UpdateManagerStatus(bureauId, bUse)
		if err != nil {
			return err
		}
	}
	return nil
}

/**
功能：启用教育局
作者：黄海
时间：2020-06-08
*/
func (s *Rpc) SetEnableEdu(ctx context.Context, in *BaseOrganizationProto.MultipleQueryArg) (*BaseOrganizationProto.Reply, error) {
	//异常处理
	defer func() {
		if err := recover(); err != nil {
			fmt.Printf("%s\n", err)
		}
	}()
	//rpc响应
	var reply BaseOrganizationProto.Reply
	//设置为启用状态
	err := BaseOrganizationDao.SetEduStatus(in.Ids, 1)
	if err != nil {
		reply.Success = false
		reply.Message = Const.DataBaseActionError
		LogUtil.Error(ErrorConst.SqlQueryError, "执行SetEnableEdu时发生严重错误："+err.Error())
		return &reply, err
	}
	//返回结果
	reply.Count = int32(len(in.Ids))
	reply.Success = true
	reply.Message = Const.SuccessDataBaseAction
	return &reply, nil
}

/**
功能：禁用教育局
作者：黄海
时间：2020-06-08
*/
func (s *Rpc) SetDisableEdu(ctx context.Context, in *BaseOrganizationProto.MultipleQueryArg) (*BaseOrganizationProto.Reply, error) {
	//异常处理
	defer func() {
		if err := recover(); err != nil {
			fmt.Printf("%s\n", err)
		}
	}()
	//rpc响应
	var reply BaseOrganizationProto.Reply
	//设置为禁用状态
	err := BaseOrganizationDao.SetEduStatus(in.Ids, -1)
	if err != nil {
		reply.Success = false
		reply.Message = Const.DataBaseActionError
		LogUtil.Error(ErrorConst.SqlQueryError, "执行SetDisableEdu时发生严重错误："+err.Error())
		return &reply, err
	}
	//返回结果
	reply.Count = int32(len(in.Ids))
	reply.Success = true
	reply.Message = Const.SuccessDataBaseAction
	return &reply, nil
}

//根据单位名称的关键字和管理员的人员ID查询单位列表
func (s *Rpc) ListOrgInfoByOrgKeyWord(ctx context.Context, in *BaseOrganizationProto.ListOrgArg) (*BaseOrganizationProto.Reply, error) {
	//异常处理
	defer func() {
		if err := recover(); err != nil {
			fmt.Printf("%s\n", err)
		}
	}()
	//rpc响应
	var reply BaseOrganizationProto.Reply
	//获取关键字单位
	list, err := BaseOrganizationDao.ListOrgInfoByOrgKeyWord(in.PersonId, in.OrgKeyWord)
	if err != nil {
		reply.Success = false
		reply.Message = Const.DataBaseActionError
		LogUtil.Error(ErrorConst.SqlQueryError, "执行ListOrgInfoByOrgKeyWord时发生严重错误："+err.Error())
		return &reply, err
	}
	//返回结果
	reply.Count = int32(len(list))
	reply.Success = true
	reply.Message = Const.SuccessDataBaseAction
	reply.List = CommonUtil.SerializeToString(list)
	return &reply, nil
}

//根据市的行政区划码获取教育局列表
func (s *Rpc) ListEduByCityCode(ctx context.Context, in *BaseOrganizationProto.CityCodeArg) (*BaseOrganizationProto.Reply, error) {
	//异常处理
	defer func() {
		if err := recover(); err != nil {
			fmt.Printf("%s\n", err)
		}
	}()
	//rpc响应
	var reply BaseOrganizationProto.Reply
	//获取关键字单位
	list, err := BaseOrganizationDao.ListEduByCityCode(in.CityCode)
	if err != nil {
		reply.Success = false
		reply.Message = Const.DataBaseActionError
		LogUtil.Error(ErrorConst.SqlQueryError, "执行ListEduByCityCode时发生严重错误："+err.Error())
		return &reply, err
	}
	//返回结果
	reply.Count = int32(len(list))
	reply.Success = true
	reply.Message = Const.SuccessDataBaseAction
	return &reply, nil
}