lc_veterans/app/device/service/garbageWayGroupService.go

package service

import (
	"fmt"
	"iot_manager_service/app/device/dao"
	"iot_manager_service/app/device/model"
	"iot_manager_service/app/system/service"
	"iot_manager_service/util/cache"
	"iot_manager_service/util/common"
	"time"
)

var GarbageWayGroupService = new(garbageWayGroupService)

type garbageWayGroupService struct{}

func (s *garbageWayGroupService) Get(id int) (*dao.GarbageWayGroup, *common.Errors) {
	// 创建查询实例
	device := &dao.GarbageWayGroup{
		ID: id,
	}
	err := device.GetDevice()
	if err != nil {
		return nil, common.FailResponse(err.Error(), nil)
	}
	return device, nil

}

func (s *garbageWayGroupService) CreateOrUpdate(userId int64, tenantId int, req dao.GarbageWayGroup) *common.Errors {
	// 创建查询实例
	device := req
	device.TenantId = tenantId
	device.UpdateUser = userId
	device.UpdateTime = time.Now()
	if req.ID == 0 {
		device.CreateTime = time.Now()
		device.CreateUser = userId
		if device.IsExistedByName() {
			fmt.Printf("Create GetDeviceID err \n")
			return common.ParamsInvalidResponse("存在重名,请更改名称！", nil)
		}
		if err := device.Create(); err != nil {
			fmt.Printf("Create err = %s \n", err.Error())
			return common.FailResponse(err.Error(), nil)
		}
		service.OperationHisService.Save(userId, tenantId, common.OperationCreate, common.ModuleTypeDevice,
			common.DeviceTypeGarbageGroup, common.GetDeviceObject(device.ID, device.GroupName), common.OperationSuccess)
		return common.SuccessResponse(common.Succeeded, nil)
	}
	if device.IsExistedByNameAndCode() {
		return common.ParamsInvalidResponse("列表中存在重名,请更改垃圾桶道路名称！", nil)
	}

	if err := device.Update(); err != nil {
		fmt.Printf("Update err = %s \n", err.Error())
		return common.FailResponse(err.Error(), nil)
	}

	service.OperationHisService.Save(userId, tenantId, common.OperationUpdate, common.ModuleTypeDevice,
		common.DeviceTypeGarbageGroup, common.GetDeviceObject(device.ID, device.GroupName), common.OperationSuccess)
	return common.SuccessResponse(common.Succeeded, nil)
}

func (s *garbageWayGroupService) List(searchValue string, current, size int) ([]dao.GarbageWayGroup, *common.Errors) {
	device := dao.GarbageWayGroup{}
	if searchValue != "" {
		device.GroupName = searchValue
	}

	offset := (current - 1) * size
	limit := size
	devices, err := device.GetDevices(offset, limit)
	if err != nil {
		return nil, common.FailResponse(err.Error(), nil)
	}
	return devices, nil
}

func (s *garbageWayGroupService) Remove(userId int64, tenantId int, id int) *common.Errors {
	// 创建查询实例
	device := &dao.GarbageWayGroup{
		ID:         id,
		IsDeleted:  1,
		UpdateUser: userId,
		UpdateTime: time.Now(),
	}
	err := device.Delete()
	if err != nil {
		return common.FailResponse(err.Error(), nil)
	}
	service.OperationHisService.Save(userId, tenantId, common.OperationRemove, common.ModuleTypeDevice,
		common.DeviceTypeGarbageGroup, common.GetDeviceObject(device.ID, device.GroupName), common.OperationSuccess)
	return nil
}

func (s *garbageWayGroupService) GetList(tenantId int) ([]*dao.GarbageWayGroup, *common.Errors) {
	var devices []*dao.GarbageWayGroup
	err := cache.Redis.Get(getGarbageWayGroupListRedisKey("000000")).Scan(&devices)
	if err == nil {
		return devices, nil
	}
	device := &dao.GarbageWayGroup{
		TenantId:  tenantId,
		IsDeleted: 0,
	}
	devices, err = device.GetAllDevices()
	if err != nil {
		return nil, common.FailResponse(err.Error(), nil)
	}
	_ = cache.Redis.Set(getGarbageWayGroupListRedisKey("000000"), devices, 0).Err()
	return devices, nil
}

func getGarbageWayGroupListRedisKey(tenantId string) string {
	return fmt.Sprintf(model.GarbageWayGroupList, tenantId)
}