services/service/course/course.go

package course

import (
	"errors"
	"spaceofcheng/services/models"
	"spaceofcheng/services/models/cases"
	"spaceofcheng/services/models/coupon"
	"spaceofcheng/services/models/course"
	"spaceofcheng/services/models/customer"
	"spaceofcheng/services/models/model"
	"spaceofcheng/services/models/system"
	"spaceofcheng/services/models/vipcard"
	"spaceofcheng/services/service"
	"spaceofcheng/services/utils"
	"strings"
)

// CourseServ 系统处理
type CourseServ struct {
	ctx       *utils.Context
	dao       *course.CourseDAO
	casedao   *cases.CaseDAO
	custDAO   *customer.CustomerDAO
	userDAO   *system.UserDAO
	couponDAO *coupon.CouponDAO
	vipDAO    *vipcard.VipcardDAO
}

// NewCourseServ 初始化
func NewCourseServ(ctx *utils.Context) *CourseServ {
	return &CourseServ{
		ctx:       ctx,
		dao:       course.NewCourseDAO(ctx),
		casedao:   cases.NewCaseDAO(ctx),
		custDAO:   customer.NewCustomerDAO(ctx),
		userDAO:   system.NewUserDAO(ctx),
		couponDAO: coupon.NewCouponDAO(ctx),
		vipDAO:    vipcard.NewVipcardDAO(ctx),
	}
}

// GetCourseList 获取课程列表
func (s *CourseServ) GetCourseList(caseids, name, typeid, status string, page, pageSize int) (map[string]interface{}, error) {
	if pageSize == 0 {
		pageSize = service.PAGENUM
	}
	if page == 0 {
		page = 1
	}
	list, err := s.dao.GetCourseList(caseids, name, typeid, status, page, pageSize)
	if err != nil {
		utils.LogError("获取课程信息失败: " + err.Error())
		return nil, errors.New("获取课程信息失败")
	}
	total, err := s.dao.GetCourseCount(caseids, name, status, typeid)
	if err != nil {
		utils.LogError("获取课程信息失败: " + err.Error())
		return nil, errors.New("获取课程信息失败")
	}

	return map[string]interface{}{
		"list":     list,
		"pagesize": pageSize,
		"pagenum":  total,
		"page":     page,
	}, nil
}

// GetCourseByID 获取课程明细
func (s *CourseServ) GetCourseByID(courseid string) (*course.CourseDetail, error) {
	if courseid == "" {
		return nil, utils.LogError("不存在课程信息！")
	}
	info, err := s.dao.GetCourseInfo(courseid)
	if err != nil {
		utils.LogError("获取课程信息失败: " + err.Error())
		return nil, errors.New("获取课程信息失败")
	}
	if info == nil {
		return nil, utils.LogError("不存在课程信息！")
	}
	if info.Status == models.STATUS_DEL {
		return nil, utils.LogError("课程已被删除！")
	}

	tags, err := s.dao.GetCourseTag(courseid)
	if err != nil {
		utils.LogError("获取课程标签信息失败: " + err.Error())
		return nil, errors.New("获取课程信息失败")
	}
	info.CourseTags = tags
	details, err := s.dao.GetCourseDetail(courseid)
	if err != nil {
		utils.LogError("获取课程明细信息失败: " + err.Error())
		return nil, errors.New("获取课程信息失败")
	}
	info.CourseDetail = details
	imgs, err := s.dao.GetCourseImgs(courseid)
	if err != nil {
		utils.LogError("获取课程图片信息失败: " + err.Error())
		return nil, errors.New("获取课程信息失败")
	}
	info.CourseImgs = imgs
	caseinfo, err := s.casedao.GetCaseByID(info.CaseId)
	if err != nil {
		utils.LogError("获取课程案场信息失败: " + err.Error())
		return nil, errors.New("获取课程信息失败")
	}
	info.CaseInfo = caseinfo
	return info, nil
}

// SaveCourse 保存课程信息
func (s *CourseServ) SaveCourse(course model.TaCourse, tagids string) (*model.TaCourse, error) {
	var newInfo *model.TaCourse
	var err error
	if course.CourseName == "" {
		return nil, utils.LogError("课程名称不允许为空！")
	}
	if course.CourseImg == "" {
		return nil, utils.LogError("课程主图不允许为空！")
	}
	if course.LocationId == "" {
		return nil, utils.LogError("课程类型不允许为空！")
	}
	if course.CaseId == "" {
		return nil, utils.LogError("课程案场不允许为空！")
	}
	if course.Price == "" || course.Price == "0" {
		return nil, utils.LogError("课程价格不允许为0！")
	}
	if course.MinNum == 0 {
		return nil, utils.LogError("最小开课人数不允许为0！")
	}
	if course.MaxNum == 0 {
		return nil, utils.LogError("上课人数不允许为0！")
	}
	if course.MaxNum < course.MinNum {
		return nil, utils.LogError("上课人数不允许小于最小开课人数！")
	}
	if course.CourseNum == 0 {
		return nil, utils.LogError("课时数不允许为0！")
	}
	if course.BeginDate.IsZero() || course.EndDate.IsZero() {
		return nil, utils.LogError("课程时间不允许为空！")
	}
	if !course.EndDate.After(course.BeginDate) && course.EndDate != course.BeginDate {
		return nil, utils.LogError("截止时间必须大于开始时间！")
	}
	// if tagids == "" {
	// 	return nil, utils.LogError("请选择课程标签！")
	// }
	if course.CourseId == "" {
		org := s.ctx.Get("org").(model.SysOrg)
		course.OrgId = org.OrgId
		newInfo, err = s.dao.AddCourse(course)
		if err != nil {
			utils.LogError("保存课程信息失败: " + err.Error())
			return nil, errors.New("保存课程信息失败")
		}
	} else {
		err = s.dao.UpdateCourse(course)
		if err != nil {
			utils.LogError("保存课程信息失败: " + err.Error())
			return nil, errors.New("保存课程信息失败")
		}
		newInfo = &course
		err = s.dao.DelCourseTag(course.CourseId)
		if err != nil {
			utils.LogError("保存课程信息失败: " + err.Error())
			return nil, errors.New("保存课程信息失败")
		}
	}
	if tagids != "" {
		tags := strings.Split(tagids, ",")
		var courseTags []model.TaCourseTag
		for _, tag := range tags {
			arr := strings.Split(tag, ":")
			var tagid = ""
			if len(arr) > 1 {
				tagid = arr[1]
			} else {
				var taginfo = model.TdCourseTag{
					TagName: arr[0],
					OrgId:   course.OrgId,
				}
				newtag, err := s.dao.AddCourseTag(taginfo)
				if err != nil {
					utils.LogError("保存课程信息失败: " + err.Error())
					return nil, errors.New("保存课程信息失败")
				}
				tagid = newtag.TagId
			}
			var coursetag = model.TaCourseTag{
				CourseId: newInfo.CourseId,
				TagId:    tagid,
			}
			courseTags = append(courseTags, coursetag)
		}
		if len(courseTags) > 0 {
			err = s.dao.SaveCourseTag(courseTags)
			if err != nil {
				utils.LogError("保存课程信息失败: " + err.Error())
				return nil, errors.New("保存课程信息失败")
			}
		}
	}

	return newInfo, nil
}

// DelCourse 刪除课程信息
func (s *CourseServ) DelCourse(courseid string) error {
	if courseid == "" {
		return utils.LogError("没有对应的课程！")
	}
	courseinfo, err := s.dao.GetCourseByID(courseid)
	if err != nil {
		utils.LogError("刪除课程信息失败: " + err.Error())
		return errors.New("刪除课程信息失败")
	}
	if courseinfo.Status != course.STATUS_UNPUBLISH {
		return utils.LogError("课程状态异常！不允许删除！")
	}
	isok, err := s.dao.CheckCourseInCardOrCoupon(courseid)
	if err != nil {
		utils.LogError("判断是否绑定卡券中失败: " + err.Error())
		return errors.New("判断是否绑定卡券中失败")
	}
	if !isok {
		return errors.New("课程已绑定卡券，不允许删除！")
	}
	err = s.dao.DelCourse(courseid)
	if err != nil {
		utils.LogError("刪除课程信息失败: " + err.Error())
		return errors.New("刪除课程信息失败")
	}
	err = s.dao.DeleteScheduleByCourse(courseid)
	return err
}

// CoursePublic 课程发布
func (s *CourseServ) CoursePublic(courseid string) error {
	if courseid == "" {
		return utils.LogError("没有对应的课程！")
	}
	info, err := s.dao.GetCourseByID(courseid)
	if err != nil {
		utils.LogError("课程发布失败: " + err.Error())
		return errors.New("课程发布失败")
	}
	if info.Status != course.STATUS_UNPUBLISH {
		return utils.LogError("当前课程状态异常！请刷新后重试！")
	}
	// 获取课程已排课数量
	num, err := s.dao.GetCourseDetailCount(courseid)
	if err != nil {
		utils.LogError("课程发布失败: " + err.Error())
		return errors.New("课程发布失败")
	}
	if info.CourseNum > num {
		return errors.New("请先进行排课，再发布课程！")
	}
	err = s.dao.CoursePublic(courseid)
	if err != nil {
		utils.LogError("课程发布失败: " + err.Error())
		return errors.New("课程发布失败")
	}
	return nil
}

// CourseUnPublic 课程取消发布
func (s *CourseServ) CourseUnPublic(courseid string) error {
	if courseid == "" {
		return utils.LogError("没有对应的课程！")
	}
	info, err := s.dao.GetCourseByID(courseid)
	if err != nil {
		utils.LogError("课程取消发布失败: " + err.Error())
		return errors.New("课程取消发布失败")
	}
	if info.Status != models.STATUS_NORMAL {
		return utils.LogError("当前课程状态异常！请刷新后重试！")
	}
	err = s.dao.CourseUnPublic(courseid)
	if err != nil {
		utils.LogError("课程发布失败: " + err.Error())
		return errors.New("课程发布失败")
	}
	return nil
}

// GetCourseImgs 获取课程图片
func (s *CourseServ) GetCourseImgs(courseid string) ([]model.TaCourseImg, error) {
	if courseid == "" {
		return nil, utils.LogError("没有对应的课程！")
	}
	imgs, err := s.dao.GetCourseImgs(courseid)
	if err != nil {
		utils.LogError("获取课程图片失败: " + err.Error())
		return nil, errors.New("获取课程图片失败")
	}
	return imgs, nil
}

// SaveCourseImg 保存课程图片
func (s *CourseServ) SaveCourseImg(img model.TaCourseImg) (*model.TaCourseImg, error) {
	var newinfo *model.TaCourseImg
	var err error
	if img.ImgUrl == "" {
		return nil, utils.LogError("请先上传图片！")
	}
	if img.ImgId == "" {
		newinfo, err = s.dao.AddCourseImg(img)
	} else {
		newinfo = &img
		err = s.dao.UpdateCourseImg(img)
	}
	if err != nil {
		utils.LogError("保存课程图片失败: " + err.Error())
		return nil, errors.New("保存课程图片失败")
	}
	return newinfo, err
}

// DelCourseImg 刪除课程图片
func (s *CourseServ) DelCourseImg(imgid string) error {
	if imgid == "" {
		return utils.LogError("没有需要删除的内容！")
	}
	err := s.dao.DelCourseImg(imgid)
	if err != nil {
		utils.LogError("删除课程图片失败: " + err.Error())
		return errors.New("删除课程图片失败")
	}
	return err
}

// GetCourseSchedule 获取课程排期
func (s *CourseServ) GetCourseSchedule(name, caseids, courseid, date string, page, pageSize int) (map[string]interface{}, error) {
	if pageSize == 0 {
		pageSize = service.PAGENUM
	}
	if page == 0 {
		page = 1
	}
	if date == "" {
		return nil, utils.LogError("请先选择需要排课的日期！")
	}

	list, err := s.dao.GetCourseSchedule(name, caseids, courseid, date, page, pageSize)
	if err != nil {
		utils.LogError("获取课程排期失败: " + err.Error())
		return nil, errors.New("获取课程排期失败")
	}
	total, err := s.dao.GetCourseScheduleCount(name, caseids, courseid, date)
	if err != nil {
		utils.LogError("获取课程排期失败: " + err.Error())
		return nil, errors.New("获取课程排期失败")
	}

	return map[string]interface{}{
		"list":     list,
		"pagesize": pageSize,
		"pagenum":  total,
		"page":     page,
	}, nil
}

// GetDetails 获取所有排课
func (s *CourseServ) GetDetails(caseid, date, courseid string) ([]course.DetailInfo, error) {
	if courseid == "" && caseid == "" {
		return nil, utils.LogError("请先选择案场！")
	}
	if date == "" {
		return nil, utils.LogError("请选择需要查看的月份！")
	}
	details, err := s.dao.GetDetails(caseid, date, courseid)
	if err != nil {
		utils.LogError("获取排期信息失败: " + err.Error())
		return nil, errors.New("获取排期信息失败")
	}
	return details, nil
}

// GetDetailByID 获取单个排课信息
func (s *CourseServ) GetDetailByID(detailid string) (*model.TaCourseDetail, error) {
	if detailid == "" {
		return nil, utils.LogError("没有对应的排课信息！")
	}
	detail, err := s.dao.GetDetailByID(detailid)
	if err != nil {
		utils.LogError("获取排期信息失败: " + err.Error())
		return nil, errors.New("获取排期信息失败")
	}
	return detail, nil
}

// SaveDetail 保存排课信息
func (s *CourseServ) SaveDetail(detail model.TaCourseDetail) (*model.TaCourseDetail, error) {
	var newinfo *model.TaCourseDetail
	if detail.CourseId == "" {
		return nil, utils.LogError("没有对应的课程信息！")
	}
	if detail.DetailName == "" {
		return nil, utils.LogError("课程名称不能为空！")
	}
	if detail.BeginDate.IsZero() || detail.EndDate.IsZero() {
		return nil, utils.LogError("课程时间不能为空！")
	}
	if detail.BeginDate.After(detail.EndDate) {
		return nil, utils.LogError("课程截止时间必须大于开始时间！")
	}
	courseinfo, err := s.dao.GetCourseByID(detail.CourseId)
	if err != nil {
		utils.LogError("获取排期信息失败: " + err.Error())
		return nil, errors.New("保存排课信息失败")
	}
	if courseinfo.Status != course.STATUS_UNPUBLISH {
		return nil, utils.LogError("课程状态异常！不允许排课！请刷新后重试！")
	}
	if detail.DetailId == "" {
		detail.OrgId = courseinfo.OrgId
		detail.CaseId = courseinfo.CaseId
		newinfo, err = s.dao.AddCourseDetail(detail)
		if err != nil {
			utils.LogError("保存排课信息失败: " + err.Error())
			return nil, errors.New("保存排课信息失败")
		}
		num, err := s.dao.GetCourseDetailCount(courseinfo.CourseId)
		if err != nil {
			utils.LogError("保存排课信息失败: " + err.Error())
			return nil, errors.New("保存排课信息失败")
		}
		err = s.dao.UpdateCourseScheduleNum(courseinfo.CourseId, num)
		if err != nil {
			utils.LogError("保存排课信息失败: " + err.Error())
			return nil, errors.New("保存排课信息失败")
		}
	} else {
		err := s.dao.UpdateCourseDetail(detail)
		if err != nil {
			utils.LogError("保存排课信息失败: " + err.Error())
			return nil, errors.New("保存排课信息失败")
		}
		newinfo = &detail
	}
	return newinfo, nil
}

// DelCourseDetail 删除课程明细
func (s *CourseServ) DelCourseDetail(detailid string) error {
	if detailid == "" {
		return utils.LogError("没有对应的排课信息！")
	}
	detail, err := s.dao.GetDetailByID(detailid)
	if err != nil {
		utils.LogError("删除排课信息失败: " + err.Error())
		return errors.New("删除排课信息失败")
	}
	courseinfo, err := s.dao.GetCourseByID(detail.CourseId)
	if err != nil {
		utils.LogError("删除排课信息失败: " + err.Error())
		return errors.New("删除排课信息失败")
	}
	if courseinfo.Status != course.STATUS_UNPUBLISH {
		return utils.LogError("课程状态异常！不允许删除！")
	}
	isok, err := s.dao.CheckCourseInCardOrCoupon(detail.CourseId)
	if err != nil {
		utils.LogError("判断是否绑定卡券中失败: " + err.Error())
		return errors.New("判断是否绑定卡券中失败")
	}
	if !isok {
		return errors.New("课时已绑定卡券，不允许删除！")
	}
	err = s.dao.DelCourseDetail(detailid)
	if err != nil {
		utils.LogError("删除排课信息失败: " + err.Error())
		return errors.New("删除排课信息失败")
	}
	num, err := s.dao.GetCourseDetailCount(courseinfo.CourseId)
	if err != nil {
		utils.LogError("删除排课信息失败: " + err.Error())
		return errors.New("删除排课信息失败")
	}
	err = s.dao.UpdateCourseScheduleNum(courseinfo.CourseId, num)
	if err != nil {
		utils.LogError("删除排课信息失败: " + err.Error())
		return errors.New("删除排课信息失败")
	}
	return nil
}

// GetCourseBySelect 获取精选课程
func (s *CourseServ) GetSelectCourseList(orgid string) ([]course.CourseDetail, error) {
	if orgid == "" {
		return nil, utils.LogError("参数错误！")
	}
	list, err := s.dao.GetSelectCourseList(orgid)
	if err != nil {
		utils.LogError("获取课程信息失败: " + err.Error())
		return nil, errors.New("获取课程信息失败")
	}
	for i, v := range list {
		caseinfo, err := s.casedao.GetCaseByID(v.CaseId)
		if err != nil {
			utils.LogError("获取课程信息失败: " + err.Error())
			return nil, errors.New("获取课程信息失败")
		}
		list[i].CaseInfo = caseinfo
	}
	return list, err
}

// GetCourseByLocation 根据位置获取课程
func (s *CourseServ) GetCourseByLocation(orgid, locationid string) ([]course.CourseDetail, error) {
	if orgid == "" || locationid == "" {
		return nil, utils.LogError("参数错误！")
	}
	list, err := s.dao.GetCourseByLocation(orgid, locationid)
	if err != nil {
		utils.LogError("获取课程信息失败: " + err.Error())
		return nil, errors.New("获取课程信息失败")
	}
	for i, v := range list {
		caseinfo, err := s.casedao.GetCaseByID(v.CaseId)
		if err != nil {
			utils.LogError("获取课程信息失败: " + err.Error())
			return nil, errors.New("获取课程信息失败")
		}
		list[i].CaseInfo = caseinfo
	}
	return list, err
}

// GetCustomerCourse 获取用户的课程信息
func (s *CourseServ) GetCustomerCourse(page, pageSize int) (map[string]interface{}, error) {
	if pageSize == 0 {
		pageSize = service.PAGENUM
	}
	if page == 0 {
		page = 1
	}
	customer := s.ctx.Get("customer")
	cust := customer.(model.TaCustomer)
	list, err := s.dao.GetCustomerCourse(cust.CustomerId, page, pageSize)
	if err != nil {
		utils.LogError("获取课程信息失败: " + err.Error())
		return nil, errors.New("获取课程信息失败")
	}
	total, err := s.dao.GetCustomerCourseCount(cust.CustomerId)
	if err != nil {
		utils.LogError("获取课程信息失败: " + err.Error())
		return nil, errors.New("获取课程信息失败")
	}
	return map[string]interface{}{
		"list":     list,
		"pagesize": pageSize,
		"pagenum":  total,
		"page":     page,
	}, nil

}

// GetCustomerCourseByID 获取我的课程明细
func (s *CourseServ) GetCustomerCourseByID(id string) (*course.CustomerCourse, error) {
	info, err := s.dao.GetCustomerCourseByID(id)
	if err != nil {
		utils.LogError("获取课程信息失败: " + err.Error())
		return nil, errors.New("获取课程信息失败")
	}
	return info, err
}

// GetCourseBySendType 根据类型获取课程
func (s *CourseServ) GetCourseBySendType(typeval, caseids string) ([]model.TaCourse, error) {
	courses, err := s.dao.GetCourseBySendType(typeval, caseids)
	if err != nil {
		utils.LogError("获取课程信息失败: " + err.Error())
		return nil, errors.New("获取课程信息失败")
	}
	return courses, err
}

// GetCourseCanUse 获取可用课程列表
func (s *CourseServ) GetCourseCanUse(caseids string, page, pageSize int) (map[string]interface{}, error) {
	if pageSize == 0 {
		pageSize = service.PAGENUM
	}
	if page == 0 {
		page = 1
	}
	list, err := s.dao.GetCourseCanUse(caseids, page, pageSize)
	if err != nil {
		utils.LogError("获取课程信息失败: " + err.Error())
		return nil, errors.New("获取课程信息失败")
	}
	total, err := s.dao.GetCourseCanUseCount(caseids)
	if err != nil {
		utils.LogError("获取课程信息失败: " + err.Error())
		return nil, errors.New("获取课程信息失败")
	}

	return map[string]interface{}{
		"list":     list,
		"pagesize": pageSize,
		"pagenum":  total,
		"page":     page,
	}, nil
}

// GetCourseList 获取微信首页课程列表
func (s *CourseServ) GetCourseForWechatFront(orgId string, page, pageSize int) (map[string]interface{}, error) {
	if pageSize == 0 {
		pageSize = service.PAGENUM
	}
	if page == 0 {
		page = 1
	}
	list, err := s.dao.GetCourseForWechatFront(orgId, page, pageSize)
	if err != nil {
		utils.LogError("获取课程信息失败: " + err.Error())
		return nil, errors.New("获取课程信息失败")
	}
	for i := 0; i < len(list); i++ {
		tags, err := s.dao.GetCourseTag(list[i].CourseId)
		if err != nil {
			utils.LogError("获取课程信息失败: " + err.Error())
			return nil, errors.New("获取课程信息失败")
		}
		list[i].CourseTags = tags
	}
	total, err := s.dao.GetCourseForWechatFrontCount(orgId)
	if err != nil {
		utils.LogError("获取课程信息失败: " + err.Error())
		return nil, errors.New("获取课程信息失败")
	}

	return map[string]interface{}{
		"list":     list,
		"pagesize": pageSize,
		"pagenum":  total,
		"page":     page,
	}, nil
}