package manage

import (
	"demo/configs"
	"demo/data/domain"
	"demo/data/domain/vo"
)

func GetArticleById(id int64) (domain.Article, error) {
	var article domain.Article
	_, err := configs.Engine.Table("article").Where("id = ?", id).Get(&article)
	if err != nil {
		return article, err
	}
	return article, nil
}

func GetArticleListInId(ids []int64) ([]domain.Article, error) {
	rows, err := configs.Engine.Table("article").In("id", ids).Rows(&domain.Article{})
	if err != nil {
		return make([]domain.Article, 0), err
	}
	defer rows.Close()
	var list []domain.Article
	for rows.Next() {
		var u domain.Article
		rows.Scan(&u)
		list = append(list, u)
	}
	return list, nil
}

func GetArticleList(article domain.Article, pageNum, pageSize int) (vo.BaseListVo, error) {
	var arr []domain.Article
	Count, err := configs.Engine.Table("article").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &article)
	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 SaveArticle(article *domain.Article) (domain.Article, error) {
	_, err := configs.Engine.Table("article").Insert(&article)
	if err != nil {
		return *article, err
	}
	return *article, nil
}

func SetArticle(articleMap map[string]interface{}, id int64) (domain.Article, bool, error) {
	var article domain.Article
	_, err := configs.Engine.Table("article").Where("id = ?", id).Update(articleMap)
	if err != nil {
		return article, false, err
	}
	return article, true, nil
}

func DeleteArticle(id int64) bool {
	var article domain.Article
	i, err := configs.Engine.Table("article").Where("id = ?", id).Delete(&article)
	if err != nil {
		return false
	}
	return i > 0
}

func GetArticleTagById(id int64) (domain.ArticleTag, error) {
	var articleTag domain.ArticleTag
	_, err := configs.Engine.Table("articleTag").Where("id = ?", id).Get(&articleTag)
	if err != nil {
		return articleTag, err
	}
	return articleTag, nil
}

func GetArticleTagListInId(ids []int64) ([]domain.ArticleTag, error) {
	rows, err := configs.Engine.Table("articleTag").In("id", ids).Rows(&domain.ArticleTag{})
	if err != nil {
		return make([]domain.ArticleTag, 0), err
	}
	defer rows.Close()
	var list []domain.ArticleTag
	for rows.Next() {
		var u domain.ArticleTag
		rows.Scan(&u)
		list = append(list, u)
	}
	return list, nil
}

func GetArticleTagList(articleTag domain.ArticleTag, pageNum, pageSize int) (vo.BaseListVo, error) {
	var arr []domain.ArticleTag
	Count, err := configs.Engine.Table("articleTag").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &articleTag)
	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 SaveArticleTag(articleTag *domain.ArticleTag) (domain.ArticleTag, error) {
	_, err := configs.Engine.Table("articleTag").Insert(&articleTag)
	if err != nil {
		return *articleTag, err
	}
	return *articleTag, nil
}

func SetArticleTag(articleTagMap map[string]interface{}, id int64) (domain.ArticleTag, bool, error) {
	var articleTag domain.ArticleTag
	_, err := configs.Engine.Table("articleTag").Where("id = ?", id).Update(articleTagMap)
	if err != nil {
		return articleTag, false, err
	}
	return articleTag, true, nil
}

func DeleteArticleTag(id int64) bool {
	var articleTag domain.ArticleTag
	i, err := configs.Engine.Table("articleTag").Where("id = ?", id).Delete(&articleTag)
	if err != nil {
		return false
	}
	return i > 0
}

func GetArticleTopicById(id int64) (domain.ArticleTopic, error) {
	var articleTopic domain.ArticleTopic
	_, err := configs.Engine.Table("articleTopic").Where("id = ?", id).Get(&articleTopic)
	if err != nil {
		return articleTopic, err
	}
	return articleTopic, nil
}

func GetArticleTopicListInId(ids []int64) ([]domain.ArticleTopic, error) {
	rows, err := configs.Engine.Table("articleTopic").In("id", ids).Rows(&domain.ArticleTopic{})
	if err != nil {
		return make([]domain.ArticleTopic, 0), err
	}
	defer rows.Close()
	var list []domain.ArticleTopic
	for rows.Next() {
		var u domain.ArticleTopic
		rows.Scan(&u)
		list = append(list, u)
	}
	return list, nil
}

func GetArticleTopicList(articleTopic domain.ArticleTopic, pageNum, pageSize int) (vo.BaseListVo, error) {
	var arr []domain.ArticleTopic
	Count, err := configs.Engine.Table("articleTopic").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &articleTopic)
	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 SaveArticleTopic(articleTopic *domain.ArticleTopic) (domain.ArticleTopic, error) {
	_, err := configs.Engine.Table("articleTopic").Insert(&articleTopic)
	if err != nil {
		return *articleTopic, err
	}
	return *articleTopic, nil
}

func SetArticleTopic(articleTopicMap map[string]interface{}, id int64) (domain.ArticleTopic, bool, error) {
	var articleTopic domain.ArticleTopic
	_, err := configs.Engine.Table("articleTopic").Where("id = ?", id).Update(articleTopicMap)
	if err != nil {
		return articleTopic, false, err
	}
	return articleTopic, true, nil
}

func DeleteArticleTopic(id int64) bool {
	var articleTopic domain.ArticleTopic
	i, err := configs.Engine.Table("articleTopic").Where("id = ?", id).Delete(&articleTopic)
	if err != nil {
		return false
	}
	return i > 0
}

func GetBackAuthorityById(id int64) (domain.BackAuthority, error) {
	var backAuthority domain.BackAuthority
	_, err := configs.Engine.Table("backAuthority").Where("id = ?", id).Get(&backAuthority)
	if err != nil {
		return backAuthority, err
	}
	return backAuthority, nil
}

func GetBackAuthorityListInId(ids []int64) ([]domain.BackAuthority, error) {
	rows, err := configs.Engine.Table("backAuthority").In("id", ids).Rows(&domain.BackAuthority{})
	if err != nil {
		return make([]domain.BackAuthority, 0), err
	}
	defer rows.Close()
	var list []domain.BackAuthority
	for rows.Next() {
		var u domain.BackAuthority
		rows.Scan(&u)
		list = append(list, u)
	}
	return list, nil
}

func GetBackAuthorityList(backAuthority domain.BackAuthority, pageNum, pageSize int) (vo.BaseListVo, error) {
	var arr []domain.BackAuthority
	Count, err := configs.Engine.Table("backAuthority").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &backAuthority)
	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 SaveBackAuthority(backAuthority *domain.BackAuthority) (domain.BackAuthority, error) {
	_, err := configs.Engine.Table("backAuthority").Insert(&backAuthority)
	if err != nil {
		return *backAuthority, err
	}
	return *backAuthority, nil
}

func SetBackAuthority(backAuthorityMap map[string]interface{}, id int64) (domain.BackAuthority, bool, error) {
	var backAuthority domain.BackAuthority
	_, err := configs.Engine.Table("backAuthority").Where("id = ?", id).Update(backAuthorityMap)
	if err != nil {
		return backAuthority, false, err
	}
	return backAuthority, true, nil
}

func DeleteBackAuthority(id int64) bool {
	var backAuthority domain.BackAuthority
	i, err := configs.Engine.Table("backAuthority").Where("id = ?", id).Delete(&backAuthority)
	if err != nil {
		return false
	}
	return i > 0
}

func GetBackMenuById(id int64) (domain.BackMenu, error) {
	var backMenu domain.BackMenu
	_, err := configs.Engine.Table("backMenu").Where("id = ?", id).Get(&backMenu)
	if err != nil {
		return backMenu, err
	}
	return backMenu, nil
}

func GetBackMenuListInId(ids []int64) ([]domain.BackMenu, error) {
	rows, err := configs.Engine.Table("backMenu").In("id", ids).Rows(&domain.BackMenu{})
	if err != nil {
		return make([]domain.BackMenu, 0), err
	}
	defer rows.Close()
	var list []domain.BackMenu
	for rows.Next() {
		var u domain.BackMenu
		rows.Scan(&u)
		list = append(list, u)
	}
	return list, nil
}

func GetBackMenuList(backMenu domain.BackMenu, pageNum, pageSize int) (vo.BaseListVo, error) {
	var arr []domain.BackMenu
	Count, err := configs.Engine.Table("backMenu").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &backMenu)
	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 SaveBackMenu(backMenu *domain.BackMenu) (domain.BackMenu, error) {
	_, err := configs.Engine.Table("backMenu").Insert(&backMenu)
	if err != nil {
		return *backMenu, err
	}
	return *backMenu, nil
}

func SetBackMenu(backMenuMap map[string]interface{}, id int64) (domain.BackMenu, bool, error) {
	var backMenu domain.BackMenu
	_, err := configs.Engine.Table("backMenu").Where("id = ?", id).Update(backMenuMap)
	if err != nil {
		return backMenu, false, err
	}
	return backMenu, true, nil
}

func DeleteBackMenu(id int64) bool {
	var backMenu domain.BackMenu
	i, err := configs.Engine.Table("backMenu").Where("id = ?", id).Delete(&backMenu)
	if err != nil {
		return false
	}
	return i > 0
}

func GetBackRoleById(id int64) (domain.BackRole, error) {
	var backRole domain.BackRole
	_, err := configs.Engine.Table("backRole").Where("id = ?", id).Get(&backRole)
	if err != nil {
		return backRole, err
	}
	return backRole, nil
}

func GetBackRoleListInId(ids []int64) ([]domain.BackRole, error) {
	rows, err := configs.Engine.Table("backRole").In("id", ids).Rows(&domain.BackRole{})
	if err != nil {
		return make([]domain.BackRole, 0), err
	}
	defer rows.Close()
	var list []domain.BackRole
	for rows.Next() {
		var u domain.BackRole
		rows.Scan(&u)
		list = append(list, u)
	}
	return list, nil
}

func GetBackRoleList(backRole domain.BackRole, pageNum, pageSize int) (vo.BaseListVo, error) {
	var arr []domain.BackRole
	Count, err := configs.Engine.Table("backRole").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &backRole)
	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 SaveBackRole(backRole *domain.BackRole) (domain.BackRole, error) {
	_, err := configs.Engine.Table("backRole").Insert(&backRole)
	if err != nil {
		return *backRole, err
	}
	return *backRole, nil
}

func SetBackRole(backRoleMap map[string]interface{}, id int64) (domain.BackRole, bool, error) {
	var backRole domain.BackRole
	_, err := configs.Engine.Table("backRole").Where("id = ?", id).Update(backRoleMap)
	if err != nil {
		return backRole, false, err
	}
	return backRole, true, nil
}

func DeleteBackRole(id int64) bool {
	var backRole domain.BackRole
	i, err := configs.Engine.Table("backRole").Where("id = ?", id).Delete(&backRole)
	if err != nil {
		return false
	}
	return i > 0
}

func GetBackRoleAuthorityById(id int64) (domain.BackRoleAuthority, error) {
	var backRoleAuthority domain.BackRoleAuthority
	_, err := configs.Engine.Table("backRoleAuthority").Where("id = ?", id).Get(&backRoleAuthority)
	if err != nil {
		return backRoleAuthority, err
	}
	return backRoleAuthority, nil
}

func GetBackRoleAuthorityListInId(ids []int64) ([]domain.BackRoleAuthority, error) {
	rows, err := configs.Engine.Table("backRoleAuthority").In("id", ids).Rows(&domain.BackRoleAuthority{})
	if err != nil {
		return make([]domain.BackRoleAuthority, 0), err
	}
	defer rows.Close()
	var list []domain.BackRoleAuthority
	for rows.Next() {
		var u domain.BackRoleAuthority
		rows.Scan(&u)
		list = append(list, u)
	}
	return list, nil
}

func GetBackRoleAuthorityList(backRoleAuthority domain.BackRoleAuthority, pageNum, pageSize int) (vo.BaseListVo, error) {
	var arr []domain.BackRoleAuthority
	Count, err := configs.Engine.Table("backRoleAuthority").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &backRoleAuthority)
	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 SaveBackRoleAuthority(backRoleAuthority *domain.BackRoleAuthority) (domain.BackRoleAuthority, error) {
	_, err := configs.Engine.Table("backRoleAuthority").Insert(&backRoleAuthority)
	if err != nil {
		return *backRoleAuthority, err
	}
	return *backRoleAuthority, nil
}

func SetBackRoleAuthority(backRoleAuthorityMap map[string]interface{}, id int64) (domain.BackRoleAuthority, bool, error) {
	var backRoleAuthority domain.BackRoleAuthority
	_, err := configs.Engine.Table("backRoleAuthority").Where("id = ?", id).Update(backRoleAuthorityMap)
	if err != nil {
		return backRoleAuthority, false, err
	}
	return backRoleAuthority, true, nil
}

func DeleteBackRoleAuthority(id int64) bool {
	var backRoleAuthority domain.BackRoleAuthority
	i, err := configs.Engine.Table("backRoleAuthority").Where("id = ?", id).Delete(&backRoleAuthority)
	if err != nil {
		return false
	}
	return i > 0
}

func GetBackRoleMenuById(id int64) (domain.BackRoleMenu, error) {
	var backRoleMenu domain.BackRoleMenu
	_, err := configs.Engine.Table("backRoleMenu").Where("id = ?", id).Get(&backRoleMenu)
	if err != nil {
		return backRoleMenu, err
	}
	return backRoleMenu, nil
}

func GetBackRoleMenuListInId(ids []int64) ([]domain.BackRoleMenu, error) {
	rows, err := configs.Engine.Table("backRoleMenu").In("id", ids).Rows(&domain.BackRoleMenu{})
	if err != nil {
		return make([]domain.BackRoleMenu, 0), err
	}
	defer rows.Close()
	var list []domain.BackRoleMenu
	for rows.Next() {
		var u domain.BackRoleMenu
		rows.Scan(&u)
		list = append(list, u)
	}
	return list, nil
}

func GetBackRoleMenuList(backRoleMenu domain.BackRoleMenu, pageNum, pageSize int) (vo.BaseListVo, error) {
	var arr []domain.BackRoleMenu
	Count, err := configs.Engine.Table("backRoleMenu").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &backRoleMenu)
	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 SaveBackRoleMenu(backRoleMenu *domain.BackRoleMenu) (domain.BackRoleMenu, error) {
	_, err := configs.Engine.Table("backRoleMenu").Insert(&backRoleMenu)
	if err != nil {
		return *backRoleMenu, err
	}
	return *backRoleMenu, nil
}

func SetBackRoleMenu(backRoleMenuMap map[string]interface{}, id int64) (domain.BackRoleMenu, bool, error) {
	var backRoleMenu domain.BackRoleMenu
	_, err := configs.Engine.Table("backRoleMenu").Where("id = ?", id).Update(backRoleMenuMap)
	if err != nil {
		return backRoleMenu, false, err
	}
	return backRoleMenu, true, nil
}

func DeleteBackRoleMenu(id int64) bool {
	var backRoleMenu domain.BackRoleMenu
	i, err := configs.Engine.Table("backRoleMenu").Where("id = ?", id).Delete(&backRoleMenu)
	if err != nil {
		return false
	}
	return i > 0
}

func GetGenTableById(id int64) (domain.GenTable, error) {
	var genTable domain.GenTable
	_, err := configs.Engine.Table("genTable").Where("id = ?", id).Get(&genTable)
	if err != nil {
		return genTable, err
	}
	return genTable, nil
}

func GetGenTableListInId(ids []int64) ([]domain.GenTable, error) {
	rows, err := configs.Engine.Table("genTable").In("id", ids).Rows(&domain.GenTable{})
	if err != nil {
		return make([]domain.GenTable, 0), err
	}
	defer rows.Close()
	var list []domain.GenTable
	for rows.Next() {
		var u domain.GenTable
		rows.Scan(&u)
		list = append(list, u)
	}
	return list, nil
}

func GetGenTableList(genTable domain.GenTable, pageNum, pageSize int) (vo.BaseListVo, error) {
	var arr []domain.GenTable
	Count, err := configs.Engine.Table("genTable").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &genTable)
	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 SaveGenTable(genTable *domain.GenTable) (domain.GenTable, error) {
	_, err := configs.Engine.Table("genTable").Insert(&genTable)
	if err != nil {
		return *genTable, err
	}
	return *genTable, nil
}

func SetGenTable(genTableMap map[string]interface{}, id int64) (domain.GenTable, bool, error) {
	var genTable domain.GenTable
	_, err := configs.Engine.Table("genTable").Where("id = ?", id).Update(genTableMap)
	if err != nil {
		return genTable, false, err
	}
	return genTable, true, nil
}

func DeleteGenTable(id int64) bool {
	var genTable domain.GenTable
	i, err := configs.Engine.Table("genTable").Where("id = ?", id).Delete(&genTable)
	if err != nil {
		return false
	}
	return i > 0
}

func GetGenTableColumnById(id int64) (domain.GenTableColumn, error) {
	var genTableColumn domain.GenTableColumn
	_, err := configs.Engine.Table("genTableColumn").Where("id = ?", id).Get(&genTableColumn)
	if err != nil {
		return genTableColumn, err
	}
	return genTableColumn, nil
}

func GetGenTableColumnListInId(ids []int64) ([]domain.GenTableColumn, error) {
	rows, err := configs.Engine.Table("genTableColumn").In("id", ids).Rows(&domain.GenTableColumn{})
	if err != nil {
		return make([]domain.GenTableColumn, 0), err
	}
	defer rows.Close()
	var list []domain.GenTableColumn
	for rows.Next() {
		var u domain.GenTableColumn
		rows.Scan(&u)
		list = append(list, u)
	}
	return list, nil
}

func GetGenTableColumnList(genTableColumn domain.GenTableColumn, pageNum, pageSize int) (vo.BaseListVo, error) {
	var arr []domain.GenTableColumn
	Count, err := configs.Engine.Table("genTableColumn").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &genTableColumn)
	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 SaveGenTableColumn(genTableColumn *domain.GenTableColumn) (domain.GenTableColumn, error) {
	_, err := configs.Engine.Table("genTableColumn").Insert(&genTableColumn)
	if err != nil {
		return *genTableColumn, err
	}
	return *genTableColumn, nil
}

func SetGenTableColumn(genTableColumnMap map[string]interface{}, id int64) (domain.GenTableColumn, bool, error) {
	var genTableColumn domain.GenTableColumn
	_, err := configs.Engine.Table("genTableColumn").Where("id = ?", id).Update(genTableColumnMap)
	if err != nil {
		return genTableColumn, false, err
	}
	return genTableColumn, true, nil
}

func DeleteGenTableColumn(id int64) bool {
	var genTableColumn domain.GenTableColumn
	i, err := configs.Engine.Table("genTableColumn").Where("id = ?", id).Delete(&genTableColumn)
	if err != nil {
		return false
	}
	return i > 0
}

func GetGoodsById(id int64) (domain.Goods, error) {
	var goods domain.Goods
	_, err := configs.Engine.Table("goods").Where("id = ?", id).Get(&goods)
	if err != nil {
		return goods, err
	}
	return goods, nil
}

func GetGoodsListInId(ids []int64) ([]domain.Goods, error) {
	rows, err := configs.Engine.Table("goods").In("id", ids).Rows(&domain.Goods{})
	if err != nil {
		return make([]domain.Goods, 0), err
	}
	defer rows.Close()
	var list []domain.Goods
	for rows.Next() {
		var u domain.Goods
		rows.Scan(&u)
		list = append(list, u)
	}
	return list, nil
}

func GetGoodsList(goods domain.Goods, pageNum, pageSize int) (vo.BaseListVo, error) {
	var arr []domain.Goods
	Count, err := configs.Engine.Table("goods").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &goods)
	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 SaveGoods(goods *domain.Goods) (domain.Goods, error) {
	_, err := configs.Engine.Table("goods").Insert(&goods)
	if err != nil {
		return *goods, err
	}
	return *goods, nil
}

func SetGoods(goodsMap map[string]interface{}, id int64) (domain.Goods, bool, error) {
	var goods domain.Goods
	_, err := configs.Engine.Table("goods").Where("id = ?", id).Update(goodsMap)
	if err != nil {
		return goods, false, err
	}
	return goods, true, nil
}

func DeleteGoods(id int64) bool {
	var goods domain.Goods
	i, err := configs.Engine.Table("goods").Where("id = ?", id).Delete(&goods)
	if err != nil {
		return false
	}
	return i > 0
}

func GetGoodsCommodityAreaById(id int64) (domain.GoodsCommodityArea, error) {
	var goodsCommodityArea domain.GoodsCommodityArea
	_, err := configs.Engine.Table("goodsCommodityArea").Where("id = ?", id).Get(&goodsCommodityArea)
	if err != nil {
		return goodsCommodityArea, err
	}
	return goodsCommodityArea, nil
}

func GetGoodsCommodityAreaListInId(ids []int64) ([]domain.GoodsCommodityArea, error) {
	rows, err := configs.Engine.Table("goodsCommodityArea").In("id", ids).Rows(&domain.GoodsCommodityArea{})
	if err != nil {
		return make([]domain.GoodsCommodityArea, 0), err
	}
	defer rows.Close()
	var list []domain.GoodsCommodityArea
	for rows.Next() {
		var u domain.GoodsCommodityArea
		rows.Scan(&u)
		list = append(list, u)
	}
	return list, nil
}

func GetGoodsCommodityAreaList(goodsCommodityArea domain.GoodsCommodityArea, pageNum, pageSize int) (vo.BaseListVo, error) {
	var arr []domain.GoodsCommodityArea
	Count, err := configs.Engine.Table("goodsCommodityArea").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &goodsCommodityArea)
	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 SaveGoodsCommodityArea(goodsCommodityArea *domain.GoodsCommodityArea) (domain.GoodsCommodityArea, error) {
	_, err := configs.Engine.Table("goodsCommodityArea").Insert(&goodsCommodityArea)
	if err != nil {
		return *goodsCommodityArea, err
	}
	return *goodsCommodityArea, nil
}

func SetGoodsCommodityArea(goodsCommodityAreaMap map[string]interface{}, id int64) (domain.GoodsCommodityArea, bool, error) {
	var goodsCommodityArea domain.GoodsCommodityArea
	_, err := configs.Engine.Table("goodsCommodityArea").Where("id = ?", id).Update(goodsCommodityAreaMap)
	if err != nil {
		return goodsCommodityArea, false, err
	}
	return goodsCommodityArea, true, nil
}

func DeleteGoodsCommodityArea(id int64) bool {
	var goodsCommodityArea domain.GoodsCommodityArea
	i, err := configs.Engine.Table("goodsCommodityArea").Where("id = ?", id).Delete(&goodsCommodityArea)
	if err != nil {
		return false
	}
	return i > 0
}

func GetGoodsCouponById(id int64) (domain.GoodsCoupon, error) {
	var goodsCoupon domain.GoodsCoupon
	_, err := configs.Engine.Table("goodsCoupon").Where("id = ?", id).Get(&goodsCoupon)
	if err != nil {
		return goodsCoupon, err
	}
	return goodsCoupon, nil
}

func GetGoodsCouponListInId(ids []int64) ([]domain.GoodsCoupon, error) {
	rows, err := configs.Engine.Table("goodsCoupon").In("id", ids).Rows(&domain.GoodsCoupon{})
	if err != nil {
		return make([]domain.GoodsCoupon, 0), err
	}
	defer rows.Close()
	var list []domain.GoodsCoupon
	for rows.Next() {
		var u domain.GoodsCoupon
		rows.Scan(&u)
		list = append(list, u)
	}
	return list, nil
}

func GetGoodsCouponList(goodsCoupon domain.GoodsCoupon, pageNum, pageSize int) (vo.BaseListVo, error) {
	var arr []domain.GoodsCoupon
	Count, err := configs.Engine.Table("goodsCoupon").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &goodsCoupon)
	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 SaveGoodsCoupon(goodsCoupon *domain.GoodsCoupon) (domain.GoodsCoupon, error) {
	_, err := configs.Engine.Table("goodsCoupon").Insert(&goodsCoupon)
	if err != nil {
		return *goodsCoupon, err
	}
	return *goodsCoupon, nil
}

func SetGoodsCoupon(goodsCouponMap map[string]interface{}, id int64) (domain.GoodsCoupon, bool, error) {
	var goodsCoupon domain.GoodsCoupon
	_, err := configs.Engine.Table("goodsCoupon").Where("id = ?", id).Update(goodsCouponMap)
	if err != nil {
		return goodsCoupon, false, err
	}
	return goodsCoupon, true, nil
}

func DeleteGoodsCoupon(id int64) bool {
	var goodsCoupon domain.GoodsCoupon
	i, err := configs.Engine.Table("goodsCoupon").Where("id = ?", id).Delete(&goodsCoupon)
	if err != nil {
		return false
	}
	return i > 0
}

func GetGoodsCouponUserById(id int64) (domain.GoodsCouponUser, error) {
	var goodsCouponUser domain.GoodsCouponUser
	_, err := configs.Engine.Table("goodsCouponUser").Where("id = ?", id).Get(&goodsCouponUser)
	if err != nil {
		return goodsCouponUser, err
	}
	return goodsCouponUser, nil
}

func GetGoodsCouponUserListInId(ids []int64) ([]domain.GoodsCouponUser, error) {
	rows, err := configs.Engine.Table("goodsCouponUser").In("id", ids).Rows(&domain.GoodsCouponUser{})
	if err != nil {
		return make([]domain.GoodsCouponUser, 0), err
	}
	defer rows.Close()
	var list []domain.GoodsCouponUser
	for rows.Next() {
		var u domain.GoodsCouponUser
		rows.Scan(&u)
		list = append(list, u)
	}
	return list, nil
}

func GetGoodsCouponUserList(goodsCouponUser domain.GoodsCouponUser, pageNum, pageSize int) (vo.BaseListVo, error) {
	var arr []domain.GoodsCouponUser
	Count, err := configs.Engine.Table("goodsCouponUser").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &goodsCouponUser)
	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 SaveGoodsCouponUser(goodsCouponUser *domain.GoodsCouponUser) (domain.GoodsCouponUser, error) {
	_, err := configs.Engine.Table("goodsCouponUser").Insert(&goodsCouponUser)
	if err != nil {
		return *goodsCouponUser, err
	}
	return *goodsCouponUser, nil
}

func SetGoodsCouponUser(goodsCouponUserMap map[string]interface{}, id int64) (domain.GoodsCouponUser, bool, error) {
	var goodsCouponUser domain.GoodsCouponUser
	_, err := configs.Engine.Table("goodsCouponUser").Where("id = ?", id).Update(goodsCouponUserMap)
	if err != nil {
		return goodsCouponUser, false, err
	}
	return goodsCouponUser, true, nil
}

func DeleteGoodsCouponUser(id int64) bool {
	var goodsCouponUser domain.GoodsCouponUser
	i, err := configs.Engine.Table("goodsCouponUser").Where("id = ?", id).Delete(&goodsCouponUser)
	if err != nil {
		return false
	}
	return i > 0
}

func GetGoodsIntroductionById(id int64) (domain.GoodsIntroduction, error) {
	var goodsIntroduction domain.GoodsIntroduction
	_, err := configs.Engine.Table("goodsIntroduction").Where("id = ?", id).Get(&goodsIntroduction)
	if err != nil {
		return goodsIntroduction, err
	}
	return goodsIntroduction, nil
}

func GetGoodsIntroductionListInId(ids []int64) ([]domain.GoodsIntroduction, error) {
	rows, err := configs.Engine.Table("goodsIntroduction").In("id", ids).Rows(&domain.GoodsIntroduction{})
	if err != nil {
		return make([]domain.GoodsIntroduction, 0), err
	}
	defer rows.Close()
	var list []domain.GoodsIntroduction
	for rows.Next() {
		var u domain.GoodsIntroduction
		rows.Scan(&u)
		list = append(list, u)
	}
	return list, nil
}

func GetGoodsIntroductionList(goodsIntroduction domain.GoodsIntroduction, pageNum, pageSize int) (vo.BaseListVo, error) {
	var arr []domain.GoodsIntroduction
	Count, err := configs.Engine.Table("goodsIntroduction").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &goodsIntroduction)
	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 SaveGoodsIntroduction(goodsIntroduction *domain.GoodsIntroduction) (domain.GoodsIntroduction, error) {
	_, err := configs.Engine.Table("goodsIntroduction").Insert(&goodsIntroduction)
	if err != nil {
		return *goodsIntroduction, err
	}
	return *goodsIntroduction, nil
}

func SetGoodsIntroduction(goodsIntroductionMap map[string]interface{}, id int64) (domain.GoodsIntroduction, bool, error) {
	var goodsIntroduction domain.GoodsIntroduction
	_, err := configs.Engine.Table("goodsIntroduction").Where("id = ?", id).Update(goodsIntroductionMap)
	if err != nil {
		return goodsIntroduction, false, err
	}
	return goodsIntroduction, true, nil
}

func DeleteGoodsIntroduction(id int64) bool {
	var goodsIntroduction domain.GoodsIntroduction
	i, err := configs.Engine.Table("goodsIntroduction").Where("id = ?", id).Delete(&goodsIntroduction)
	if err != nil {
		return false
	}
	return i > 0
}

func GetGoodsOrderById(id int64) (domain.GoodsOrder, error) {
	var goodsOrder domain.GoodsOrder
	_, err := configs.Engine.Table("goodsOrder").Where("id = ?", id).Get(&goodsOrder)
	if err != nil {
		return goodsOrder, err
	}
	return goodsOrder, nil
}

func GetGoodsOrderListInId(ids []int64) ([]domain.GoodsOrder, error) {
	rows, err := configs.Engine.Table("goodsOrder").In("id", ids).Rows(&domain.GoodsOrder{})
	if err != nil {
		return make([]domain.GoodsOrder, 0), err
	}
	defer rows.Close()
	var list []domain.GoodsOrder
	for rows.Next() {
		var u domain.GoodsOrder
		rows.Scan(&u)
		list = append(list, u)
	}
	return list, nil
}

func GetGoodsOrderList(goodsOrder domain.GoodsOrder, pageNum, pageSize int) (vo.BaseListVo, error) {
	var arr []domain.GoodsOrder
	Count, err := configs.Engine.Table("goodsOrder").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &goodsOrder)
	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 SaveGoodsOrder(goodsOrder *domain.GoodsOrder) (domain.GoodsOrder, error) {
	_, err := configs.Engine.Table("goodsOrder").Insert(&goodsOrder)
	if err != nil {
		return *goodsOrder, err
	}
	return *goodsOrder, nil
}

func SetGoodsOrder(goodsOrderMap map[string]interface{}, id int64) (domain.GoodsOrder, bool, error) {
	var goodsOrder domain.GoodsOrder
	_, err := configs.Engine.Table("goodsOrder").Where("id = ?", id).Update(goodsOrderMap)
	if err != nil {
		return goodsOrder, false, err
	}
	return goodsOrder, true, nil
}

func DeleteGoodsOrder(id int64) bool {
	var goodsOrder domain.GoodsOrder
	i, err := configs.Engine.Table("goodsOrder").Where("id = ?", id).Delete(&goodsOrder)
	if err != nil {
		return false
	}
	return i > 0
}

func GetGoodsSkuById(id int64) (domain.GoodsSku, error) {
	var goodsSku domain.GoodsSku
	_, err := configs.Engine.Table("goodsSku").Where("id = ?", id).Get(&goodsSku)
	if err != nil {
		return goodsSku, err
	}
	return goodsSku, nil
}

func GetGoodsSkuListInId(ids []int64) ([]domain.GoodsSku, error) {
	rows, err := configs.Engine.Table("goodsSku").In("id", ids).Rows(&domain.GoodsSku{})
	if err != nil {
		return make([]domain.GoodsSku, 0), err
	}
	defer rows.Close()
	var list []domain.GoodsSku
	for rows.Next() {
		var u domain.GoodsSku
		rows.Scan(&u)
		list = append(list, u)
	}
	return list, nil
}

func GetGoodsSkuList(goodsSku domain.GoodsSku, pageNum, pageSize int) (vo.BaseListVo, error) {
	var arr []domain.GoodsSku
	Count, err := configs.Engine.Table("goodsSku").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &goodsSku)
	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 SaveGoodsSku(goodsSku *domain.GoodsSku) (domain.GoodsSku, error) {
	_, err := configs.Engine.Table("goodsSku").Insert(&goodsSku)
	if err != nil {
		return *goodsSku, err
	}
	return *goodsSku, nil
}

func SetGoodsSku(goodsSkuMap map[string]interface{}, id int64) (domain.GoodsSku, bool, error) {
	var goodsSku domain.GoodsSku
	_, err := configs.Engine.Table("goodsSku").Where("id = ?", id).Update(goodsSkuMap)
	if err != nil {
		return goodsSku, false, err
	}
	return goodsSku, true, nil
}

func DeleteGoodsSku(id int64) bool {
	var goodsSku domain.GoodsSku
	i, err := configs.Engine.Table("goodsSku").Where("id = ?", id).Delete(&goodsSku)
	if err != nil {
		return false
	}
	return i > 0
}

func GetGoodsSkuCardById(id int64) (domain.GoodsSkuCard, error) {
	var goodsSkuCard domain.GoodsSkuCard
	_, err := configs.Engine.Table("goodsSkuCard").Where("id = ?", id).Get(&goodsSkuCard)
	if err != nil {
		return goodsSkuCard, err
	}
	return goodsSkuCard, nil
}

func GetGoodsSkuCardListInId(ids []int64) ([]domain.GoodsSkuCard, error) {
	rows, err := configs.Engine.Table("goodsSkuCard").In("id", ids).Rows(&domain.GoodsSkuCard{})
	if err != nil {
		return make([]domain.GoodsSkuCard, 0), err
	}
	defer rows.Close()
	var list []domain.GoodsSkuCard
	for rows.Next() {
		var u domain.GoodsSkuCard
		rows.Scan(&u)
		list = append(list, u)
	}
	return list, nil
}

func GetGoodsSkuCardList(goodsSkuCard domain.GoodsSkuCard, pageNum, pageSize int) (vo.BaseListVo, error) {
	var arr []domain.GoodsSkuCard
	Count, err := configs.Engine.Table("goodsSkuCard").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &goodsSkuCard)
	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 SaveGoodsSkuCard(goodsSkuCard *domain.GoodsSkuCard) (domain.GoodsSkuCard, error) {
	_, err := configs.Engine.Table("goodsSkuCard").Insert(&goodsSkuCard)
	if err != nil {
		return *goodsSkuCard, err
	}
	return *goodsSkuCard, nil
}

func SetGoodsSkuCard(goodsSkuCardMap map[string]interface{}, id int64) (domain.GoodsSkuCard, bool, error) {
	var goodsSkuCard domain.GoodsSkuCard
	_, err := configs.Engine.Table("goodsSkuCard").Where("id = ?", id).Update(goodsSkuCardMap)
	if err != nil {
		return goodsSkuCard, false, err
	}
	return goodsSkuCard, true, nil
}

func DeleteGoodsSkuCard(id int64) bool {
	var goodsSkuCard domain.GoodsSkuCard
	i, err := configs.Engine.Table("goodsSkuCard").Where("id = ?", id).Delete(&goodsSkuCard)
	if err != nil {
		return false
	}
	return i > 0
}

func GetGoodsTagById(id int64) (domain.GoodsTag, error) {
	var goodsTag domain.GoodsTag
	_, err := configs.Engine.Table("goodsTag").Where("id = ?", id).Get(&goodsTag)
	if err != nil {
		return goodsTag, err
	}
	return goodsTag, nil
}

func GetGoodsTagListInId(ids []int64) ([]domain.GoodsTag, error) {
	rows, err := configs.Engine.Table("goodsTag").In("id", ids).Rows(&domain.GoodsTag{})
	if err != nil {
		return make([]domain.GoodsTag, 0), err
	}
	defer rows.Close()
	var list []domain.GoodsTag
	for rows.Next() {
		var u domain.GoodsTag
		rows.Scan(&u)
		list = append(list, u)
	}
	return list, nil
}

func GetGoodsTagList(goodsTag domain.GoodsTag, pageNum, pageSize int) (vo.BaseListVo, error) {
	var arr []domain.GoodsTag
	Count, err := configs.Engine.Table("goodsTag").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &goodsTag)
	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 SaveGoodsTag(goodsTag *domain.GoodsTag) (domain.GoodsTag, error) {
	_, err := configs.Engine.Table("goodsTag").Insert(&goodsTag)
	if err != nil {
		return *goodsTag, err
	}
	return *goodsTag, nil
}

func SetGoodsTag(goodsTagMap map[string]interface{}, id int64) (domain.GoodsTag, bool, error) {
	var goodsTag domain.GoodsTag
	_, err := configs.Engine.Table("goodsTag").Where("id = ?", id).Update(goodsTagMap)
	if err != nil {
		return goodsTag, false, err
	}
	return goodsTag, true, nil
}

func DeleteGoodsTag(id int64) bool {
	var goodsTag domain.GoodsTag
	i, err := configs.Engine.Table("goodsTag").Where("id = ?", id).Delete(&goodsTag)
	if err != nil {
		return false
	}
	return i > 0
}

func GetGoodsTypeById(id int64) (domain.GoodsType, error) {
	var goodsType domain.GoodsType
	_, err := configs.Engine.Table("goodsType").Where("id = ?", id).Get(&goodsType)
	if err != nil {
		return goodsType, err
	}
	return goodsType, nil
}

func GetGoodsTypeListInId(ids []int64) ([]domain.GoodsType, error) {
	rows, err := configs.Engine.Table("goodsType").In("id", ids).Rows(&domain.GoodsType{})
	if err != nil {
		return make([]domain.GoodsType, 0), err
	}
	defer rows.Close()
	var list []domain.GoodsType
	for rows.Next() {
		var u domain.GoodsType
		rows.Scan(&u)
		list = append(list, u)
	}
	return list, nil
}

func GetGoodsTypeList(goodsType domain.GoodsType, pageNum, pageSize int) (vo.BaseListVo, error) {
	var arr []domain.GoodsType
	Count, err := configs.Engine.Table("goodsType").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &goodsType)
	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 SaveGoodsType(goodsType *domain.GoodsType) (domain.GoodsType, error) {
	_, err := configs.Engine.Table("goodsType").Insert(&goodsType)
	if err != nil {
		return *goodsType, err
	}
	return *goodsType, nil
}

func SetGoodsType(goodsTypeMap map[string]interface{}, id int64) (domain.GoodsType, bool, error) {
	var goodsType domain.GoodsType
	_, err := configs.Engine.Table("goodsType").Where("id = ?", id).Update(goodsTypeMap)
	if err != nil {
		return goodsType, false, err
	}
	return goodsType, true, nil
}

func DeleteGoodsType(id int64) bool {
	var goodsType domain.GoodsType
	i, err := configs.Engine.Table("goodsType").Where("id = ?", id).Delete(&goodsType)
	if err != nil {
		return false
	}
	return i > 0
}

func GetUserById(id int64) (domain.User, error) {
	var user domain.User
	_, err := configs.Engine.Table("user").Where("id = ?", id).Get(&user)
	if err != nil {
		return user, err
	}
	return user, nil
}

func GetUserListInId(ids []int64) ([]domain.User, error) {
	rows, err := configs.Engine.Table("user").In("id", ids).Rows(&domain.User{})
	if err != nil {
		return make([]domain.User, 0), err
	}
	defer rows.Close()
	var list []domain.User
	for rows.Next() {
		var u domain.User
		rows.Scan(&u)
		list = append(list, u)
	}
	return list, nil
}

func GetUserList(user domain.User, pageNum, pageSize int) (vo.BaseListVo, error) {
	var arr []domain.User
	Count, err := configs.Engine.Table("user").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &user)
	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 SaveUser(user *domain.User) (domain.User, error) {
	_, err := configs.Engine.Table("user").Insert(&user)
	if err != nil {
		return *user, err
	}
	return *user, nil
}

func SetUser(userMap map[string]interface{}, id int64) (domain.User, bool, error) {
	var user domain.User
	_, err := configs.Engine.Table("user").Where("id = ?", id).Update(userMap)
	if err != nil {
		return user, false, err
	}
	return user, true, nil
}

func DeleteUser(id int64) bool {
	var user domain.User
	i, err := configs.Engine.Table("user").Where("id = ?", id).Delete(&user)
	if err != nil {
		return false
	}
	return i > 0
}

func GetUserWalletById(id int64) (domain.UserWallet, error) {
	var userWallet domain.UserWallet
	_, err := configs.Engine.Table("userWallet").Where("id = ?", id).Get(&userWallet)
	if err != nil {
		return userWallet, err
	}
	return userWallet, nil
}

func GetUserWalletListInId(ids []int64) ([]domain.UserWallet, error) {
	rows, err := configs.Engine.Table("userWallet").In("id", ids).Rows(&domain.UserWallet{})
	if err != nil {
		return make([]domain.UserWallet, 0), err
	}
	defer rows.Close()
	var list []domain.UserWallet
	for rows.Next() {
		var u domain.UserWallet
		rows.Scan(&u)
		list = append(list, u)
	}
	return list, nil
}

func GetUserWalletList(userWallet domain.UserWallet, pageNum, pageSize int) (vo.BaseListVo, error) {
	var arr []domain.UserWallet
	Count, err := configs.Engine.Table("userWallet").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &userWallet)
	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 SaveUserWallet(userWallet *domain.UserWallet) (domain.UserWallet, error) {
	_, err := configs.Engine.Table("userWallet").Insert(&userWallet)
	if err != nil {
		return *userWallet, err
	}
	return *userWallet, nil
}

func SetUserWallet(userWalletMap map[string]interface{}, id int64) (domain.UserWallet, bool, error) {
	var userWallet domain.UserWallet
	_, err := configs.Engine.Table("userWallet").Where("id = ?", id).Update(userWalletMap)
	if err != nil {
		return userWallet, false, err
	}
	return userWallet, true, nil
}

func DeleteUserWallet(id int64) bool {
	var userWallet domain.UserWallet
	i, err := configs.Engine.Table("userWallet").Where("id = ?", id).Delete(&userWallet)
	if err != nil {
		return false
	}
	return i > 0
}

func GetDictDataById(id int64) (domain.DictData, error) {
	var dictData domain.DictData
	_, err := configs.Engine.Table("dictData").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("dictData").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
		rows.Scan(&u)
		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("dictData").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("dictData").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("dictData").Where("id = ?", id).Update(dictDataMap)
	if err != nil {
		return dictData, false, err
	}
	return dictData, true, nil
}

func DeleteDictData(id int64) bool {
	var dictData domain.DictData
	i, err := configs.Engine.Table("dictData").Where("id = ?", id).Delete(&dictData)
	if err != nil {
		return false
	}
	return i > 0
}

func GetDictTypeById(id int64) (domain.DictType, error) {
	var dictType domain.DictType
	_, err := configs.Engine.Table("dictType").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("dictType").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
		rows.Scan(&u)
		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("dictType").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("dictType").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("dictType").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("dictType").Where("id = ?", id).Delete(&dictType)
	if err != nil {
		return false
	}
	return i > 0
}

func GetManageUserById(id int64) (domain.ManageUser, error) {
	var manageUser domain.ManageUser
	_, err := configs.Engine.Table("manageUser").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("manageUser").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
		rows.Scan(&u)
		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("manageUser").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("manageUser").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("manageUser").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("manageUser").Where("id = ?", id).Delete(&manageUser)
	if err != nil {
		return false
	}
	return i > 0
}

func GetShopTopicById(id int64) (domain.ShopTopic, error) {
	var shopTopic domain.ShopTopic
	_, err := configs.Engine.Table("shopTopic").Where("id = ?", id).Get(&shopTopic)
	if err != nil {
		return shopTopic, err
	}
	return shopTopic, nil
}

func GetShopTopicListInId(ids []int64) ([]domain.ShopTopic, error) {
	rows, err := configs.Engine.Table("shopTopic").In("id", ids).Rows(&domain.ShopTopic{})
	if err != nil {
		return make([]domain.ShopTopic, 0), err
	}
	defer rows.Close()
	var list []domain.ShopTopic
	for rows.Next() {
		var u domain.ShopTopic
		rows.Scan(&u)
		list = append(list, u)
	}
	return list, nil
}

func GetShopTopicList(shopTopic domain.ShopTopic, pageNum, pageSize int) (vo.BaseListVo, error) {
	var arr []domain.ShopTopic
	Count, err := configs.Engine.Table("shopTopic").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &shopTopic)
	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 SaveShopTopic(shopTopic *domain.ShopTopic) (domain.ShopTopic, error) {
	_, err := configs.Engine.Table("shopTopic").Insert(&shopTopic)
	if err != nil {
		return *shopTopic, err
	}
	return *shopTopic, nil
}

func SetShopTopic(shopTopicMap map[string]interface{}, id int64) (domain.ShopTopic, bool, error) {
	var shopTopic domain.ShopTopic
	_, err := configs.Engine.Table("shopTopic").Where("id = ?", id).Update(shopTopicMap)
	if err != nil {
		return shopTopic, false, err
	}
	return shopTopic, true, nil
}

func DeleteShopTopic(id int64) bool {
	var shopTopic domain.ShopTopic
	i, err := configs.Engine.Table("shopTopic").Where("id = ?", id).Delete(&shopTopic)
	if err != nil {
		return false
	}
	return i > 0
}

func GetShopAdviceCarouselById(id int64) (domain.ShopAdviceCarousel, error) {
	var shopAdviceCarousel domain.ShopAdviceCarousel
	_, err := configs.Engine.Table("shopAdviceCarousel").Where("id = ?", id).Get(&shopAdviceCarousel)
	if err != nil {
		return shopAdviceCarousel, err
	}
	return shopAdviceCarousel, nil
}

func GetShopAdviceCarouselListInId(ids []int64) ([]domain.ShopAdviceCarousel, error) {
	rows, err := configs.Engine.Table("shopAdviceCarousel").In("id", ids).Rows(&domain.ShopAdviceCarousel{})
	if err != nil {
		return make([]domain.ShopAdviceCarousel, 0), err
	}
	defer rows.Close()
	var list []domain.ShopAdviceCarousel
	for rows.Next() {
		var u domain.ShopAdviceCarousel
		rows.Scan(&u)
		list = append(list, u)
	}
	return list, nil
}

func GetShopAdviceCarouselList(shopAdviceCarousel domain.ShopAdviceCarousel, pageNum, pageSize int) (vo.BaseListVo, error) {
	var arr []domain.ShopAdviceCarousel
	Count, err := configs.Engine.Table("shopAdviceCarousel").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &shopAdviceCarousel)
	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 SaveShopAdviceCarousel(shopAdviceCarousel *domain.ShopAdviceCarousel) (domain.ShopAdviceCarousel, error) {
	_, err := configs.Engine.Table("shopAdviceCarousel").Insert(&shopAdviceCarousel)
	if err != nil {
		return *shopAdviceCarousel, err
	}
	return *shopAdviceCarousel, nil
}

func SetShopAdviceCarousel(shopAdviceCarouselMap map[string]interface{}, id int64) (domain.ShopAdviceCarousel, bool, error) {
	var shopAdviceCarousel domain.ShopAdviceCarousel
	_, err := configs.Engine.Table("shopAdviceCarousel").Where("id = ?", id).Update(shopAdviceCarouselMap)
	if err != nil {
		return shopAdviceCarousel, false, err
	}
	return shopAdviceCarousel, true, nil
}

func DeleteShopAdviceCarousel(id int64) bool {
	var shopAdviceCarousel domain.ShopAdviceCarousel
	i, err := configs.Engine.Table("shopAdviceCarousel").Where("id = ?", id).Delete(&shopAdviceCarousel)
	if err != nil {
		return false
	}
	return i > 0
}

func GetShopTopicSkuById(id int64) (domain.ShopTopicSku, error) {
	var shopTopicSku domain.ShopTopicSku
	_, err := configs.Engine.Table("shopTopicSku").Where("id = ?", id).Get(&shopTopicSku)
	if err != nil {
		return shopTopicSku, err
	}
	return shopTopicSku, nil
}

func GetShopTopicSkuListInId(ids []int64) ([]domain.ShopTopicSku, error) {
	rows, err := configs.Engine.Table("shopTopicSku").In("id", ids).Rows(&domain.ShopTopicSku{})
	if err != nil {
		return make([]domain.ShopTopicSku, 0), err
	}
	defer rows.Close()
	var list []domain.ShopTopicSku
	for rows.Next() {
		var u domain.ShopTopicSku
		rows.Scan(&u)
		list = append(list, u)
	}
	return list, nil
}

func GetShopTopicSkuList(shopTopicSku domain.ShopTopicSku, pageNum, pageSize int) (vo.BaseListVo, error) {
	var arr []domain.ShopTopicSku
	Count, err := configs.Engine.Table("shopTopicSku").Limit(pageSize, (pageNum-1)*pageSize).FindAndCount(&arr, &shopTopicSku)
	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 SaveShopTopicSku(shopTopicSku *domain.ShopTopicSku) (domain.ShopTopicSku, error) {
	_, err := configs.Engine.Table("shopTopicSku").Insert(&shopTopicSku)
	if err != nil {
		return *shopTopicSku, err
	}
	return *shopTopicSku, nil
}

func SetShopTopicSku(shopTopicSkuMap map[string]interface{}, id int64) (domain.ShopTopicSku, bool, error) {
	var shopTopicSku domain.ShopTopicSku
	_, err := configs.Engine.Table("shopTopicSku").Where("id = ?", id).Update(shopTopicSkuMap)
	if err != nil {
		return shopTopicSku, false, err
	}
	return shopTopicSku, true, nil
}

func DeleteShopTopicSku(id int64) bool {
	var shopTopicSku domain.ShopTopicSku
	i, err := configs.Engine.Table("shopTopicSku").Where("id = ?", id).Delete(&shopTopicSku)
	if err != nil {
		return false
	}
	return i > 0
}