package course

import (
	"errors"
	"spaceofcheng/services/models"
	"spaceofcheng/services/models/model"
	"spaceofcheng/services/utils"
	"strconv"
	"strings"
	"time"

	"github.com/astaxie/beego"

	"github.com/yl10/kit/guid"

	"github.com/go-xorm/xorm"
)

// CourseDAO 当前数据库操作对象
type CourseDAO struct {
	ctx *utils.Context
	db  *xorm.Session
}

// NewCourseDAO New Inst
func NewCourseDAO(ctx *utils.Context) *CourseDAO {
	return &CourseDAO{
		ctx: ctx,
		db:  ctx.DB,
	}
}

const (
	STATUS_UNPUBLISH = 0
	IS_SELECT        = 1
)

// CourseInfo 课程
type CourseInfo struct {
	model.TaCourse `xorm:"extends"`
	CourseType     string
}

// GetCourseList 获取课程列表
func (m *CourseDAO) GetCourseList(caseids, name, typeid, status string, page, pageSize int) ([]CourseInfo, error) {
	var courses []CourseInfo
	sql := `select a.*,b.location_name from ta_course a left join td_cms_image_location b on a.location_id = b.location_id where a.case_id in ('` +
		strings.Replace(caseids, ",", "','", -1) + `')`

	if name != "" {
		sql += ` and a.course_name like '%` + name + `%'`
	}

	if typeid != "" {
		sql += ` and a.location_id='` + typeid + `'`
	}

	if status != "" {
		if status != "1" {
			status = "0"
		}
		sql += ` and a.status=` + status
	} else {
		sql += ` and a.status>` + strconv.Itoa(models.STATUS_DEL)
	}

	sql += ` order by create_date desc limit ` + strconv.Itoa((page-1)*pageSize) + `, ` + strconv.Itoa(pageSize)
	err := m.db.Sql(sql).Find(&courses)
	return courses, err
}

// GetCourseCount 获取课程总数
func (m *CourseDAO) GetCourseCount(caseids, name, typeid, status string) (int, error) {
	var course []model.TaCourse
	dao := m.db.Where("case_id in ('" + strings.Replace(caseids, ",", "','", -1) + "')")

	if name != "" {
		dao.And("course_name like '%" + name + "%'")
	}

	if typeid != "" {
		dao.And("location_id=?", typeid)
	}

	if status != "" {
		if status != "1" {
			status = "0"
		}
		dao.And("status=?", status)
	} else {
		dao.And("status>" + strconv.Itoa(models.STATUS_DEL))
	}

	err := dao.Find(&course)
	if err != nil {
		return 0, err
	}
	if len(course) > 0 {
		return len(course), nil
	}
	return 0, nil
}

// GetCourseByID 根据ID获取课程
func (m *CourseDAO) GetCourseByID(courseid string) (*model.TaCourse, error) {
	var course []model.TaCourse
	err := m.db.Where("course_id=?", courseid).Find(&course)
	if err != nil {
		return nil, err
	}
	if len(course) > 0 {
		return &course[0], nil
	}
	return nil, nil
}

// CheckCourseInCardOrCoupon 判断课程是否存在于卡券种
func (m *CourseDAO) CheckCourseInCardOrCoupon(courseid string) (bool, error) {
	sql := `select a.* from ta_coupon_card_target a inner join ta_coupon_card b on a.card_id=b.card_id where b.status>? and a.target_id=?`
	var cardtarget []model.TaCouponCardTarget
	err := m.db.Sql(sql, models.STATUS_DEL, courseid).Find(&cardtarget)
	if err != nil {
		return false, err
	}
	if len(cardtarget) > 0 {
		return false, nil
	}
	sql = `select a.* from ta_coupon_target a inner join ta_coupon b on a.coupon_id=b.coupon_id where b.status>? and a.target_id=?`
	var coupontarget []model.TaCouponCardTarget
	err = m.db.Sql(sql, models.STATUS_DEL, courseid).Find(&coupontarget)
	if err != nil {
		return false, err
	}
	if len(coupontarget) > 0 {
		return false, nil
	}
	return true, nil
}

// AddCourse 新增课程信息
func (m *CourseDAO) AddCourse(course model.TaCourse) (*model.TaCourse, error) {
	course.CourseId = utils.GetGUID()
	course.CreateDate = time.Now()
	course.Status = STATUS_UNPUBLISH
	course.ScheduleNum = 0
	course.SignupNum = 0
	user := m.ctx.Get("user").(model.SysUser)
	course.CreateUser = user.UserId
	_, err := m.db.Insert(course)
	return &course, err
}

// UpdateCourse 修改课程信息
func (m *CourseDAO) UpdateCourse(course model.TaCourse) error {
	var cols = []string{
		"course_name",
		"price",
		"case_id",
		"location_id",
		"course_num",
		"max_num",
		"min_num",
		"begin_date",
		"end_date",
		"course_img",
		"course_desc",
		"remark",
		"is_select",
	}
	_, err := m.db.Cols(cols...).Where("course_id=?", course.CourseId).Update(course)
	return err
}

// DelCourse 删除课程信息
func (m *CourseDAO) DelCourse(courseid string) error {
	var info = model.TaCourse{
		CourseId: courseid,
		Status:   models.STATUS_DEL,
	}
	var cols = []string{
		"status",
	}
	_, err := m.db.Cols(cols...).Where("course_id=?", courseid).Update(info)
	return err
}

// CoursePublic 课程发布
func (m *CourseDAO) CoursePublic(courseid string) error {
	var info = model.TaCourse{
		CourseId: courseid,
		Status:   models.STATUS_NORMAL,
	}
	var cols = []string{
		"status",
	}
	_, err := m.db.Cols(cols...).Where("course_id=?", courseid).Update(info)
	return err
}

// CourseUnPublic 取消课程发布
func (m *CourseDAO) CourseUnPublic(courseid string) error {
	var info = model.TaCourse{
		CourseId: courseid,
		Status:   STATUS_UNPUBLISH,
	}
	var cols = []string{
		"status",
	}
	_, err := m.db.Cols(cols...).Where("course_id=?", courseid).Update(info)
	return err
}

// GetCourseImgs 获取课程图片
func (m *CourseDAO) GetCourseImgs(courseid string) ([]model.TaCourseImg, error) {
	var imgs []model.TaCourseImg
	err := m.db.Where("course_id=?", courseid).Find(&imgs)
	return imgs, err
}

// AddCourseImg 新增课程图片
func (m *CourseDAO) AddCourseImg(courseimg model.TaCourseImg) (*model.TaCourseImg, error) {
	courseimg.ImgId = utils.GetGUID()
	_, err := m.db.Insert(courseimg)
	return &courseimg, err
}

// UpdateCourseImg 修改课程图片
func (m *CourseDAO) UpdateCourseImg(courseimg model.TaCourseImg) error {
	var cols = []string{
		"sort",
	}
	_, err := m.db.Cols(cols...).Where("img_id=?", courseimg.ImgId).Update(courseimg)
	return err
}

// DelCourseImg 删除课程图片
func (m *CourseDAO) DelCourseImg(imgid string) error {
	sql := `delete from ta_course_img where img_id='` + imgid + `'`
	_, err := m.db.Exec(sql)
	return err
}

// TagDetail 标签
type TagDetail struct {
	model.TaCourseTag `xorm:"extends"`
	TagName           string
}

// CourseDetail 课程详情
type CourseDetail struct {
	model.TaCourse `xorm:"extends"`
	CourseTags     []TagDetail
	CourseImgs     []model.TaCourseImg
	CourseDetail   []model.TaCourseDetail
	CaseInfo       *model.SysCase
}

// GetCourseInfo 获取课程详情
func (m *CourseDAO) GetCourseInfo(courseid string) (*CourseDetail, error) {
	course := new(CourseDetail)
	sql := `select * from ta_course where course_id='` + courseid + `'`
	has, err := m.db.Sql(sql).Get(course)
	if err != nil {
		return nil, err
	}

	if !has {
		return nil, nil
	}

	details, err := m.GetCourseDetail(courseid)
	if err != nil {
		return nil, err
	}

	course.CourseDetail = details

	return course, nil
}

// GetCourseDetail 获取课程明细
func (m *CourseDAO) GetCourseDetail(courseid string) ([]model.TaCourseDetail, error) {
	var details []model.TaCourseDetail
	err := m.db.Where("course_id=?", courseid).And("status>" + strconv.Itoa(models.STATUS_DEL)).Find(&details)
	return details, err
}

// DetailInfo 排课记录
type DetailInfo struct {
	model.TaCourseDetail `xorm:"extends"`
	CourseStatus         int
	CourseName           string
	CaseName             string
	CaseAddress          string
}

// GetDetails 获取所有的排课记录
func (m *CourseDAO) GetDetails(caseid, date, courseid string) ([]DetailInfo, error) {
	var details []DetailInfo

	sql := `select a.*,b.course_name,b.status as course_status,c.case_name,c.case_address from ta_course_detail a 
	inner join ta_course b on a.course_id=b.course_id 
	inner join sys_case c on a.case_id=c.case_id where a.status>` + strconv.Itoa(models.STATUS_DEL) + `
	and b.status>` + strconv.Itoa(models.STATUS_DEL) + ` and DATE_FORMAT(a.begin_date,'%Y-%m') = '` + date + `'`

	if courseid != "" {
		sql = sql + ` and a.course_id = '` + courseid + `'`
	} else {
		sql = sql + ` and a.case_id='` + caseid + `'`
	}
	err := m.db.Sql(sql).Find(&details)

	return details, err
}

// GetCourseSchedule 获取需要排课的记录
func (m *CourseDAO) GetCourseSchedule(name, caseids, courseid, date string, page, pageSize int) ([]model.TaCourse, error) {
	var courses []model.TaCourse
	beego.Error(date)
	dao := m.db.Where("status=?", STATUS_UNPUBLISH).And("schedule_num<course_num").And("'" + date + "' BETWEEN begin_date and end_date")
	if name != "" {
		dao.And("course_name like '%" + name + "%'")
	}
	beego.Error(courseid)
	if courseid != "" {
		dao.And("course_id=?", courseid)
	} else {
		if caseids != "" {
			dao.And("case_id in ('" + strings.Replace(caseids, ",", "','", -1) + "')")
		}
	}
	err := dao.Desc("create_date").Limit(pageSize, (page-1)*pageSize).Find(&courses)
	return courses, err
}

// GetCourseScheduleCount 获取排课记录数
func (m *CourseDAO) GetCourseScheduleCount(name, caseids, courseid, date string) (int, error) {
	var courses []model.TaCourse
	dao := m.db.Where("status=?", STATUS_UNPUBLISH).And("schedule_num<course_num").And("'" + date + "' BETWEEN begin_date and end_date")
	if name != "" {
		dao.And("course_name like '%" + name + "%'")
	}
	if courseid != "" {
		dao.And("course_id=?", courseid)
	} else {
		if caseids != "" {
			dao.And("case_id in ('" + strings.Replace(caseids, ",", "','", -1) + "')")
		}
	}
	err := dao.Find(&courses)
	return len(courses), err
}

// GetDetailByID 获取排课明细
func (m *CourseDAO) GetDetailByID(detailid string) (*model.TaCourseDetail, error) {
	var details []model.TaCourseDetail
	err := m.db.Where("detail_id=?", detailid).And("status>" + strconv.Itoa(models.STATUS_DEL)).Find(&details)
	if err != nil {
		return nil, err
	}
	if len(details) > 0 {
		return &details[0], nil
	}
	return nil, nil
}

// AddCourseDetail 新增明细
func (m *CourseDAO) AddCourseDetail(detail model.TaCourseDetail) (*model.TaCourseDetail, error) {
	detail.CreateDate = time.Now()
	detail.Status = models.STATUS_NORMAL
	detail.DetailId = utils.GetGUID()
	_, err := m.db.Insert(detail)
	return &detail, err
}

// UpdateCourseDetail 修改明细
func (m *CourseDAO) UpdateCourseDetail(detail model.TaCourseDetail) error {
	var cols = []string{
		"detail_name",
		"detail_desc",
		// "begin_date",
		// "end_date",
	}
	_, err := m.db.Cols(cols...).Where("detail_id=?", detail.DetailId).Update(detail)
	return err
}

// DelCourseDetail 刪除明细
func (m *CourseDAO) DelCourseDetail(detailid string) error {
	var info = model.TaCourseDetail{
		DetailId: detailid,
		Status:   models.STATUS_DEL,
	}
	var cols = []string{
		"status",
	}
	_, err := m.db.Cols(cols...).Where("detail_id=?", detailid).Update(info)
	return err
}

// DelCourseTag 删除课程对应标签
func (m *CourseDAO) DelCourseTag(courseid string) error {
	sql := `delete from ta_course_tag where course_id='` + courseid + `'`
	_, err := m.db.Exec(sql)
	return err
}

// SaveCourseTag 保存课程对应标签
func (m *CourseDAO) SaveCourseTag(coursetags []model.TaCourseTag) error {
	_, err := m.db.Insert(coursetags)
	return err
}

// GetCourseTag 获取课程对应标签
func (m *CourseDAO) GetCourseTag(courseid string) ([]TagDetail, error) {
	var coursetags []TagDetail
	sql := `select a.*,b.tag_name from ta_course_tag a inner join td_course_tag b on a.tag_id=b.tag_id where a.course_id='` + courseid + `'`
	err := m.db.Sql(sql).Find(&coursetags)
	return coursetags, err
}

// CourseTagSave 保存课程对应标签
func (m *CourseDAO) CourseTagSave(courseid, tagids string) error {
	sql := `insert into ta_course_tag(course_id,tag_id) select '` + courseid + `',tag_id from td_course_tag where tag_id in ('` + strings.Replace(tagids, ",", "','", -1) + `') and status>` + strconv.Itoa(models.STATUS_DEL)
	_, err := m.db.Exec(sql)
	return err
}

// GetCourseDetailCount 获取已排课数量
func (m *CourseDAO) GetCourseDetailCount(courseid string) (int, error) {
	var details []model.TaCourseDetail
	err := m.db.Where("course_id=?", courseid).And("status>" + strconv.Itoa(models.STATUS_DEL)).Find(&details)
	if err != nil {
		return 0, err
	}
	return len(details), nil
}

// UpdateCourseScheduleNum 更新课程已排课数量
func (m *CourseDAO) UpdateCourseScheduleNum(courseid string, num int) error {
	var info = model.TaCourse{
		CourseId:    courseid,
		ScheduleNum: num,
	}
	var cols = []string{
		"schedule_num",
	}
	_, err := m.db.Cols(cols...).Where("course_id=?", courseid).Update(info)
	return err
}

// DeleteScheduleByCourse 删除排课记录
func (m *CourseDAO) DeleteScheduleByCourse(courseid string) error {
	sql := `update ta_course_detail set status=` + strconv.Itoa(models.STATUS_DEL) + ` where course_id='` + courseid + `'`
	_, err := m.db.Exec(sql)
	return err
}

// GetSelectCourseList 获取精选课程
func (m *CourseDAO) GetSelectCourseList(orgid string) ([]CourseDetail, error) {
	var courses []CourseDetail
	sql := `select * from ta_course where is_select=` + strconv.Itoa(IS_SELECT) + ` and status=` + strconv.Itoa(models.STATUS_NORMAL) + ` and org_id='` + orgid + `'
	and course_id NOT in (
		select course_id from ta_course_detail where begin_date<=NOW() and status>` + strconv.Itoa(models.STATUS_DEL) + ` 
	)`
	err := m.db.Sql(sql).Find(&courses)
	return courses, err
}

// GetCourseByLocation 根据位置获取课程信息
func (m *CourseDAO) GetCourseByLocation(orgid, locationid string) ([]CourseDetail, error) {
	var courses []CourseDetail
	sql := `select * from ta_course where status=` + strconv.Itoa(models.STATUS_NORMAL) + ` and org_id='` + orgid + `' and location_id ='` + locationid + `' 
	and course_id NOT in (
		select course_id from ta_course_detail where begin_date<=NOW() and status>` + strconv.Itoa(models.STATUS_DEL) + ` 
	)`
	err := m.db.Sql(sql).Find(&courses)
	return courses, err
}

// GetCourseOfCustomer 获取客户课程
func (m *CourseDAO) GetCourseOfCustomer(custID, courseID string) (*model.TaCustomerCourse, error) {
	course := new(model.TaCustomerCourse)

	if _, err := m.db.Where("course_id=?", courseID).And("customer_id=?", custID).Get(course); err != nil {
		return nil, err
	}

	return course, nil
}

// SaveCourseOfCustomer 保存我的课程
func (m *CourseDAO) SaveCourseOfCustomer(course *model.TaCustomerCourse, details []model.TaCustomerCourseDetail) (string, error) {
	if course == nil || details == nil || len(details) == 0 {
		return "", errors.New("没有有效的我的课程信息")
	}

	course.CustomerCourseId = guid.NewGUIDString()
	course.Status = models.STATUS_NORMAL

	for i, d := range details {
		d.CustomerDetailId = guid.NewGUIDString()
		d.CustomerCourseId = course.CustomerCourseId
		d.Status = models.STATUS_NORMAL
		d.CustomerId = course.CustomerId
		d.OrgId = course.OrgId
		d.CourseName = course.CourseName

		details[i] = d
	}

	if _, err := m.db.Insert(&details); err != nil {
		return "", err
	}

	if _, err := m.db.Insert(course); err != nil {
		return "", err
	}

	// 课程参与人数+1
	sql := `update ta_course set signup_num=signup_num+1 where course_id='` + course.CourseId + `'`
	if _, err := m.db.Exec(sql); err != nil {
		return "", err
	}
	return course.CustomerCourseId, nil
}

// SaveCustomerCourseQrcode 保存客户课程二维码
func (m *CourseDAO) SaveCustomerCourseQrcode(qrcode *model.TaCustomerCourseQrcode) error {
	_, err := m.db.Insert(qrcode)
	return err
}

// CustomerCourse 客户课程信息
type CustomerCourse struct {
	model.TaCustomerCourse `xorm:"extends"`
	CourseImg              string
	QrCodeString           string
	OrdersNo               string
	CaseName               string
	CaseAddress            string
	BeginDate              time.Time
	EndDate                time.Time
	Remark                 string
	Details                []model.TaCustomerCourseDetail
}

// GetCustomerCourse 获取我的课程信息
func (m *CourseDAO) GetCustomerCourse(custID string, page, pageSize int) ([]CustomerCourse, error) {
	var courses []CustomerCourse
	sql := `select a.*,a.customer_course_id as qr_code_string,b.orders_no,c.course_img,d.case_address,
	d.case_name,c.begin_date,c.end_date,c.remark from ta_customer_course a 
	inner join ta_course c on a.course_id=c.course_id
	INNER JOIN sys_case d on a.case_id = d.case_id
	left join ta_course_orders b on a.source_id=b.orders_id
	 where a.status>` + strconv.Itoa(models.STATUS_DEL) + ` and a.customer_id='` + custID + `'`
	sql += ` order by a.create_date desc limit ` + strconv.Itoa((page-1)*pageSize) + `, ` + strconv.Itoa(pageSize)
	err := m.db.Sql(sql).Find(&courses)
	if err != nil {
		return nil, err
	}
	for inx, course := range courses {
		details, err := m.GetCustomerCourseDetail(course.CustomerCourseId)
		if err != nil {
			return nil, err
		}
		courses[inx].Details = details
	}
	return courses, nil
}

// GetCustomerCourseCount 获取我的课程总数
func (m *CourseDAO) GetCustomerCourseCount(custID string) (int, error) {
	var courses []model.TaCustomerCourse
	err := m.db.Where("status>"+strconv.Itoa(models.STATUS_DEL)).And("customer_id=?", custID).Find(&courses)
	if err != nil {
		return 0, err
	}
	return len(courses), nil
}

// GetCustomerCourseDetail 获取我的课程明细
func (m *CourseDAO) GetCustomerCourseDetail(customerCourseID string) ([]model.TaCustomerCourseDetail, error) {
	var details []model.TaCustomerCourseDetail
	err := m.db.Where("customer_course_id=?", customerCourseID).And(`status>` + strconv.Itoa(models.STATUS_DEL)).Find(&details)
	return details, err
}

// GetCustomerCourseByID 获取我的课程信息明细
func (m *CourseDAO) GetCustomerCourseByID(id string) (*CustomerCourse, error) {
	var courses []CustomerCourse
	sql := `SELECT
	a.*,
	e.customer_qrcode AS qr_code_string,
	b.orders_no,
	c.course_img,
	d.case_address,
	d.case_name,
	c.begin_date,
	c.end_date,
	c.remark 
FROM
	ta_customer_course a
	INNER JOIN ta_course c ON a.course_id = c.course_id
	INNER JOIN sys_case d ON a.case_id = d.case_id
	INNER JOIN ta_customer_course_qrcode e ON a.customer_course_id = e.customer_course_id
	LEFT JOIN ta_course_orders b ON a.source_id = b.orders_id
	 where a.status>` + strconv.Itoa(models.STATUS_DEL) + ` and a.customer_course_id='` + id + `'`

	err := m.db.Sql(sql).Find(&courses)
	if err != nil {
		return nil, err
	}
	if len(courses) > 0 {
		details, err := m.GetCustomerCourseDetail(courses[0].CustomerCourseId)
		if err != nil {
			return nil, err
		}
		courses[0].Details = details
		return &courses[0], nil
	}

	return nil, nil
}

// GetCourseBySendType 根据发送类型获取案场信息
func (m *CourseDAO) GetCourseBySendType(typeval, caseids string) ([]model.TaCourse, error) {
	var courses []model.TaCourse
	err := m.db.Where("status=?", models.STATUS_NORMAL).And("case_id in ('" + strings.Replace(caseids, ",", "','", -1) + "')").Find(&courses)
	return courses, err
}

// CourseWithCase 课程with案场
type CourseWithCase struct {
	model.TaCourse `xorm:"extends"`
	CaseName       string
	CaseAddress    string
	CourseTags     []TagDetail
}

// GetSelectCourseWithCaseList 获取精选课程
func (m *CourseDAO) GetSelectCourseWithCaseList(orgid string) ([]CourseWithCase, error) {
	var courses []CourseWithCase
	sql := `select a.*,b.case_name,b.case_address from ta_course a inner join sys_case b on a.case_id=b.case_id where a.is_select=` + strconv.Itoa(IS_SELECT) + ` 
	and a.status=` + strconv.Itoa(models.STATUS_NORMAL) + ` and a.org_id='` + orgid + `'
	and a.course_id NOT in (
		select course_id from ta_course_detail where begin_date<=NOW() and status>` + strconv.Itoa(models.STATUS_DEL) + ` 
	)`
	err := m.db.Sql(sql).Find(&courses)
	return courses, err
}

// GetCourseWithCaseByLocation 根据位置获取课程信息
func (m *CourseDAO) GetCourseWithCaseByLocation(orgid, locationid string) ([]CourseWithCase, error) {
	var courses []CourseWithCase
	sql := `select a.*,b.case_name,b.case_address from ta_course a inner join sys_case b on a.case_id=b.case_id where a.status=` + strconv.Itoa(models.STATUS_NORMAL) + ` 
	and a.org_id='` + orgid + `' and a.location_id ='` + locationid + `' 
	and a.course_id NOT in (
		select course_id from ta_course_detail where begin_date<=NOW() and status>` + strconv.Itoa(models.STATUS_DEL) + ` 
	)`
	err := m.db.Sql(sql).Find(&courses)
	return courses, err
}

// CourseWithType 可用课程
type CourseWithType struct {
	model.TaCourse `xorm:"extends"`
	LocationName   string
}

// GetCourseCanUse 获取可用课程列表
func (m *CourseDAO) GetCourseCanUse(caseids string, page, pageSize int) ([]CourseWithType, error) {
	var courses []CourseWithType
	sql := `select a.*,b.location_name from ta_course a inner join td_cms_image_location b on a.location_id=b.location_id where a.status=? and 
	a.case_id in ('` + strings.Replace(caseids, ",", "','", -1) + `') and a.course_id not in (
		select course_id from ta_course_detail where begin_date<=NOW() and status>` + strconv.Itoa(models.STATUS_DEL) + ` 
	) order by a.create_date desc limit ` + strconv.Itoa((page-1)*pageSize) + `, ` + strconv.Itoa(pageSize)
	err := m.db.Sql(sql, models.STATUS_NORMAL).Find(&courses)
	// err := m.db.Where("status=?", models.STATUS_NORMAL).And("case_id in ('"+strings.Replace(caseids, ",", "','", -1)+"')").And("begin_date>NOW()").Desc("create_date").Limit(pageSize, (page-1)*pageSize).Find(&courses)
	return courses, err
}

// GetCourseCanUseCount 获取可用课程列表
func (m *CourseDAO) GetCourseCanUseCount(caseids string) (int, error) {
	var courses []model.TaCourse
	sql := `select * from ta_course where status=? and case_id in ('` + strings.Replace(caseids, ",", "','", -1) + `') and course_id not in (
		select course_id from ta_course_detail where begin_date<=NOW() and status>` + strconv.Itoa(models.STATUS_DEL) + ` 
	)`
	err := m.db.Sql(sql, models.STATUS_NORMAL).Find(&courses)
	// err := m.db.Where("status=?", models.STATUS_NORMAL).And("case_id in ('" + strings.Replace(caseids, ",", "','", -1) + "')").And("begin_date>NOW()").Find(&courses)
	return len(courses), err
}

// 微信首页列表课程
type CourseFront struct {
	model.TaCourse `xorm:"extends"`
	CaseName       string
	CaseAddress    string
	CourseTags     []TagDetail
}

// GetCourseForWechatFront 获取微信首页课程列表
func (m *CourseDAO) GetCourseForWechatFront(orgId string, page, pageSize int) ([]CourseFront, error) {
	var course []CourseFront
	sql := `SELECT
	a.*,
	b.case_name,
	b.case_address 
FROM
	ta_course a
	INNER JOIN sys_case b ON a.case_id = b.case_id 
WHERE
	a.org_id = '` + orgId + `' 
	AND a.STATUS = ` + strconv.Itoa(models.STATUS_NORMAL) + ` 
ORDER BY
	a.begin_date ASC 
	LIMIT ` + strconv.Itoa((page-1)*pageSize) + `, ` + strconv.Itoa(pageSize)
	err := m.db.Sql(sql).Find(&course)
	return course, err
}

// GetCourseForWechatFrontCount 获取微信首页课程数量
func (m *CourseDAO) GetCourseForWechatFrontCount(orgId string) (int, error) {
	var course []CourseFront
	sql := `SELECT
	a.*,
	b.case_name,
	b.case_address 
FROM
	ta_course a
	INNER JOIN sys_case b ON a.case_id = b.case_id 
WHERE
	a.org_id = '` + orgId + `' 
	AND a.STATUS = ` + strconv.Itoa(models.STATUS_NORMAL)
	err := m.db.Sql(sql).Find(&course)
	return len(course), err
}