gin_server_admin/api/admin/groupmanagement/branchfactorygroup/branchfactory.go

package branchfactorygroup

import (
	"strconv"
	"time"

	"gin_server_admin/commonus"
	"gin_server_admin/global"
	"gin_server_admin/model/common/response"
	"gin_server_admin/model/testpage"
	"github.com/gin-gonic/gin"
)

/*
====================================================
分厂基础设定
====================================================
*/
//入口
func (b *BranchFactory) Index(c *gin.Context) {
	outPut := commonus.MapOut()
	response.Result(0, outPut, "分厂基础设定获取成功", c)
}

// 获取分厂栏目
func (b *BranchFactory) BranchFactoryList(c *gin.Context) {
	isTrue, SysAdminCont := commonus.AdminClientIdentity()
	if isTrue != true {
		response.Result(101, isTrue, "您的身份令牌已经失效！请重新登录获取身份令牌！", c)
		return
	}

	var requestData BranchFactoryList
	c.ShouldBindJSON(&requestData)
	if requestData.PageSize == 0 {
		requestData.PageSize = 20
	}
	if requestData.Page <= 0 {
		requestData.Page = 1
	}
	offSetPage := commonus.CalculatePages(requestData.Page, requestData.PageSize)
	gormDb := global.GVA_DB_Master.Model(&testpage.BranchFactory{})

	if SysAdminCont.Group != "1" {
		gormDb = gormDb.Where("`bf_group` = ?", SysAdminCont.Group)
		if SysAdminCont.AttriBute != "0" {
			gormDb = gormDb.Where("`bf_id` = ?", SysAdminCont.AttriBute)
		}
	}
	if requestData.State != 0 {
		gormDb = gormDb.Where("`bf_set` = ?", requestData.State)
	}
	if requestData.GroupId != 0 {
		gormDb = gormDb.Where("`bf_group` = ?", requestData.GroupId)
	}
	if requestData.Attribute != 0 {
		gormDb = gormDb.Where("`bf_attribute` = ?", requestData.Attribute)
	}
	if requestData.Title != "" {
		gormDb = gormDb.Where("(`bf_name` LIKE ?)", "%"+requestData.Title+"%")
	}
	var total int64
	totalErr := gormDb.Count(&total).Error
	if totalErr != nil {
		total = 0
	}
	var systemRoleList []testpage.BranchFactory
	systemRoleListerr := gormDb.Limit(requestData.PageSize).Offset(offSetPage).Order("bf_id desc").Find(&systemRoleList).Error
	if systemRoleListerr != nil {
		response.Result(102, systemRoleListerr, "数据获取失败！", c)
		return
	}
	var putBfList []PrintBranchFactoryList
	for _, val := range systemRoleList {
		var putBfCont PrintBranchFactoryList
		putBfCont.Id = val.Id
		putBfCont.Name = val.Name
		putBfCont.Set = val.Set
		putBfCont.Uid = val.Uid
		putBfCont.Time = val.Time
		putBfCont.Attribute = val.Attribute
		putBfCont.Group = val.Group
		putBfCont.WechatId = val.WechatId
		groupIsTrue, groupCont := commonus.GetGroupInfo(val.Group)
		if groupIsTrue == true {
			putBfCont.GroupName = groupCont.Name
		}
		putBfList = append(putBfList, putBfCont)
	}

	countSum := len(putBfList)
	printData := commonus.OutPutList(total, int64(countSum), requestData.Page, requestData.PageSize, putBfList)
	response.Result(0, printData, "查询成功！", c)
}

// 添加分厂
func (b *BranchFactory) AddBranchFactory(c *gin.Context) {
	isTrue, SysAdminCont := commonus.AdminClientIdentity()
	if isTrue != true {
		response.Result(101, isTrue, "您的身份令牌已经失效！请重新登录获取身份令牌！", c)
		return
	}
	var requestData AddBranchFactory
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(102, requestData, "数据获取失败！", c)
		return
	}
	if requestData.Title == "" {
		response.Result(103, requestData, "请输入分厂（部室）名称！", c)
		return
	}
	if requestData.GroupId == 0 {
		response.Result(104, requestData, "请输入分厂（部室）归属哪个集团！", c)
		return
	}
	if requestData.Attribute == 0 {
		requestData.Attribute = 1
	}
	var bfCont testpage.BranchFactory
	userKey, userKeyErr := strconv.ParseInt(SysAdminCont.UserKey, 10, 64)

	//判断该分厂是否已经存在
	juadgeMap := commonus.MapOut()
	juadgeBfErr := global.GVA_DB_Master.Model(&testpage.BranchFactory{}).Select("bf_name").Where("`bf_name` = ? AND `bf_group` = ?", requestData.Title, requestData.GroupId).First(&juadgeMap).Error
	if juadgeBfErr == nil {
		response.Result(106, juadgeMap, "该集团下已经存在此分厂!请不要重复添加！", c)
		return
	}
	if requestData.WechatId != 0 {
		juadgeBfErrs := global.GVA_DB_Master.Model(&testpage.BranchFactory{}).Select("bf_wechat_id").Where("`bf_wechat_id` = ?", requestData.WechatId).First(&juadgeMap).Error
		if juadgeBfErrs == nil {
			response.Result(106, juadgeMap, "此微信ID已经使用!请不要重复添加！", c)
			return
		}
	}

	bfCont.Name = requestData.Title
	bfCont.Set = 1
	if userKeyErr == nil {
		bfCont.Uid = userKey
	}
	bfCont.Time = time.Now().Unix()
	bfCont.Attribute = requestData.Attribute
	bfCont.Group = requestData.GroupId
	bfCont.WechatId = requestData.WechatId
	addErr := global.GVA_DB_Master.Create(&bfCont).Error
	if addErr != nil {
		response.Result(105, requestData, "添加失败!", c)
	} else {
		response.Result(0, bfCont, "添加成功!", c)
	}
}

// 获取分厂（部室）详细信息
func (b *BranchFactory) GetBranchFactory(c *gin.Context) {
	var requestData commonus.SetIds
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(102, requestData, "数据获取失败！", c)
		return
	}
	if requestData.Id == 0 && requestData.OutId == "" {
		response.Result(102, err, "参数错误！请重新提交！", c)
		return
	}
	if requestData.OutId != "" {
		idInt, inIntErr := strconv.ParseInt(requestData.OutId, 10, 64)
		if inIntErr == nil {
			requestData.Id = idInt
		}
	}
	var systemBFCont testpage.BranchFactory
	contErr := global.GVA_DB_Master.Where("`bf_id` = ?", requestData.Id).First(&systemBFCont).Error
	if contErr != nil {
		response.Result(102, err, "数据获取失败！", c)
		return
	}
	response.Result(0, systemBFCont, "数据获取成功！", c)
}

// 修改分厂内容
func (b *BranchFactory) EiteBranchFactory(c *gin.Context) {
	var requestData EiteBranchFactory
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, requestData, "数据获取失败！", c)
		return
	}
	if requestData.Id == 0 && requestData.OutId == "" {
		response.Result(102, err, "参数错误！请重新提交！", c)
		return
	}
	if requestData.OutId != "" {
		idInt, inIntErr := strconv.ParseInt(requestData.OutId, 10, 64)
		if inIntErr == nil {
			requestData.Id = idInt
		}
	}
	var systemBFCont testpage.BranchFactory
	contErr := global.GVA_DB_Master.Where("`bf_id` = ?", requestData.Id).First(&systemBFCont).Error
	if contErr != nil {
		response.Result(103, contErr, "数据获取失败！", c)
		return
	}
	saveData := commonus.MapOut()
	if requestData.Title != "" && requestData.Title != systemBFCont.Name {
		juadgeMaps := commonus.MapOut()
		contErr := global.GVA_DB_Master.Model(&testpage.BranchFactory{}).Where("`bf_name` = ? AND `bf_group` = ?", requestData.Title, requestData.GroupId).First(&juadgeMaps).Error
		if contErr == nil {
			response.Result(104, juadgeMaps, "该集团下已经存在此分厂!请不要重复添加！", c)
			return
		} else {
			saveData["bf_name"] = requestData.Title
		}
	}
	if requestData.GroupId != 0 {
		saveData["bf_group"] = requestData.GroupId
	}
	if requestData.Attribute == 0 {
		requestData.Attribute = 1
	}
	saveData["bf_attribute"] = requestData.Attribute
	saveData["bf_time"] = time.Now().Unix()
	if requestData.WechatId != 0 && requestData.WechatId != systemBFCont.WechatId {
		juadgeMap := commonus.MapOut()
		juadgeBfErrs := global.GVA_DB_Master.Model(&testpage.BranchFactory{}).Select("bf_wechat_id").Where("`bf_wechat_id` = ?", requestData.WechatId).First(&juadgeMap).Error
		if juadgeBfErrs == nil {
			juadgeMap["systemBFCont"] = requestData.WechatId
			juadgeMap["systemBFCont"] = systemBFCont
			response.Result(105, juadgeMap, "此微信ID已经使用!请不要重复添加！", c)
			return
		} else {
			saveData["bf_wechat_id"] = requestData.WechatId
		}
	}
	roleIsTrue, roleErr := eiteBranchFactoryInfo(requestData.Id, saveData)
	if roleIsTrue != true {
		response.Result(106, roleErr, "编辑失败!", c)
	} else {
		response.Result(0, saveData, "编辑成功!", c)
	}
}

// 编辑分厂数据处理
func eiteBranchFactoryInfo(saveId int64, saveData map[string]interface{}) (isTrue bool, infoErr error) {
	isTrue = false
	infoErr = global.GVA_DB_Master.Model(&testpage.BranchFactory{}).Where("`bf_id` = ?", saveId).Updates(saveData).Error
	if infoErr != nil {
		return
	}
	isTrue = true
	return
}

// 删除分厂内容
func (b *BranchFactory) DelBranchFactory(c *gin.Context) {
	var requestData delBFType
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, requestData, "数据获取失败！", c)
		return
	}
	if requestData.Id == 0 && requestData.OutId == "" {
		response.Result(102, err, "参数错误！请重新提交！", c)
		return
	}
	if requestData.OutId != "" {
		idInt, inIntErr := strconv.ParseInt(requestData.OutId, 10, 64)
		if inIntErr == nil {
			requestData.Id = idInt
		}
	}
	if requestData.State == 0 {
		requestData.State = 1
	}
	saveData := commonus.MapOut()
	saveData["bf_set"] = requestData.State
	saveData["bf_time"] = time.Now().Unix()
	if requestData.IsDel != 1 {
		roleIsTrue, roleErr := eiteBranchFactoryInfo(requestData.Id, saveData)
		if roleIsTrue != true {
			response.Result(103, roleErr, "修改失败！", c)
			return
		}
		response.Result(0, requestData, "修改成功！", c)
	} else {
		if requestData.State == 3 {
			roleErr := global.GVA_DB_Master.Where("bf_id = ?", requestData.Id).Delete(&testpage.BranchFactory{}).Error
			if roleErr != nil {
				response.Result(104, saveData, "删除失败！", c)
				return
			}
			response.Result(0, saveData, "删除成功！", c)
		} else {
			roleIsTrue, roleErr := eiteBranchFactoryInfo(requestData.Id, saveData)
			if roleIsTrue != true {
				response.Result(103, roleErr, "修改失败！", c)
				return
			}
			response.Result(0, requestData, "修改成功！", c)
		}
	}
}