日常提交

data/dao/manage/AuthorityDao.go

@@ -0,0 +1,76 @@
+package manage
+
+import (
+	"demo/configs"
+	"demo/data/domain"
+	"demo/data/domain/vo"
+)
+
+func GetAuthorityById(id int64) (domain.Authority, error) {
+	var authority domain.Authority
+	_, err := configs.Engine.Table("authority").Where("id = ?", id).Get(&authority)
+	if err != nil {
+		return authority, err
+	}
+	return authority, nil
+}
+
+func GetAuthorityListInId(ids []int64) ([]domain.Authority, error) {
+	rows, err := configs.Engine.Table("authority").In("id", ids).Rows(&domain.Authority{})
+	if err != nil {
+		return make([]domain.Authority, 0), err
+	}
+	defer rows.Close()
+	var list []domain.Authority
+	for rows.Next() {
+		var u domain.Authority
+		list = append(list, u)
+	}
+	return list, nil
+}
+
+func GetAuthorityList(authority domain.Authority, pageNum, pageSize int) (vo.BaseListVo, error) {
+	var arr []domain.Authority
+	Count, err := configs.Engine.Table("authority").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &authority)
+	var vo vo.BaseListVo
+	if err != nil {
+		return vo, err
+	}
+	if err != nil {
+		return vo, err
+	}
+	vo.PageNum = pageNum
+	vo.PageSize = pageSize
+	vo.List = make([]any, len(arr))
+	for i, v := range arr {
+		vo.List[i] = v
+	}
+	vo.Total = int(Count)
+	return vo, nil
+}
+
+func SaveAuthority(authority *domain.Authority) (domain.Authority, error) {
+	_, err := configs.Engine.Table("authority").Insert(&authority)
+	if err != nil {
+		return *authority, err
+	}
+	return *authority, nil
+}
+
+func SetAuthority(authorityMap map[string]interface{}, id int64) (domain.Authority, bool, error) {
+	var authority domain.Authority
+	_, err := configs.Engine.Table("authority").Where("id = ?", id).Update(authorityMap)
+	if err != nil {
+		return authority, false, err
+	}
+	return authority, true, nil
+}
+
+func DeleteAuthority(id int64) bool {
+	var authority domain.Authority
+	i, err := configs.Engine.Table("authority").Where("id = ?", id).Delete(&authority)
+	if err != nil {
+		return false
+	}
+	return i > 0
+}

data/dao/manage/DictDataDao.go

@@ -0,0 +1,78 @@
+package manage
+
+import (
+	"demo/configs"
+	"demo/data/domain"
+	"demo/data/domain/vo"
+	"fmt"
+)
+
+func GetDictDataById(id int64) (domain.DictData, error) {
+	var dictData domain.DictData
+	_, err := configs.Engine.Table("dict_data").Where("id = ?", id).Get(&dictData)
+	if err != nil {
+		return dictData, err
+	}
+	return dictData, nil
+}
+
+func GetDictDataListInId(ids []int64) ([]domain.DictData, error) {
+	rows, err := configs.Engine.Table("dict_data").In("id", ids).Rows(&domain.DictData{})
+	if err != nil {
+		return make([]domain.DictData, 0), err
+	}
+	defer rows.Close()
+	var list []domain.DictData
+	for rows.Next() {
+		var u domain.DictData
+		list = append(list, u)
+	}
+	return list, nil
+}
+
+func GetDictDataList(dictData domain.DictData, pageNum, pageSize int) (vo.BaseListVo, error) {
+	var arr []domain.DictData
+	Count, err := configs.Engine.Table("dict_data").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &dictData)
+	var vo vo.BaseListVo
+	if err != nil {
+		return vo, err
+	}
+	if err != nil {
+		return vo, err
+	}
+	vo.PageNum = pageNum
+	vo.PageSize = pageSize
+	vo.List = make([]any, len(arr))
+	for i, v := range arr {
+		vo.List[i] = v
+	}
+	vo.Total = int(Count)
+	return vo, nil
+}
+
+func SaveDictData(dictData *domain.DictData) (domain.DictData, error) {
+	_, err := configs.Engine.Table("dict_data").Insert(&dictData)
+	if err != nil {
+		return *dictData, err
+	}
+	return *dictData, nil
+}
+
+func SetDictData(dictDataMap map[string]interface{}, id int64) (domain.DictData, bool, error) {
+	var dictData domain.DictData
+	_, err := configs.Engine.Table("dict_data").Where("id = ?", id).Update(dictDataMap)
+	if err != nil {
+		fmt.Println(err)
+		return dictData, false, err
+	}
+	return dictData, true, nil
+}
+
+func DeleteDictData(id int64) bool {
+	var dictData domain.DictData
+	i, err := configs.Engine.Table("dict_data").Where("id = ?", id).Delete(&dictData)
+	if err != nil {
+		return false
+	}
+	return i > 0
+}

data/dao/manage/DictTypeDao.go

@@ -0,0 +1,76 @@
+package manage
+
+import (
+	"demo/configs"
+	"demo/data/domain"
+	"demo/data/domain/vo"
+)
+
+func GetDictTypeById(id int64) (domain.DictType, error) {
+	var dictType domain.DictType
+	_, err := configs.Engine.Table("dict_type").Where("id = ?", id).Get(&dictType)
+	if err != nil {
+		return dictType, err
+	}
+	return dictType, nil
+}
+
+func GetDictTypeListInId(ids []int64) ([]domain.DictType, error) {
+	rows, err := configs.Engine.Table("dict_type").In("id", ids).Rows(&domain.DictType{})
+	if err != nil {
+		return make([]domain.DictType, 0), err
+	}
+	defer rows.Close()
+	var list []domain.DictType
+	for rows.Next() {
+		var u domain.DictType
+		list = append(list, u)
+	}
+	return list, nil
+}
+
+func GetDictTypeList(dictType domain.DictType, pageNum, pageSize int) (vo.BaseListVo, error) {
+	var arr []domain.DictType
+	Count, err := configs.Engine.Table("dict_type").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &dictType)
+	var vo vo.BaseListVo
+	if err != nil {
+		return vo, err
+	}
+	if err != nil {
+		return vo, err
+	}
+	vo.PageNum = pageNum
+	vo.PageSize = pageSize
+	vo.List = make([]any, len(arr))
+	for i, v := range arr {
+		vo.List[i] = v
+	}
+	vo.Total = int(Count)
+	return vo, nil
+}
+
+func SaveDictType(dictType *domain.DictType) (domain.DictType, error) {
+	_, err := configs.Engine.Table("dict_type").Insert(&dictType)
+	if err != nil {
+		return *dictType, err
+	}
+	return *dictType, nil
+}
+
+func SetDictType(dictTypeMap map[string]interface{}, id int64) (domain.DictType, bool, error) {
+	var dictType domain.DictType
+	_, err := configs.Engine.Table("dict_type").Where("id = ?", id).Update(dictTypeMap)
+	if err != nil {
+		return dictType, false, err
+	}
+	return dictType, true, nil
+}
+
+func DeleteDictType(id int64) bool {
+	var dictType domain.DictType
+	i, err := configs.Engine.Table("dict_type").Where("id = ?", id).Delete(&dictType)
+	if err != nil {
+		return false
+	}
+	return i > 0
+}

data/dao/manage/ManageUserDao.go

@@ -0,0 +1,76 @@
+package manage
+
+import (
+	"demo/configs"
+	"demo/data/domain"
+	"demo/data/domain/vo"
+)
+
+func GetManageUserById(id int64) (domain.ManageUser, error) {
+	var manageUser domain.ManageUser
+	_, err := configs.Engine.Table("manage_user").Where("id = ?", id).Get(&manageUser)
+	if err != nil {
+		return manageUser, err
+	}
+	return manageUser, nil
+}
+
+func GetManageUserListInId(ids []int64) ([]domain.ManageUser, error) {
+	rows, err := configs.Engine.Table("manage_user").In("id", ids).Rows(&domain.ManageUser{})
+	if err != nil {
+		return make([]domain.ManageUser, 0), err
+	}
+	defer rows.Close()
+	var list []domain.ManageUser
+	for rows.Next() {
+		var u domain.ManageUser
+		list = append(list, u)
+	}
+	return list, nil
+}
+
+func GetManageUserList(manageUser domain.ManageUser, pageNum, pageSize int) (vo.BaseListVo, error) {
+	var arr []domain.ManageUser
+	Count, err := configs.Engine.Table("manage_user").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &manageUser)
+	var vo vo.BaseListVo
+	if err != nil {
+		return vo, err
+	}
+	if err != nil {
+		return vo, err
+	}
+	vo.PageNum = pageNum
+	vo.PageSize = pageSize
+	vo.List = make([]any, len(arr))
+	for i, v := range arr {
+		vo.List[i] = v
+	}
+	vo.Total = int(Count)
+	return vo, nil
+}
+
+func SaveManageUser(manageUser *domain.ManageUser) (domain.ManageUser, error) {
+	_, err := configs.Engine.Table("manage_user").Insert(&manageUser)
+	if err != nil {
+		return *manageUser, err
+	}
+	return *manageUser, nil
+}
+
+func SetManageUser(manageUserMap map[string]interface{}, id int64) (domain.ManageUser, bool, error) {
+	var manageUser domain.ManageUser
+	_, err := configs.Engine.Table("manage_user").Where("id = ?", id).Update(manageUserMap)
+	if err != nil {
+		return manageUser, false, err
+	}
+	return manageUser, true, nil
+}
+
+func DeleteManageUser(id int64) bool {
+	var manageUser domain.ManageUser
+	i, err := configs.Engine.Table("manage_user").Where("id = ?", id).Delete(&manageUser)
+	if err != nil {
+		return false
+	}
+	return i > 0
+}

data/dao/manage/RoleAuthorityDao.go

@@ -0,0 +1,58 @@
+package manage
+
+import (
+	"demo/configs"
+	"demo/data/domain"
+	"demo/data/domain/vo"
+)
+
+func GetRoleAuthorityListInId(ids []int64) ([]domain.RoleAuthority, error) {
+	rows, err := configs.Engine.Table("role_authority").In("id", ids).Rows(&domain.RoleAuthority{})
+	if err != nil {
+		return make([]domain.RoleAuthority, 0), err
+	}
+	defer rows.Close()
+	var list []domain.RoleAuthority
+	for rows.Next() {
+		var u domain.RoleAuthority
+		list = append(list, u)
+	}
+	return list, nil
+}
+
+func GetRoleAuthorityList(roleAuthority domain.RoleAuthority, pageNum, pageSize int) (vo.BaseListVo, error) {
+	var arr []domain.RoleAuthority
+	Count, err := configs.Engine.Table("role_authority").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &roleAuthority)
+	var vo vo.BaseListVo
+	if err != nil {
+		return vo, err
+	}
+	if err != nil {
+		return vo, err
+	}
+	vo.PageNum = pageNum
+	vo.PageSize = pageSize
+	vo.List = make([]any, len(arr))
+	for i, v := range arr {
+		vo.List[i] = v
+	}
+	vo.Total = int(Count)
+	return vo, nil
+}
+
+func SaveRoleAuthority(roleAuthority *domain.RoleAuthority) (domain.RoleAuthority, error) {
+	_, err := configs.Engine.Table("role_authority").Insert(&roleAuthority)
+	if err != nil {
+		return *roleAuthority, err
+	}
+	return *roleAuthority, nil
+}
+
+func SetRoleAuthority(roleAuthorityMap map[string]interface{}, id int64) (domain.RoleAuthority, bool, error) {
+	var roleAuthority domain.RoleAuthority
+	_, err := configs.Engine.Table("role_authority").Where("authority_id = ?", id).Update(roleAuthorityMap)
+	if err != nil {
+		return roleAuthority, false, err
+	}
+	return roleAuthority, true, nil
+}

data/dao/manage/RoleDao.go

@@ -0,0 +1,76 @@
+package manage
+
+import (
+	"demo/configs"
+	"demo/data/domain"
+	"demo/data/domain/vo"
+)
+
+func GetRoleById(id int64) (domain.Role, error) {
+	var role domain.Role
+	_, err := configs.Engine.Table("role").Where("id = ?", id).Get(&role)
+	if err != nil {
+		return role, err
+	}
+	return role, nil
+}
+
+func GetRoleListInId(ids []int64) ([]domain.Role, error) {
+	rows, err := configs.Engine.Table("role").In("id", ids).Rows(&domain.Role{})
+	if err != nil {
+		return make([]domain.Role, 0), err
+	}
+	defer rows.Close()
+	var list []domain.Role
+	for rows.Next() {
+		var u domain.Role
+		list = append(list, u)
+	}
+	return list, nil
+}
+
+func GetRoleList(role domain.Role, pageNum, pageSize int) (vo.BaseListVo, error) {
+	var arr []domain.Role
+	Count, err := configs.Engine.Table("role").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &role)
+	var vo vo.BaseListVo
+	if err != nil {
+		return vo, err
+	}
+	if err != nil {
+		return vo, err
+	}
+	vo.PageNum = pageNum
+	vo.PageSize = pageSize
+	vo.List = make([]any, len(arr))
+	for i, v := range arr {
+		vo.List[i] = v
+	}
+	vo.Total = int(Count)
+	return vo, nil
+}
+
+func SaveRole(role *domain.Role) (domain.Role, error) {
+	_, err := configs.Engine.Table("role").Insert(&role)
+	if err != nil {
+		return *role, err
+	}
+	return *role, nil
+}
+
+func SetRole(roleMap map[string]interface{}, id int64) (domain.Role, bool, error) {
+	var role domain.Role
+	_, err := configs.Engine.Table("role").Where("id = ?", id).Update(roleMap)
+	if err != nil {
+		return role, false, err
+	}
+	return role, true, nil
+}
+
+func DeleteRole(id int64) bool {
+	var role domain.Role
+	i, err := configs.Engine.Table("role").Where("id = ?", id).Delete(&role)
+	if err != nil {
+		return false
+	}
+	return i > 0
+}