XT_New/service/auto_create_week_schedules_...

package service

import (
	"fmt"
	"strings"
	"time"

	"XT_New/models"
	"XT_New/utils"

	"github.com/jinzhu/gorm"
	"github.com/robfig/cron"
)

// cron表达式 https://www.cnblogs.com/zuxingyu/p/6023919.html
var createWeekSchedulesCronJob *cron.Cron

func init() {
	utils.InfoLog("开启自动排班定时任务")
	createWeekSchedulesCronJob = cron.New()
	spec := "0 0 0 ? * MON" // 每周一凌晨0点生成排班
	//spec := "0 */1 * * * ?"
	createWeekSchedulesCronJob.AddFunc(spec, func() {
		AutoCreateWeekSchedules()
		NewAutoCreateWeekSchedules()
	})
}

func BeginAutoCreateWeekSchedulesJob() {
	createWeekSchedulesCronJob.Start()
}

func NewAutoCreateWeekSchedules() {
	utils.TraceLog("自动排班任务开始执行")
	var modes []*models.PatientScheduleTemplateMode
	getModesErr := readDb.Model(&models.PatientScheduleTemplateMode{}).Where("mode <> 0 AND status = 1").Find(&modes).Error
	if getModesErr != nil {
		utils.ErrorLog("自动排班-获取启用模板模式列表失败:%v", getModesErr)
		CreateDBErrorRecord(0, "自动排班-获取启用模板模式列表失败:%v", getModesErr)
		return
	}

	for _, mode := range modes {
		templates, getTemplatesErr := GetOrgPatientScheduleTemplateIDs(mode.OrgID)
		if getTemplatesErr != nil {
			utils.ErrorLog("自动排班-org_id: %v ：获取模板 ID 失败：%v", mode.OrgID, getTemplatesErr)
			CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：获取模板 ID 失败：%v", mode.OrgID, getTemplatesErr)
			continue
		} else if len(templates) == 0 {
			utils.WarningLog("自动排班-org_id: %v ：没有模板", mode.OrgID)
			continue
		}

		now := time.Now()
		nextSecWeek := now.AddDate(0, 0, 14)
		//nextThridWeek := now.AddDate(0, 0, 21)
		//nextFourWeek := now.AddDate(0, 0, 28)

		tx := writeDb.Begin()

		thisTime := time.Now()
		_, theWeek := thisTime.ISOWeek()

		//mode.Week == 0 为了兼容开发新功能前的老数据
		//新功能加了，预约排班生成的，int64(theWeek) >= mode.Week 当判断当前周数是否小大于或者等于模版预约第几周生成的周数
		if mode.Week == 0 || int64(theWeek) >= mode.Week {

			if mode.Mode == 1 { // 用第一周模板生成下第二周的排班

				items, getItemsErr := GetOrgPatientScheduleTemplateItemsWithoutPatientByTemplateID(mode.OrgID, templates[0].ID)
				if getItemsErr != nil {
					utils.ErrorLog("自动排班-org_id: %v ：获取第一周模板Item失败：%v", mode.OrgID, getItemsErr)
					CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：获取第一周模板Item失败：%v", mode.OrgID, getItemsErr)
					continue
				}
				insertErr, count := _refreshWeekSchedulesWithTemplateItems(tx, mode.OrgID, nextSecWeek, items, nil)
				if insertErr != nil {
					utils.ErrorLog("自动排班-org_id: %v ：使用第一周模板插入下第二周排班失败：%v", mode.OrgID, insertErr)
					CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：使用第一周模板插入下第二周排班失败：%v", mode.OrgID, insertErr)
					tx.Rollback()
					continue
				} else {
					//更新周次
					templates[0].Week = count
					UpdateTemplateItemWeek(templates[0].OrgID, templates[0].ID, int8(templates[0].Week))
					continue
				}
			} else if mode.Mode == 2 { // mode.ExecuteTimes % 2 的结果，如果为0，用第一周模板生成下第二周的排班，否则用第二周的模板生成排班
				if mode.ExecuteTimes%2 == 0 {
					items, getItemsErr := GetOrgPatientScheduleTemplateItemsWithoutPatientByTemplateID(mode.OrgID, templates[0].ID)
					if getItemsErr != nil {
						utils.ErrorLog("自动排班-org_id: %v ：获取第一周模板Item失败：%v", mode.OrgID, getItemsErr)
						CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：获取第一周模板Item失败：%v", mode.OrgID, getItemsErr)
						continue
					}

					insertErr, count := _refreshWeekSchedulesWithTemplateItems(tx, mode.OrgID, nextSecWeek, items, nil)
					if insertErr != nil {
						utils.ErrorLog("自动排班-org_id: %v ：使用第一周模板插入下第二周排班失败：%v", mode.OrgID, insertErr)
						CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：使用第一周模板插入下第二周排班失败：%v", mode.OrgID, insertErr)
						tx.Rollback()
						continue
					} else {
						//更新周次
						templates[0].Week = count
						UpdateTemplateItemWeek(templates[0].OrgID, templates[0].ID, int8(templates[0].Week))

						continue
					}

				} else {
					if len(templates) < 2 {
						utils.WarningLog("自动排班-org_id: %v ：没有第二周的模板")
						continue
					}
					items, getItemsErr := GetOrgPatientScheduleTemplateItemsWithoutPatientByTemplateID(mode.OrgID, templates[1].ID)
					if getItemsErr != nil {
						utils.ErrorLog("自动排班-org_id: %v ：获取第二周模板Item失败：%v", mode.OrgID, getItemsErr)
						CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：获取第二周模板Item失败：%v", mode.OrgID, getItemsErr)
						continue
					}

					insertErr, count := _refreshWeekSchedulesWithTemplateItems(tx, mode.OrgID, nextSecWeek, items, nil)
					if insertErr != nil {
						utils.ErrorLog("自动排班-org_id: %v ：使用第二周模板插入下第二周排班失败：%v", mode.OrgID, insertErr)
						CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：使用第二周模板插入下第二周排班失败：%v", mode.OrgID, insertErr)
						tx.Rollback()
						continue
					} else {
						//更新周次
						templates[1].Week = count
						UpdateTemplateItemWeek(templates[1].OrgID, templates[1].ID, int8(templates[1].Week))

						continue
					}
				}
			} else if mode.Mode == 3 { // mode.ExecuteTimes % 2 的结果，如果为0，用第一周模板生成下第二周的排班，否则用第二周的模板生成排班
				if mode.ExecuteTimes%3 == 0 {
					items, getItemsErr := GetOrgPatientScheduleTemplateItemsWithoutPatientByTemplateID(mode.OrgID, templates[0].ID)
					if getItemsErr != nil {
						utils.ErrorLog("自动排班-org_id: %v ：获取第一周模板Item失败：%v", mode.OrgID, getItemsErr)
						CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：获取第一周模板Item失败：%v", mode.OrgID, getItemsErr)
						continue
					}

					insertErr, count := _refreshWeekSchedulesWithTemplateItems(tx, mode.OrgID, nextSecWeek, items, nil)
					if insertErr != nil {
						utils.ErrorLog("自动排班-org_id: %v ：使用第一周模板插入下第三周排班失败：%v", mode.OrgID, insertErr)
						CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：使用第一周模板插入下第三周排班失败：%v", mode.OrgID, insertErr)
						tx.Rollback()
						continue
					} else {
						templates[0].Week = count
						UpdateTemplateItemWeek(templates[0].OrgID, templates[0].ID, int8(templates[0].Week))

						continue

					}

				} else if mode.ExecuteTimes%3 == 1 {
					if len(templates) < 2 {
						utils.WarningLog("自动排班-org_id: %v ：没有第二周的模板")
						continue
					}
					items, getItemsErr := GetOrgPatientScheduleTemplateItemsWithoutPatientByTemplateID(mode.OrgID, templates[1].ID)
					if getItemsErr != nil {
						utils.ErrorLog("自动排班-org_id: %v ：获取第一周模板Item失败：%v", mode.OrgID, getItemsErr)
						CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：获取第一周模板Item失败：%v", mode.OrgID, getItemsErr)
						continue
					}

					insertErr, count := _refreshWeekSchedulesWithTemplateItems(tx, mode.OrgID, nextSecWeek, items, nil)
					if insertErr != nil {
						utils.ErrorLog("自动排班-org_id: %v ：使用第一周模板插入下第三周排班失败：%v", mode.OrgID, insertErr)
						CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：使用第一周模板插入下第三周排班失败：%v", mode.OrgID, insertErr)
						tx.Rollback()
						continue
					} else {
						//更新周次
						templates[1].Week = count
						UpdateTemplateItemWeek(templates[1].OrgID, templates[1].ID, int8(templates[1].Week))

						continue
					}

				} else {
					if len(templates) < 3 {
						utils.WarningLog("自动排班-org_id: %v ：没有第三周的模板")
						continue
					}
					items, getItemsErr := GetOrgPatientScheduleTemplateItemsWithoutPatientByTemplateID(mode.OrgID, templates[2].ID)
					if getItemsErr != nil {
						utils.ErrorLog("自动排班-org_id: %v ：获取第三周模板Item失败：%v", mode.OrgID, getItemsErr)
						CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：获取第三周模板Item失败：%v", mode.OrgID, getItemsErr)
						continue
					}

					insertErr, count := _refreshWeekSchedulesWithTemplateItems(tx, mode.OrgID, nextSecWeek, items, nil)
					if insertErr != nil {
						utils.ErrorLog("自动排班-org_id: %v ：使用第三周模板插入下第三周排班失败：%v", mode.OrgID, insertErr)
						CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：使用第三周模板插入下第三周排班失败：%v", mode.OrgID, insertErr)
						tx.Rollback()
						continue
					} else {
						//更新周次
						templates[2].Week = count
						UpdateTemplateItemWeek(templates[2].OrgID, templates[2].ID, int8(templates[2].Week))

						continue
					}
				}
			} else if mode.Mode == 4 { // mode.ExecuteTimes % 2 的结果，如果为0，用第一周模板生成下第二周的排班，否则用第二周的模板生成排班
				if mode.ExecuteTimes%4 == 0 {
					items, getItemsErr := GetOrgPatientScheduleTemplateItemsWithoutPatientByTemplateID(mode.OrgID, templates[0].ID)
					if getItemsErr != nil {
						utils.ErrorLog("自动排班-org_id: %v ：获取第一周模板Item失败：%v", mode.OrgID, getItemsErr)
						CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：获取第一周模板Item失败：%v", mode.OrgID, getItemsErr)
						continue
					}

					insertErr, count := _refreshWeekSchedulesWithTemplateItems(tx, mode.OrgID, nextSecWeek, items, nil)
					if insertErr != nil {
						utils.ErrorLog("自动排班-org_id: %v ：使用第一周模板插入下第二周排班失败：%v", mode.OrgID, insertErr)
						CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：使用第一周模板插入下第二周排班失败：%v", mode.OrgID, insertErr)
						tx.Rollback()
						continue
					} else {
						//更新周次
						templates[0].Week = count
						UpdateTemplateItemWeek(templates[0].OrgID, templates[0].ID, int8(templates[0].Week))

						continue

					}

				} else if mode.ExecuteTimes%4 == 1 {
					items, getItemsErr := GetOrgPatientScheduleTemplateItemsWithoutPatientByTemplateID(mode.OrgID, templates[1].ID)
					if getItemsErr != nil {
						utils.ErrorLog("自动排班-org_id: %v ：获取第一周模板Item失败：%v", mode.OrgID, getItemsErr)
						CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：获取第一周模板Item失败：%v", mode.OrgID, getItemsErr)
						continue
					}

					insertErr, count := _refreshWeekSchedulesWithTemplateItems(tx, mode.OrgID, nextSecWeek, items, nil)
					if insertErr != nil {
						utils.ErrorLog("自动排班-org_id: %v ：使用第一周模板插入下第二周排班失败：%v", mode.OrgID, insertErr)
						CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：使用第一周模板插入下第二周排班失败：%v", mode.OrgID, insertErr)
						tx.Rollback()
						continue
					} else {

						//更新周次
						templates[1].Week = count
						UpdateTemplateItemWeek(templates[1].OrgID, templates[1].ID, int8(templates[1].Week))

						continue
					}

				} else if mode.ExecuteTimes%4 == 2 {
					if len(templates) < 2 {
						utils.WarningLog("自动排班-org_id: %v ：没有第二周的模板")
						continue
					}
					items, getItemsErr := GetOrgPatientScheduleTemplateItemsWithoutPatientByTemplateID(mode.OrgID, templates[2].ID)
					if getItemsErr != nil {
						utils.ErrorLog("自动排班-org_id: %v ：获取第一周模板Item失败：%v", mode.OrgID, getItemsErr)
						CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：获取第一周模板Item失败：%v", mode.OrgID, getItemsErr)
						continue
					}

					insertErr, count := _refreshWeekSchedulesWithTemplateItems(tx, mode.OrgID, nextSecWeek, items, nil)
					if insertErr != nil {
						utils.ErrorLog("自动排班-org_id: %v ：使用第一周模板插入下第二周排班失败：%v", mode.OrgID, insertErr)
						CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：使用第一周模板插入下第二周排班失败：%v", mode.OrgID, insertErr)
						tx.Rollback()
						continue
					} else {

						//更新周次
						templates[2].Week = count
						UpdateTemplateItemWeek(templates[2].OrgID, templates[2].ID, int8(templates[2].Week))

						continue
					}

				} else if mode.ExecuteTimes%4 == 3 {
					if len(templates) < 3 {
						utils.WarningLog("自动排班-org_id: %v ：没有第三周的模板")
						continue
					}
					items, getItemsErr := GetOrgPatientScheduleTemplateItemsWithoutPatientByTemplateID(mode.OrgID, templates[3].ID)
					if getItemsErr != nil {
						utils.ErrorLog("自动排班-org_id: %v ：获取第三周模板Item失败：%v", mode.OrgID, getItemsErr)
						CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：获取第三周模板Item失败：%v", mode.OrgID, getItemsErr)
						continue
					}

					insertErr, count := _refreshWeekSchedulesWithTemplateItems(tx, mode.OrgID, nextSecWeek, items, nil)
					if insertErr != nil {
						utils.ErrorLog("自动排班-org_id: %v ：使用第一周模板插入下第四周排班失败：%v", mode.OrgID, insertErr)
						CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：使用第一周模板插入下第三周排班失败：%v", mode.OrgID, insertErr)
						tx.Rollback()
						continue
					} else {
						//更新周次
						templates[3].Week = count
						UpdateTemplateItemWeek(templates[3].OrgID, templates[3].ID, int8(templates[3].Week))
						continue
					}

				}
			}
			mode.ExecuteTimes += 1
			mode.ModifyTime = now.Unix()
			updateModeErr := tx.Save(mode).Error
			if updateModeErr != nil {
				utils.ErrorLog("自动排班-org_id：%v ：更新启用模板模式的执行次数失败：%v", mode.OrgID, updateModeErr)
				CreateDBErrorRecord(mode.OrgID, "自动排班-org_id：%v ：更新启用模板模式的执行次数失败：%v", mode.OrgID, updateModeErr)
				tx.Rollback()
				continue
			}
			tx.Commit()
			utils.SuccessLog("自动排班-插入排班成功：org_id: %v", mode.OrgID)
			time.Sleep(time.Second * 30)
		}
		utils.SuccessLog("自动排班任务完成")

	}

}

func AutoCreateWeekSchedules() {
	utils.TraceLog("自动排班任务开始执行")
	var modes []*models.PatientScheduleTemplateMode
	getModesErr := readDb.Model(&models.PatientScheduleTemplateMode{}).Where("mode <> 0 AND status = 1").Find(&modes).Error
	if getModesErr != nil {
		utils.ErrorLog("自动排班-获取启用模板模式列表失败:%v", getModesErr)
		CreateDBErrorRecord(0, "自动排班-获取启用模板模式列表失败:%v", getModesErr)
		return
	}

	for _, mode := range modes {
		templates, getTemplatesErr := GetOrgPatientScheduleTemplateIDs(mode.OrgID)
		if getTemplatesErr != nil {
			utils.ErrorLog("自动排班-org_id: %v ：获取模板 ID 失败：%v", mode.OrgID, getTemplatesErr)
			CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：获取模板 ID 失败：%v", mode.OrgID, getTemplatesErr)
			continue
		} else if len(templates) == 0 {
			utils.WarningLog("自动排班-org_id: %v ：没有模板", mode.OrgID)
			continue
		}

		now := time.Now()
		nextSecWeek := now.AddDate(0, 0, 14)
		tx := writeDb.Begin()

		if mode.Mode == 1 { // 用第一周模板生成下第二周的排班
			items, getItemsErr := GetOrgPatientScheduleTemplateItemsWithoutPatientByTemplateID(mode.OrgID, templates[0].ID)
			if getItemsErr != nil {
				utils.ErrorLog("自动排班-org_id: %v ：获取第一周模板Item失败：%v", mode.OrgID, getItemsErr)
				CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：获取第一周模板Item失败：%v", mode.OrgID, getItemsErr)
				continue
			}
			insertErr, _ := _refreshWeekSchedulesWithTemplateItems(tx, mode.OrgID, nextSecWeek, items, nil)
			if insertErr != nil {
				utils.ErrorLog("自动排班-org_id: %v ：使用第一周模板插入下第二周排班失败：%v", mode.OrgID, insertErr)
				CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：使用第一周模板插入下第二周排班失败：%v", mode.OrgID, insertErr)
				tx.Rollback()
				continue
			}

		} else if mode.Mode == 2 { // mode.ExecuteTimes % 2 的结果，如果为0，用第一周模板生成下第二周的排班，否则用第二周的模板生成排班
			if mode.ExecuteTimes%2 == 0 {
				items, getItemsErr := GetOrgPatientScheduleTemplateItemsWithoutPatientByTemplateID(mode.OrgID, templates[0].ID)
				if getItemsErr != nil {
					utils.ErrorLog("自动排班-org_id: %v ：获取第一周模板Item失败：%v", mode.OrgID, getItemsErr)
					CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：获取第一周模板Item失败：%v", mode.OrgID, getItemsErr)
					continue
				}

				insertErr, _ := _refreshWeekSchedulesWithTemplateItems(tx, mode.OrgID, nextSecWeek, items, nil)
				if insertErr != nil {
					utils.ErrorLog("自动排班-org_id: %v ：使用第一周模板插入下第二周排班失败：%v", mode.OrgID, insertErr)
					CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：使用第一周模板插入下第二周排班失败：%v", mode.OrgID, insertErr)
					tx.Rollback()
					continue
				}

			} else {
				if len(templates) < 2 {
					utils.WarningLog("自动排班-org_id: %v ：没有第二周的模板")
					continue
				}
				items, getItemsErr := GetOrgPatientScheduleTemplateItemsWithoutPatientByTemplateID(mode.OrgID, templates[1].ID)
				if getItemsErr != nil {
					utils.ErrorLog("自动排班-org_id: %v ：获取第二周模板Item失败：%v", mode.OrgID, getItemsErr)
					CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：获取第二周模板Item失败：%v", mode.OrgID, getItemsErr)
					continue
				}

				insertErr, _ := _refreshWeekSchedulesWithTemplateItems(tx, mode.OrgID, nextSecWeek, items, nil)
				if insertErr != nil {
					utils.ErrorLog("自动排班-org_id: %v ：使用第二周模板插入下第二周排班失败：%v", mode.OrgID, insertErr)
					CreateDBErrorRecord(mode.OrgID, "自动排班-org_id: %v ：使用第二周模板插入下第二周排班失败：%v", mode.OrgID, insertErr)
					tx.Rollback()
					continue
				} else {

				}
			}
		}
		mode.ExecuteTimes += 1
		mode.ModifyTime = now.Unix()
		updateModeErr := tx.Save(mode).Error
		if updateModeErr != nil {
			utils.ErrorLog("自动排班-org_id：%v ：更新启用模板模式的执行次数失败：%v", mode.OrgID, updateModeErr)
			CreateDBErrorRecord(mode.OrgID, "自动排班-org_id：%v ：更新启用模板模式的执行次数失败：%v", mode.OrgID, updateModeErr)
			tx.Rollback()
			continue
		}
		tx.Commit()
		utils.SuccessLog("自动排班-插入排班成功：org_id: %v", mode.OrgID)
		time.Sleep(time.Second * 30)
	}

	utils.SuccessLog("自动排班任务完成")
}

func _refreshWeekSchedulesWithTemplateItems(tx *gorm.DB, orgID int64, week time.Time, templateItems []*models.PatientScheduleTemplateItem, deviceNumberMap map[int64]*DeviceNumberViewModel) (error, int) {
	if deviceNumberMap == nil {
		deviceNumbers, getDeviceNumbersErr := GetAllValidDeviceNumbers(orgID)
		//fmt.Println("getDeviceNumbersErr3232322332323232323323223232323",getDeviceNumbersErr)
		if getDeviceNumbersErr != nil {
			return getDeviceNumbersErr, 0
		}
		deviceNumberMap = make(map[int64]*DeviceNumberViewModel, 0)
		for _, deviceNumber := range deviceNumbers {
			deviceNumberMap[deviceNumber.ID] = deviceNumber
		}
	}

	now := time.Now()
	monday, sunday := utils.GetMondayAndSundayOfWeekDate(&week)
	disableErr := tx.Model(&models.Schedule{}).Where("user_org_id = ? AND status = 1 AND schedule_date >= ? AND schedule_date <= ?", orgID, monday.Unix(), sunday.Unix()).Updates(map[string]interface{}{"status": 0, "updated_time": now.Unix()}).Error
	//fmt.Println("disableErr323232332323232233222332232332",disableErr)
	if disableErr != nil {
		return disableErr, 0
	}

	var week_count int
	// 批量插入排班
	if len(templateItems) > 0 {

		timeLayout := "20060102"
		loc, _ := time.LoadLocation("Local")
		tmp, _ := time.ParseInLocation(timeLayout, time.Unix(monday.Unix(), 0).Format("2006-01-02"), loc)
		_, weeks := tmp.ISOWeek()
		week_count = weeks
		valueStrs := make([]string, 0, len(templateItems))
		values := make([]interface{}, 0, len(templateItems)*11)

		for _, item := range templateItems {
			deviceNumber := deviceNumberMap[item.DeviceNumberID]
			if deviceNumber == nil {
				continue
			}

			so, _ := GetDialysisSolutionTwo(item.OrgID, item.PatientID, item.TreatMode)
			filedRecordOne, _ := FindFiledBy(item.OrgID, "透析器")
			filedRecordTwo, _ := FindFiledBy(item.OrgID, "灌流器")
			filedRecordThree, _ := FindFiledBy(item.OrgID, "透析器/灌流器")
			var DialysisMachineName string
			if filedRecordOne.IsShow == 1 {
				DialysisMachineName = so.DialysisDialyszers
				//service.UpdateSchDName(schedule)
			}
			if filedRecordTwo.IsShow == 1 {
				DialysisMachineName = so.DialysisIrrigation
				//service.UpdateSchDName(schedule)
			}

			if filedRecordThree.IsShow == 1 {
				DialysisMachineName = so.DialyzerPerfusionApparatus
				//service.UpdateSchDName(schedule)
			}

			valueStrs = append(valueStrs, "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,?)")
			values = append(values, orgID)
			values = append(values, deviceNumber.ZoneID)
			values = append(values, item.DeviceNumberID)
			values = append(values, item.PatientID)
			values = append(values, monday.AddDate(0, 0, int(item.Weekday-1)).Unix())
			values = append(values, item.Weekday)
			values = append(values, item.TimeType)
			values = append(values, item.TreatMode)
			values = append(values, 1)
			values = append(values, now.Unix())
			values = append(values, now.Unix())
			values = append(values, DialysisMachineName)
		}
		sql := fmt.Sprintf("INSERT INTO xt_schedule (user_org_id, partition_id, bed_id, patient_id, schedule_date, schedule_week, schedule_type, mode_id, status, created_time, updated_time,dialysis_machine_name) VALUES %v;", strings.Join(valueStrs, ", "))
		if insertErr := tx.Exec(sql, values...).Error; insertErr != nil {
			//fmt.Println("insertErr232332233223332232323222222www",insertErr)
			return insertErr, 0
		}
	}

	return nil, week_count
}

func FakeAutoCreateNextTwoWeekSchedules(orgID int64) {
	mode, getModeErr := GetOrgPatientScheduleTemplateMode(orgID)
	if getModeErr != nil {
		utils.ErrorLog("%v", getModeErr)
		return
	}

	templates, getTemplatesErr := GetOrgPatientScheduleTemplateIDs(mode.OrgID)
	if getTemplatesErr != nil {
		utils.ErrorLog("获取模板 ID 失败：%v", getTemplatesErr)
		return
	} else if len(templates) == 0 {
		utils.WarningLog("没有模板")
		return
	}

	deviceNumbers, getDeviceNumbersErr := GetAllValidDeviceNumbers(orgID)
	if getDeviceNumbersErr != nil {
		utils.ErrorLog("获取床位列表失败:%v", getDeviceNumbersErr)
		return
	}
	deviceNumberMap := make(map[int64]*DeviceNumberViewModel, 0)
	for _, deviceNumber := range deviceNumbers {
		deviceNumberMap[deviceNumber.ID] = deviceNumber
	}

	now := time.Now()
	tx := writeDb.Begin()

	if mode.Mode == 1 { // 用第一周模板生成下两周的排班
		items, getItemsErr := GetOrgPatientScheduleTemplateItemsWithoutPatientByTemplateID(mode.OrgID, templates[0].ID)
		if getItemsErr != nil {
			utils.ErrorLog("获取第一周模板Item失败：%v", getItemsErr)
			return
		}
		insertErr, _ := _refreshWeekSchedulesWithTemplateItems(tx, mode.OrgID, now.AddDate(0, 0, 7), items, deviceNumberMap)
		if insertErr != nil {
			utils.ErrorLog("使用第一周模板插入下第一周排班失败：%v", insertErr)
			tx.Rollback()
			return
		}
		insertErr, _ = _refreshWeekSchedulesWithTemplateItems(tx, mode.OrgID, now.AddDate(0, 0, 14), items, deviceNumberMap)
		if insertErr != nil {
			utils.ErrorLog("使用第一周模板插入下第二周排班失败：%v", insertErr)
			tx.Rollback()
			return
		}

	} else if mode.Mode == 2 {
		firstItems, getFirstItemsErr := GetOrgPatientScheduleTemplateItemsWithoutPatientByTemplateID(mode.OrgID, templates[0].ID)
		if getFirstItemsErr != nil {
			utils.ErrorLog("获取第一周模板Item失败：%v", getFirstItemsErr)
			return
		}
		secItems, getSecItemsErr := GetOrgPatientScheduleTemplateItemsWithoutPatientByTemplateID(mode.OrgID, templates[1].ID)
		if getSecItemsErr != nil {
			utils.ErrorLog("获取第一周模板Item失败：%v", getSecItemsErr)
			return
		}

		if mode.ExecuteTimes%2 == 0 {
			insertErr, _ := _refreshWeekSchedulesWithTemplateItems(tx, mode.OrgID, now.AddDate(0, 0, 7), firstItems, deviceNumberMap)
			if insertErr != nil {
				utils.ErrorLog("使用第一周模板插入下第一周排班失败：%v", insertErr)
				tx.Rollback()
				return
			}
			insertErr, _ = _refreshWeekSchedulesWithTemplateItems(tx, mode.OrgID, now.AddDate(0, 0, 14), secItems, deviceNumberMap)
			if insertErr != nil {
				utils.ErrorLog("使用第二周模板插入下第二周排班失败：%v", insertErr)
				tx.Rollback()
				return
			}

		} else { // mode.ExecuteTimes%2 == 1
			insertErr, _ := _refreshWeekSchedulesWithTemplateItems(tx, mode.OrgID, now.AddDate(0, 0, 7), secItems, deviceNumberMap)
			if insertErr != nil {
				utils.ErrorLog("使用第二周模板插入下第一周排班失败：%v", mode.OrgID, insertErr)
				tx.Rollback()
				return
			}
			insertErr, _ = _refreshWeekSchedulesWithTemplateItems(tx, mode.OrgID, now.AddDate(0, 0, 14), firstItems, deviceNumberMap)
			if insertErr != nil {
				utils.ErrorLog("使用第一周模板插入下第二周排班失败：%v", mode.OrgID, insertErr)
				tx.Rollback()
				return
			}
		}
	}

	mode.ExecuteTimes += 2
	mode.ModifyTime = now.Unix()
	updateModeErr := tx.Save(mode).Error
	if updateModeErr != nil {
		utils.ErrorLog("更新启用模板模式的执行次数失败：%v", mode.OrgID, updateModeErr)
		tx.Rollback()
		return
	}

	tx.Commit()
	utils.SuccessLog("模拟自动更新下两周排班成功")
}