DigitalScholl/Learun.Framework.Ultimate V7/Learun.Framework.Module/Learun.Application.Module/Learun.Application.TwoDevelopment/EducationalAdministration/ArrangeLessonTerm/ArrangeLessonTermService.cs

using Dapper;
using Learun.DataBase.Repository;
using Learun.Util;
using System;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Linq;
using System.Net.Http;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
using Learun.Application.Base.SystemModule;
using Learun.Application.Organization;
using Newtonsoft.Json;
using static Learun.Application.TwoDevelopment.EducationalAdministration.ArrangeExamTermService;

namespace Learun.Application.TwoDevelopment.EducationalAdministration
{
    /// <summary>
    /// 版 本 Learun-ADMS-Ultimate V7.0.0 数字化智慧校园 
    /// Copyright (c) 2013-2018 北京泉江科技有限公司 
    /// 创 建：超级管理员
    /// 日 期：2019-02-27 11:05
    /// 描 述：排课
    /// </summary>
    public class ArrangeLessonTermService : RepositoryFactory
    {

        private static readonly HttpClient Client;
        static ArrangeLessonTermService()
        {
            Client = new HttpClient();
        }
        #region  构造函数和属性

        private string fieldSql;
        public ArrangeLessonTermService()
        {
            fieldSql = @"
                t.ALTId,
                t.LessonDate,
                t.AcademicYearNo,
                t.Semester,
                t.DeptNo,
                t.MajorNo,
                t.LessonNo,
                t.LessonName,
                t.TeachClassNo,
                t.TeachClassSn,
                t.EmpNo,
                t.EmpName,
                t.LessonSortNo,
                t.StuSortNo,
                t.JoinLessonNum,
                t.RelatedClassNo,
                t.ClassroomNo,
                t.LessonTime,
                t.Remark,
                t.CheckMark,
                t.RecordMark
            ";
        }
        #endregion

        #region  获取数据

        /// <summary>
        /// 获取列表数据
        /// <summary>
        /// <returns></returns>
        public IEnumerable<ArrangeLessonTermEntity> GetList(string queryJson)
        {
            try
            {
                //参考写法
                var queryParam = queryJson.ToJObject();
                // 虚拟参数
                var dp = new DynamicParameters(new { });

                var strSql = new StringBuilder();
                strSql.Append("SELECT ");
                strSql.Append(fieldSql);
                strSql.Append(" FROM ArrangeLessonTerm t where 1=1 ");

                if (!queryParam["AcademicYearNo"].IsEmpty())
                {
                    dp.Add("AcademicYearNo", queryParam["AcademicYearNo"].ToString(), DbType.String);
                    strSql.Append(" AND t.AcademicYearNo = @AcademicYearNo ");
                }
                if (!queryParam["Semester"].IsEmpty())
                {
                    dp.Add("Semester", queryParam["Semester"].ToString(), DbType.String);
                    strSql.Append(" AND t.Semester = @Semester ");
                }
                if (!queryParam["DeptNo"].IsEmpty())
                {
                    dp.Add("DeptNo", queryParam["DeptNo"].ToString(), DbType.String);
                    strSql.Append(" AND t.DeptNo = @DeptNo ");
                }
                if (!queryParam["MajorNo"].IsEmpty())
                {
                    dp.Add("MajorNo", queryParam["MajorNo"].ToString(), DbType.String);
                    strSql.Append(" AND t.MajorNo = @MajorNo ");
                }
                if (!queryParam["LessonNo"].IsEmpty())
                {
                    dp.Add("LessonNo", queryParam["LessonNo"].ToString(), DbType.String);
                    strSql.Append(" AND t.LessonNo = @LessonNo ");
                }
                if (!queryParam["TeachClassNo"].IsEmpty())
                {
                    dp.Add("TeachClassNo", "%" + queryParam["TeachClassNo"].ToString(), DbType.String);
                    strSql.Append(" AND t.TeachClassNo like @TeachClassNo ");
                }
                if (!queryParam["EmpNo"].IsEmpty())
                {
                    dp.Add("EmpNo", queryParam["EmpNo"].ToString(), DbType.String);
                    strSql.Append(" AND t.EmpNo = @EmpNo ");
                }
                if (!queryParam["ClassroomNo"].IsEmpty())
                {
                    dp.Add("ClassroomNo", queryParam["ClassroomNo"].ToString(), DbType.String);
                    strSql.Append(" AND t.ClassroomNo = @ClassroomNo ");
                }

                return this.BaseRepository("CollegeMIS").FindList<ArrangeLessonTermEntity>(strSql.ToString(), dp);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        internal IEnumerable<ArrangeLessonTermEntity> GetListByEmpNo(List<string> empNos)
        {
            try
            {
                return this.BaseRepository("CollegeMIS").FindList<ArrangeLessonTermEntity>(a => empNos.Contains(a.EmpNo)).ToList();
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        /// <summary>
        /// 获取列表分页数据
        /// <param name="pagination">分页参数</param>
        /// <summary>
        /// <returns></returns>
        public IEnumerable<ArrangeLessonTermEntity> GetPageList(Pagination pagination, string queryJson)
        {
            try
            {
                var strSql = new StringBuilder();
                strSql.Append("SELECT ");
                strSql.Append(fieldSql);
                strSql.Append(" FROM ArrangeLessonTerm t ");
                return this.BaseRepository("CollegeMIS").FindList<ArrangeLessonTermEntity>(strSql.ToString(), pagination);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        /// <summary>
        /// 获取实体数据
        /// <param name="keyValue">主键</param>
        /// <summary>
        /// <returns></returns>
        public ArrangeLessonTermEntity GetEntity(string keyValue)
        {
            try
            {
                return this.BaseRepository("CollegeMIS").FindEntity<ArrangeLessonTermEntity>(keyValue);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }


        #endregion

        #region  提交数据

        /// <summary>
        /// 删除实体数据
        /// <param name="keyValue">主键</param>
        /// <summary>
        /// <returns></returns>
        public void DeleteEntity(string keyValue)
        {
            try
            {
                this.BaseRepository("CollegeMIS").Delete<ArrangeLessonTermEntity>(t => t.ALTId == keyValue);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        /// <summary>
        /// 保存实体数据（新增、修改）
        /// <param name="keyValue">主键</param>
        /// <summary>
        /// <returns></returns>
        public void SaveEntity(string keyValue, ArrangeLessonTermEntity entity)
        {
            try
            {
                if (!string.IsNullOrEmpty(keyValue))
                {
                    entity.Modify(keyValue);
                    this.BaseRepository("CollegeMIS").Update(entity);
                }
                else
                {
                    entity.Create();
                    this.BaseRepository("CollegeMIS").Insert(entity);
                }
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        internal bool GetAny()
        {
            try
            {
                var semesterAndYear = Common.GetSemesterAndYear();
                return this.BaseRepository("CollegeMIS").FindList<ArrangeLessonTermEntity>(a => a.AcademicYearNo == semesterAndYear.AcademicYearShort && a.Semester == semesterAndYear.Semester).Any();

            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        #endregion



        /// <summary>
        /// 获取相关课程考勤的学生信息
        /// </summary>
        /// <param name="year"></param>
        /// <param name="semester"></param>
        /// <param name="empno"></param>
        /// <param name="lessonNo"></param>
        /// <param name="teachClassNo"></param>
        /// <returns></returns>
        public IEnumerable<StuSelectLessonListEntity> AttendanceStudents(Pagination pagination, string queryJson)
        {
            try
            {
                var queryParam = queryJson.ToJObject();
                var strSql = new StringBuilder();
                strSql.Append("SELECT ");
                strSql.Append(@"
                     a.[StuNo]
                    ,a.[DeptNo]
                    ,a.[MajorNo]
                    ,a.[ClassNo]
                    ,a.[StuName]
                    ,a.[GenderNo]
                    ,a.[AcademicYearNo]
                    ,a.[Semester]
                    ,a.[LessonNo]
                    ,a.[LessonName]
                    ,a.[TeachClassNo]
                    ,a.[LessonSortNo]
                    ,a.[Grade]
                    ,a.[ConflictLessonNo]
                    ,a.[EmpNo]
                    ,a.[TeachPlanNo],b.ID as StuAttendanceNo,b.AttendOrNo,b.Sort,b.AttenCondition,b.AttenScore 
                    ");
                strSql.Append(" FROM StuSelectLessonList a left join StuAttendance b on a.AcademicYearNo=b.AcademicYearNo and a.StuNo=b.StuNo and a.Semester=b.Semester and a.EmpNo=b.EmpNo and a.LessonNo=b.LessonNo and a.TeachClassNo=b.TeachClassNo ");
                strSql.Append($" and b.LessonTime='{queryParam["lessonTime"]}'");
                strSql.Append(" WHERE 1=1 ");
                strSql.Append($"and a.AcademicYearNo='{ queryParam["year"]}' and a.Semester='{queryParam["semester"]}' and a.EmpNo='{queryParam["empno"]}' and a.LessonNo='{queryParam["lessonNo"]}' and a.TeachClassNo='{queryParam["teachClassNo"]}' ");
                return this.BaseRepository("CollegeMIS").FindList<StuSelectLessonListEntity>(strSql.ToString(), pagination);


            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        private string strAcademicYear;
        private string strSemester;
        /// <summary>
        /// 同步排课系统数据
        /// </summary>
        /// <returns></returns>
        public async Task<bool> AsyncArrangeLessonData()
        {
            bool result = false;
            try
            {
                var apiData = await Client.GetStringAsync(Config.GetValue("ArrangeLessonAPI"));
                if (!string.IsNullOrEmpty(apiData))
                {
                    var data = JsonConvert.DeserializeObject<Root>(apiData);
                    var dataList = data.entity.list;
                    if (dataList.Any())
                    {
                        var oldArrangeLessonTermList = (await BaseRepository("CollegeMIS").FindListAsync<ArrangeLessonTermEntity>()).ToList();
                        var insertDataList = new List<ArrangeLessonTermEntity>();
                        var lessonData = (await BaseRepository("CollegeMIS").FindListAsync<LessonInfoEntity>()).ToList();
                        var classData = (await BaseRepository("CollegeMIS").FindListAsync<ClassInfoEntity>()).ToList();
                        foreach (var item in dataList)
                        {
                            var classinfo = classData.FirstOrDefault(m => m.ClassNo == item.paike.clazzId);
                            var insertData = new ArrangeLessonTermEntity
                            {
                                ALTId = Guid.NewGuid().ToString(),
                                LessonDate = DateTime.Parse(item.times),
                                AcademicYearNo = item.schoolYear,
                                Semester = item.paike.semester,
                                DeptNo = classinfo?.DeptNo,
                                MajorNo = classinfo?.MajorNo,
                                LessonNo = item.paike.curriculunId,
                                LessonName = item.paike.curriculunName,
                                TeachClassNo = item.paike.curriculunName + item.paike.clazzId,
                                EmpNo = item.paike.teacherId,
                                EmpName = item.paike.teacherName,
                                LessonSortNo = lessonData.FirstOrDefault(m => m.LessonNo == item.paike.curriculunId)?.LessonSortNo,
                                ClassroomNo = item.paike.classRoomId,
                                LessonTime = item.paike.week + item.paike.section,
                                CheckMark = "1",
                                F_SchoolId = item.schoolId
                            };
                            strAcademicYear = insertData.AcademicYearNo;
                            strSemester = insertData.Semester;
                            if (oldArrangeLessonTermList.Count(m => m.AcademicYearNo == insertData.AcademicYearNo && m.Semester == insertData.Semester
                                                                  && m.LessonNo == insertData.LessonNo && m.LessonDate == insertData.LessonDate
                                                                  && m.DeptNo == insertData.DeptNo && m.MajorNo == insertData.MajorNo
                                                                  && m.TeachClassNo == insertData.TeachClassNo && m.EmpNo == insertData.EmpNo
                                                                  && m.ClassroomNo == insertData.ClassroomNo && m.LessonTime == insertData.LessonTime
                                                                  && m.F_SchoolId == insertData.F_SchoolId) == 0
                                && insertDataList.Count(m => m.AcademicYearNo == insertData.AcademicYearNo && m.Semester == insertData.Semester
                                                                                                           && m.LessonNo == insertData.LessonNo && m.LessonDate == insertData.LessonDate
                                                                                                           && m.DeptNo == insertData.DeptNo && m.MajorNo == insertData.MajorNo
                                                                                                           && m.TeachClassNo == insertData.TeachClassNo && m.EmpNo == insertData.EmpNo
                                                                                                           && m.ClassroomNo == insertData.ClassroomNo && m.LessonTime == insertData.LessonTime
                                                                                                           && m.F_SchoolId == insertData.F_SchoolId) == 0)
                            {
                                insertDataList.Add(insertData);
                            }
                        }
                        var insertResult = await BaseRepository("CollegeMIS").InsertAsync(insertDataList);
                        //TeachClass数据处理

                        var arrangeLessonTermData = (await BaseRepository("CollegeMIS").FindListAsync<ArrangeLessonTermEntity>(@"select AcademicYearNo,Semester,DeptNo,majorno,lessonno,replace(teachclassno,lessonname,'') as teachclassno,empno from [dbo].[ArrangeLessonTerm] 
where (AcademicYearNo = '" + strAcademicYear + "') and semester='" + strSemester + @"'
group by AcademicYearNo,Semester,DeptNo,majorno,lessonno,replace(teachclassno,lessonname,'') ,empno ")).ToList();
                        var TeachClassData = (await BaseRepository("CollegeMIS").FindListAsync<TeachClassEntity>(@"SELECT   *
FROM      TeachClass
WHERE   (AcademicYearNo = '" + strAcademicYear + "') and semester='" + strSemester + "'  ")).ToList();
                        var insertTeachClassDataList = new List<TeachClassEntity>();
                        if (arrangeLessonTermData.Any())
                        {
                            foreach (var altitem in arrangeLessonTermData)
                            {
                                var insertTeachClassData = new TeachClassEntity()
                                {
                                    AcademicYearNo = altitem.AcademicYearNo,
                                    Semester = altitem.Semester,
                                    DeptNo = altitem.DeptNo,
                                    MajorNo = altitem.MajorNo,
                                    LessonNo = altitem.LessonNo,
                                    Grade = classData.FirstOrDefault(m => m.ClassNo == altitem.TeachClassNo)?.Grade,
                                    LessonSortNo = altitem.LessonSortNo,
                                    TeachClassNo = altitem.TeachClassNo,
                                    EmpNo = altitem.EmpNo,
                                    F_SchoolId = altitem.F_SchoolId
                                };
                                //非空判断
                                if (TeachClassData.Count(m => m.AcademicYearNo == insertTeachClassData.AcademicYearNo &&
                                                            m.Semester == insertTeachClassData.Semester && m.DeptNo == insertTeachClassData.DeptNo &&
                                                            m.MajorNo == insertTeachClassData.MajorNo && m.LessonNo == insertTeachClassData.LessonNo &&
                                                            m.Grade == insertTeachClassData.Grade && m.LessonSortNo == insertTeachClassData.LessonSortNo &&
                                                            m.TeachClassNo == insertTeachClassData.TeachClassNo && m.EmpNo == insertTeachClassData.EmpNo &&
                                                            m.F_SchoolId == insertTeachClassData.F_SchoolId) == 0
                                    && insertTeachClassDataList.Count(m => m.AcademicYearNo == insertTeachClassData.AcademicYearNo &&
                                          m.Semester == insertTeachClassData.Semester && m.DeptNo == insertTeachClassData.DeptNo &&
                                          m.MajorNo == insertTeachClassData.MajorNo && m.LessonNo == insertTeachClassData.LessonNo &&
                                          m.Grade == insertTeachClassData.Grade && m.LessonSortNo == insertTeachClassData.LessonSortNo &&
                                          m.TeachClassNo == insertTeachClassData.TeachClassNo && m.EmpNo == insertTeachClassData.EmpNo &&
                                          m.F_SchoolId == insertTeachClassData.F_SchoolId) == 0)
                                {
                                    insertTeachClassDataList.Add(insertTeachClassData);
                                }

                            }
                            await BaseRepository("CollegeMIS").InsertAsync(insertTeachClassDataList);
                        }
                        //继续openlessonplan同步
                        await AsyncOpenLessonPlanData();
                        if (insertResult > 0)
                        {
                            result = true;
                        }
                    }
                }

            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
            return result;
        }

        /// <summary>
        /// 同步专业开课计划数据,学生选课数据
        /// </summary>
        /// <returns></returns>
        public async Task<bool> AsyncOpenLessonPlanData()
        {
            bool result = false;
            try
            {
                var apiData = await Client.GetStringAsync(Config.GetValue("OpenLessonPlanAPI"));
                if (!string.IsNullOrEmpty(apiData))
                {
                    var openLessonPlanData = await BaseRepository("CollegeMIS").FindListAsync<OpenLessonPlanEntity>();
                    var data = JsonConvert.DeserializeObject<Root>(apiData);
                    var dataList = data.entity.list;
                    if (dataList.Any())
                    {
                        var insertDataList = new List<OpenLessonPlanEntity>();
                        var majorData = (await BaseRepository("CollegeMIS").FindListAsync<CdMajorEntity>()).ToList();
                        var lessonData = (await BaseRepository("CollegeMIS").FindListAsync<LessonInfoEntity>()).ToList();
                        foreach (var item in dataList)
                        {
                            var insertData = new OpenLessonPlanEntity()
                            {
                                MakeDate = DateTime.Now,
                                AcademicYearNo = item.schoolYear,
                                Semester = item.semester.shangxia,
                                DeptNo = majorData.Find(m => m.MajorNo == item.majorNumber).DeptNo,
                                MajorNo = item.majorNumber,
                                LessonNo = item.curriculumNumber,
                                LessonName = item.curriculumName,
                                PartCode = "",
                                Grade = item.grade,
                                LessonSortNo = lessonData.FirstOrDefault(m => m.LessonNo == item.curriculumNumber)?.LessonSortNo,
                                LessonSortDetailNo = lessonData.FirstOrDefault(m => m.LessonNo == item.curriculumNumber)?.LessonSortDetailNo,
                                StartWeek = 1,
                                EndWeek = !string.IsNullOrEmpty(item.semester.zhouci) ? Convert.ToInt32(item.semester.zhouci) : 1,
                                CheckStyleNo = "1",
                                ScoreRecordStyleNo = "1",
                                TeachDeptNo = majorData.Find(m => m.MajorNo == item.majorNumber).DeptNo,
                                StudyScore = lessonData.FirstOrDefault(m => m.LessonNo == item.curriculumNumber)?.StudyScore,
                                AmendDate = DateTime.Now,
                                ClassroomType = 1,
                                ClassroomPracticeType = 99,
                                CheckMarkDept = "1",
                                CheckMark = "1",
                                TestMark = 0,
                                F_SchoolId = item.schoolId
                            };
                            if (openLessonPlanData.Count(m => m.AcademicYearNo == insertData.AcademicYearNo &&
                                                              m.Semester == insertData.Semester &&
                                                              m.DeptNo == insertData.DeptNo &&
                                                              m.MajorNo == insertData.MajorNo &&
                                                              m.LessonNo == insertData.LessonNo &&
                                                              m.Grade == insertData.Grade &&
                                                              m.LessonSortNo == insertData.LessonSortNo &&
                                                              m.LessonName == insertData.LessonName &&
                                                              m.F_SchoolId == insertData.F_SchoolId) == 0 && insertDataList.Count(m => m.AcademicYearNo == insertData.AcademicYearNo &&
                                                                                                                                       m.Semester == insertData.Semester &&
                                                                                                                                       m.DeptNo == insertData.DeptNo &&
                                                                                                                                       m.MajorNo == insertData.MajorNo &&
                                                                                                                                       m.LessonNo == insertData.LessonNo &&
                                                                                                                                       m.Grade == insertData.Grade &&
                                                                                                                                       m.LessonSortNo == insertData.LessonSortNo &&
                                                                                                                                       m.LessonName == insertData.LessonName &&
                                                                                                                                       m.F_SchoolId == insertData.F_SchoolId) == 0)
                            {
                                insertDataList.Add(insertData);
                            }
                        }
                        var insertResult = await BaseRepository("CollegeMIS").InsertAsync(insertDataList);
                        //学生选课数据

                        var TeachClassData = (await BaseRepository("CollegeMIS").FindListAsync<TeachClassEntity>(@"SELECT   *
FROM      TeachClass
WHERE   (AcademicYearNo = '" + strAcademicYear + "') and semester='" + strSemester + "'  ")).ToList();
                        var stuinfobasicData = (await BaseRepository("CollegeMIS").FindListAsync<StuInfoBasicEntity>()).ToList();
                        var stuSelectLessonListEntityData = (await BaseRepository("CollegeMIS").FindListAsync<StuSelectLessonListEntity>()).ToList();
                        var insertStuSelectLessonListDataList = new List<StuSelectLessonListEntity>();
                        if (TeachClassData.Any())
                        {
                            foreach (var itemteachclass in TeachClassData)
                            {
                                var classstulist = stuinfobasicData.Where(m => m.ClassNo == itemteachclass.TeachClassNo)
                                    .ToList();
                                foreach (var stu in classstulist)
                                {
                                    var insertDatastuselect = new StuSelectLessonListEntity();
                                    insertDatastuselect.NoticeBookNo = stu.NoticeNo;
                                    insertDatastuselect.StuNo = stu.StuNo;
                                    insertDatastuselect.DeptNo = stu.DeptNo;
                                    insertDatastuselect.ClassNo = stu.ClassNo;
                                    insertDatastuselect.MajorNo = stu.MajorNo;
                                    insertDatastuselect.StuName = stu.StuName;
                                    insertDatastuselect.GenderNo = stu.GenderNo != null && stu.GenderNo.Value ? "1" : "0";
                                    insertDatastuselect.AcademicYearNo = itemteachclass.AcademicYearNo;
                                    insertDatastuselect.Semester = itemteachclass.Semester;
                                    insertDatastuselect.OpenLessonDeptNo = itemteachclass.DeptNo;
                                    insertDatastuselect.OpenLessonMajorNo = itemteachclass.MajorNo;
                                    insertDatastuselect.LessonNo = itemteachclass.LessonNo;
                                    insertDatastuselect.LessonName = lessonData.FirstOrDefault(m => m.LessonNo == itemteachclass.LessonNo)?.LessonName;
                                    insertDatastuselect.PartCode = "";
                                    insertDatastuselect.OrdinaryScoreScale = 1;
                                    insertDatastuselect.TermInScoreScale = 1;
                                    insertDatastuselect.TermEndScoreScale = 1;
                                    insertDatastuselect.OtherScoreScale = 1;
                                    insertDatastuselect.TeachClassNo = stu.ClassNo;
                                    insertDatastuselect.LessonSortNo = lessonData.FirstOrDefault(m => m.LessonNo == itemteachclass.LessonNo)?.LessonSortNo;
                                    insertDatastuselect.StuSortNo = "02";
                                    insertDatastuselect.Grade = stu.Grade;
                                    insertDatastuselect.StudyScore = lessonData.FirstOrDefault(m => m.LessonNo == itemteachclass.LessonNo).StudyScore == null ? 0 : lessonData.FirstOrDefault(m => m.LessonNo == itemteachclass.LessonNo).StudyScore;
                                    insertDatastuselect.TotalStudyHour = lessonData.FirstOrDefault(m => m.LessonNo == itemteachclass.LessonNo).TotalStudyHour == null ? 0 : lessonData.FirstOrDefault(m => m.LessonNo == itemteachclass.LessonNo).TotalStudyHour;
                                    insertDatastuselect.IsInEffect = "1";
                                    insertDatastuselect.EmpNo = itemteachclass.EmpNo;
                                    insertDatastuselect.IsPitchOn = "1";
                                    insertDatastuselect.CheckMark = "0";
                                    insertDatastuselect.InsertTime = DateTime.Now;
                                    insertDatastuselect.F_SchoolId = itemteachclass.F_SchoolId;
                                    if (stuSelectLessonListEntityData.Count(m => m.StuNo == insertDatastuselect.StuNo &&
                                                                                 m.AcademicYearNo == insertDatastuselect.AcademicYearNo &&
                                                                                 m.Semester == insertDatastuselect.Semester &&
                                                                                 m.DeptNo == insertDatastuselect.DeptNo &&
                                                                                 m.MajorNo == insertDatastuselect.MajorNo &&
                                                                                 m.LessonNo == insertDatastuselect.LessonNo &&
                                                                                 m.Grade == insertDatastuselect.Grade &&
                                                                                 m.OpenLessonDeptNo == insertDatastuselect.OpenLessonDeptNo &&
                                                                                 m.OpenLessonMajorNo == insertDatastuselect.OpenLessonMajorNo &&
                                                                                 m.EmpNo == insertDatastuselect.EmpNo && m.ClassNo == insertDatastuselect.ClassNo &&
                                                                                 m.F_SchoolId == insertDatastuselect.F_SchoolId) == 0 &&
                                                                                            insertStuSelectLessonListDataList.Count(m => m.StuNo == insertDatastuselect.StuNo &&
                                                                                            m.AcademicYearNo == insertDatastuselect.AcademicYearNo &&
                                                                                            m.Semester == insertDatastuselect.Semester &&
                                                                                            m.DeptNo == insertDatastuselect.DeptNo &&
                                                                                            m.MajorNo == insertDatastuselect.MajorNo &&
                                                                                            m.LessonNo == insertDatastuselect.LessonNo &&
                                                                                            m.Grade == insertDatastuselect.Grade &&
                                                                                            m.OpenLessonDeptNo == insertDatastuselect.OpenLessonDeptNo &&
                                                                                            m.OpenLessonMajorNo == insertDatastuselect.OpenLessonMajorNo &&
                                                                                            m.EmpNo == insertDatastuselect.EmpNo && m.ClassNo == insertDatastuselect.ClassNo &&
                                                                                            m.F_SchoolId == insertDatastuselect.F_SchoolId) == 0)
                                    {
                                        insertStuSelectLessonListDataList.Add(insertDatastuselect);
                                    }
                                }
                            }
                            await BaseRepository("CollegeMIS").InsertAsync(insertStuSelectLessonListDataList);
                        }
                        if (insertResult > 0)
                        {
                            result = true;
                        }

                    }
                }

            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
            return result;
        }

        /// <summary>
        /// 清空当前学期排课数据
        /// </summary>
        /// <returns></returns>
        public async Task<bool> AsyncModifyArrangeLessonData()
        {
            bool result = false;
            try
            {
                var apiData = await Client.GetStringAsync(Config.GetValue("ModifyArrangeLessonAPI"));
                if (!string.IsNullOrEmpty(apiData))
                {
                    var data = JsonConvert.DeserializeObject<Root>(apiData);
                    if (data.success)
                    {
                        var semesterAndYear = Common.GetSemesterAndYear();
                        var strAcademicYear = semesterAndYear.AcademicYearShort;
                        var strSemester = semesterAndYear.Semester;
                        var executeResult = await BaseRepository("CollegeMIS").ExecuteAsyncBySql(
                            $"delete from ArrangeLessonTerm where AcademicYearNo='{strAcademicYear}' and Semester='{strSemester}' ");
                        await BaseRepository("CollegeMIS").ExecuteAsyncBySql(
                              $"delete from TeachClass where AcademicYearNo='{strAcademicYear}' and Semester='{strSemester}' ");
                        await BaseRepository("CollegeMIS").ExecuteAsyncBySql(
                              $"delete from OpenLessonPlan where AcademicYearNo='{strAcademicYear}' and Semester='{strSemester}' ");
                        await BaseRepository("CollegeMIS").ExecuteAsyncBySql(
                            $"delete from StuSelectLessonList where AcademicYearNo='{strAcademicYear}' and Semester='{strSemester}' ");
                        if (executeResult > 0)
                        {
                            result = true;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
            return result;
        }

        /// <summary>
        /// 按条件同步排课数据
        /// </summary>
        /// <returns></returns>
        public async Task<bool> AsyncArrangeLessonDataByCondition(ArrangeLessonTermEntity entity)
        {
            bool result = false;
            try
            {
                var lessonData = (await BaseRepository("CollegeMIS").FindListAsync<LessonInfoEntity>()).ToList();
                var classData = (await BaseRepository("CollegeMIS").FindListAsync<ClassInfoEntity>()).ToList();
                var classroomData = (await BaseRepository("CollegeMIS").FindListAsync<ClassroomInfoEntity>()).ToList();
                if (entity.SyncType == "1")
                {
                    var LessonList = BaseRepository("paikeDbString").FindList<paikeList>(
                         @"SELECT a.week AS 'week', a.section AS 'section',a.timetext AS 'timetext',c.name AS 'classname',c.number AS 'classnumber',
                                            r.name AS 'roomname',r.number AS 'ClassroomNo',t.name AS 'teachername',t.number AS 'teacherNumber', cu.name AS 'curriculunName',
                                            cu.number AS 'curriculunNumber', s.year AS 'year', s.number AS 'semester'
                                            FROM tb_paike a 
                                            LEFT JOIN tb_clazz c ON c.id= a.`clazzid` 
                                            LEFT JOIN tb_classroom  r ON r.id =a.`classroomid`
                                            LEFT JOIN tb_teacher t ON t.id =a.`teacherid`
                                            LEFT JOIN tb_curriculum cu ON cu.id=a.`curriculunid`
                                            LEFT JOIN tb_semester s ON s.id=a.`semester`
                    WHERE 1=1 AND c.number IS NOT NULL  AND s.year = '" + entity.AcademicYearNo + "' AND s.number ='" + entity.Semester + "'");

                    if (LessonList.Count() > 0)
                    {
                        var oldArrangeLessonTermList = (await BaseRepository("CollegeMIS").FindListAsync<ArrangeLessonTermEntity>()).ToList();
                        var insertDataList = new List<ArrangeLessonTermEntity>();
                        foreach (var item in LessonList)
                        {
                            var classinfo = classData.FirstOrDefault(m => m.ClassNo == item.classnumber);
                            var timesArr = item.timetext.Substring(0, item.timetext.Length - 1).Split(',');
                            foreach (var timesItem in timesArr)
                            {
                                var insertData = new ArrangeLessonTermEntity
                                {
                                    ALTId = Guid.NewGuid().ToString(),
                                    LessonDate = DateTime.Parse(timesItem),
                                    AcademicYearNo = item.year,
                                    Semester = item.semester,
                                    DeptNo = classinfo?.DeptNo,
                                    MajorNo = classinfo?.MajorNo,
                                    LessonNo = item.curriculunNumber,
                                    LessonName = item.curriculunName,
                                    TeachClassNo = item.curriculunName + classinfo?.ClassNo,
                                    EmpNo = item.teacherNumber,
                                    EmpName = item.teachername,
                                    LessonSortNo = lessonData.FirstOrDefault(m => m.LessonNo == item.curriculunNumber)?.LessonSortNo,
                                    ClassroomNo = classroomData.FirstOrDefault(m => m.ClassroomNo == item.ClassroomNo)?.ClassroomNo,
                                    LessonTime = item.week + item.section,
                                    CheckMark = "1",
                                    F_SchoolId = entity.F_SchoolId
                                };
                                if (oldArrangeLessonTermList.Count(m => m.AcademicYearNo == insertData.AcademicYearNo && m.Semester == insertData.Semester
                                                                      && m.LessonNo == insertData.LessonNo && m.LessonDate.Value.Date == insertData.LessonDate.Value.Date
                                                                      && m.DeptNo == insertData.DeptNo && m.MajorNo == insertData.MajorNo
                                                                      && m.TeachClassNo == insertData.TeachClassNo && m.EmpNo == insertData.EmpNo
                                                                      && m.ClassroomNo == insertData.ClassroomNo && m.LessonTime == insertData.LessonTime
                                                                      && m.F_SchoolId == insertData.F_SchoolId) == 0
                                    && insertDataList.Count(m => m.AcademicYearNo == insertData.AcademicYearNo && m.Semester == insertData.Semester
                                                                                                               && m.LessonNo == insertData.LessonNo && m.LessonDate.Value.Date == insertData.LessonDate.Value.Date
                                                                                                               && m.DeptNo == insertData.DeptNo && m.MajorNo == insertData.MajorNo
                                                                                                               && m.TeachClassNo == insertData.TeachClassNo && m.EmpNo == insertData.EmpNo
                                                                                                               && m.ClassroomNo == insertData.ClassroomNo && m.LessonTime == insertData.LessonTime
                                                                                                               && m.F_SchoolId == insertData.F_SchoolId) == 0)
                                {
                                    insertDataList.Add(insertData);
                                    BaseRepository("CollegeMIS").Insert(insertData);
                                }
                            }
                        }

                    }
                }
                else
                {
                    //TeachClass数据处理 20211214改为直接读取mysql库
                    var teachclasslist = BaseRepository("paikeDbString").FindList<TeachClassEntity>(@"SELECT   clazz.name AS 'clazzname',
                clazz.number AS 'TeachClassNo',
                curriculum.name AS 'curriculumname',
                curriculum.number AS 'LessonNo',
                semester.year AS 'AcademicYearNo',
                semester.number AS 'Semester',
                a.jointclass AS 'jointclass',
                a.type AS 'LessonSortNo',
                a.classhour AS 'classhour',
                room.name AS 'roomname',
                room.number AS 'roomnumber',
                teacher.name AS 'teachername',
                teacher.number AS 'EmpNo'
                FROM tb_class_plan a
                    LEFT JOIN tb_clazz  clazz ON clazz.id = a.clazzid
                LEFT JOIN tb_semester semester ON semester.id = clazz.semester
                LEFT JOIN tb_curriculum  curriculum ON curriculum.id = a.curriculum
                LEFT JOIN tb_classroom  room ON room.id = a.classroom
                LEFT JOIN tb_teacher teacher ON teacher.id = a.teacher
                WHERE  a.type='1' and semester.year = '" + entity.AcademicYearNo + "' AND  semester.number = '" + entity.Semester + "'");
                    var TeachClassData = (await BaseRepository("CollegeMIS").FindListAsync<TeachClassEntity>(@"SELECT   *
                            FROM      TeachClass
                            WHERE   (AcademicYearNo = '" + entity.AcademicYearNo + "') and semester='" + entity.Semester + "' and F_SchoolId='" + entity.F_SchoolId + "'  ")).ToList();
                    //待插入数据
                    var insertTeachClassDataList = new List<TeachClassEntity>();
                    foreach (var teachClassEntity in teachclasslist)
                    {
                        var classitemEntity = classData.FirstOrDefault(m => m.ClassNo == teachClassEntity.TeachClassNo);
                        var insertTeachClassData = new TeachClassEntity()
                        {
                            AcademicYearNo = teachClassEntity.AcademicYearNo,
                            Semester = teachClassEntity.Semester,
                            DeptNo = classitemEntity?.DeptNo,
                            MajorNo = classitemEntity?.MajorNo,
                            LessonNo = teachClassEntity.LessonNo,
                            Grade = classitemEntity?.Grade,
                            LessonSortNo = teachClassEntity.LessonSortNo,
                            TeachClassNo = teachClassEntity.TeachClassNo,
                            EmpNo = teachClassEntity.EmpNo,
                            F_SchoolId = entity.F_SchoolId
                        };
                        //非空判断
                        if (TeachClassData.Count(m => m.AcademicYearNo == insertTeachClassData.AcademicYearNo &&
                                                    m.Semester == insertTeachClassData.Semester && m.DeptNo == insertTeachClassData.DeptNo &&
                                                    m.MajorNo == insertTeachClassData.MajorNo && m.LessonNo == insertTeachClassData.LessonNo &&
                                                    m.Grade == insertTeachClassData.Grade && m.LessonSortNo == insertTeachClassData.LessonSortNo &&
                                                    m.TeachClassNo == insertTeachClassData.TeachClassNo && m.EmpNo == insertTeachClassData.EmpNo &&
                                                    m.F_SchoolId == insertTeachClassData.F_SchoolId) == 0
                            && insertTeachClassDataList.Count(m => m.AcademicYearNo == insertTeachClassData.AcademicYearNo &&
                                  m.Semester == insertTeachClassData.Semester && m.DeptNo == insertTeachClassData.DeptNo &&
                                  m.MajorNo == insertTeachClassData.MajorNo && m.LessonNo == insertTeachClassData.LessonNo &&
                                  m.Grade == insertTeachClassData.Grade && m.LessonSortNo == insertTeachClassData.LessonSortNo &&
                                  m.TeachClassNo == insertTeachClassData.TeachClassNo && m.EmpNo == insertTeachClassData.EmpNo &&
                                  m.F_SchoolId == insertTeachClassData.F_SchoolId) == 0)
                        {
                            insertTeachClassDataList.Add(insertTeachClassData);
                        }
                    }
                    await BaseRepository("CollegeMIS").InsertAsync(insertTeachClassDataList);
                    //继续openlessonplan同步
                    await AsyncOpenLessonPlanDataByCondition(entity);
                }
                result = true;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
            return result;
        }

        /// <summary>
        /// 按条件同步专业开课计划数据,学生选课数据
        /// </summary>
        /// <returns></returns>
        public async Task<bool> AsyncOpenLessonPlanDataByCondition(ArrangeLessonTermEntity entity)
        {
            try
            {
                var TeachList = BaseRepository("paikeDbString").FindList<TeachClassEntity>(
                    @"select  m.name AS 'MajorName', m.number AS 'MajorNo', tt.EmpNo AS 'EmpNo', 
                                tt.EmpName AS 'EmpName', sc.name AS 'F_SchoolName', sc.sid AS 'F_SchoolId', 
                                p.grade AS 'Grade', p.classhour AS 'classhour', curr.name AS 'LessonName', curr.number AS 'LessonNo',
                                s.year AS 'AcademicYearNo', s.number AS 'Semester' ,cour.`assessmentmethod` AS 'ExamType' FROM  tb_major_plan p
                                LEFT JOIN (
						                                SELECT
						                                t.teacher,
						                                GROUP_CONCAT(DISTINCT c.`name`) AS 'EmpName',
						                                GROUP_CONCAT(DISTINCT c.number) AS 'EmpNo'
						                                 FROM
							                                tb_major_plan t
				                                 LEFT JOIN tb_teacher c ON FIND_IN_SET(c.id, t.teacher) > 0
				                                 GROUP BY
					                                t.teacher
				                                ) tt ON tt.teacher = p.teacher
                                LEFT JOIN tb_semester s ON s.id=p.`semester`
                                LEFT JOIN tb_school sc ON sc.`id`= p.`school`
                                LEFT JOIN tb_major m ON m.id=p.major 
                                LEFT JOIN tb_course cour ON cour.id= p.`course`
                                LEFT JOIN tb_curriculum curr ON curr.id=cour.`course`
                                WHERE  s.year = '" + entity.AcademicYearNo + "' AND  s.number = '" + entity.Semester
                    + "'   AND sc.sid = '" + entity.F_SchoolId + "' AND curr.`ification` ='1' ORDER BY p.`major` ");

                var majorData = (await BaseRepository("CollegeMIS").FindListAsync<CdMajorEntity>()).ToList();
                var lessonData = (await BaseRepository("CollegeMIS").FindListAsync<LessonInfoEntity>()).ToList();

                if (TeachList.Count() > 0)
                {
                    var openLessonPlanData = await BaseRepository("CollegeMIS").FindListAsync<OpenLessonPlanEntity>();
                    var now = DateTime.Now;
                    var insertDataList = new List<OpenLessonPlanEntity>();

                    foreach (var item in TeachList)
                    {
                        foreach (var itemTeach in item.EmpNo.Split(','))
                        {
                            var insertData = new OpenLessonPlanEntity()
                            {
                                TeachNo = itemTeach,
                                MakeDate = now,
                                AcademicYearNo = item.AcademicYearNo,
                                Semester = item.Semester,
                                DeptNo = majorData.FirstOrDefault(m => m.MajorNo == item.MajorNo)?.DeptNo,
                                MajorNo = item.MajorNo,
                                LessonNo = item.LessonNo,
                                LessonName = item.LessonName,
                                PartCode = "",
                                Grade = item.Grade,
                                LessonSortNo = lessonData.FirstOrDefault(m => m.LessonNo == item.LessonSortNo)
                                    ?.LessonSortNo,
                                LessonSortDetailNo = lessonData
                                    .FirstOrDefault(m => m.LessonNo == item.LessonSortDetailNo)?.LessonSortDetailNo,
                                StartWeek = item.StartWeek,
                                EndWeek = item.EndWeek,
                                CheckStyleNo = "1",
                                ScoreRecordStyleNo = "1",
                                TeachDeptNo = majorData.FirstOrDefault(m => m.MajorNo == item.MajorNo)?.DeptNo,
                                StudyScore = 0,
                                AmendDate = now,
                                ClassroomType = 1,
                                ClassroomPracticeType = 99,
                                CheckMarkDept = "1",
                                CheckMark = "1",
                                TestMark = 0,
                                F_SchoolId = item.F_SchoolId,
                                State = 1,
                                ExamType = item.ExamType
                            };
                            if (openLessonPlanData.Count(m => m.AcademicYearNo == insertData.AcademicYearNo &&
                                                              m.Semester == insertData.Semester &&
                                                              m.MajorNo == insertData.MajorNo &&
                                                              m.LessonNo == insertData.LessonNo &&
                                                              m.Grade == insertData.Grade &&
                                                              m.LessonSortNo == insertData.LessonSortNo &&
                                                              m.LessonName == insertData.LessonName &&
                                                              m.F_SchoolId == insertData.F_SchoolId) == 0 &&
                                insertDataList.Count(m => m.AcademicYearNo == insertData.AcademicYearNo &&
                                                          m.Semester == insertData.Semester &&
                                                          m.MajorNo == insertData.MajorNo &&
                                                          m.LessonNo == insertData.LessonNo &&
                                                          m.Grade == insertData.Grade &&
                                                          m.LessonSortNo == insertData.LessonSortNo &&
                                                          m.LessonName == insertData.LessonName &&
                                                          m.F_SchoolId == insertData.F_SchoolId) == 0)
                            {
                                insertDataList.Add(insertData);
                            }
                        }
                    }
                    await BaseRepository("CollegeMIS").InsertAsync(insertDataList);
                }
                //学生选课数据
                var TeachClassData = (await BaseRepository("CollegeMIS").FindListAsync<TeachClassEntity>(@"SELECT   *
                                    FROM      TeachClass
                                    WHERE   (AcademicYearNo = '" + entity.AcademicYearNo + "') and semester='" + entity.Semester + "' and F_SchoolId='" + entity.F_SchoolId + "'  ")).ToList();
                var stuinfobasicData = (await BaseRepository("CollegeMIS").FindListAsync<StuInfoBasicEntity>()).ToList();
                var stuSelectLessonListEntityData = (await BaseRepository("CollegeMIS").FindListAsync<StuSelectLessonListEntity>()).ToList();
                var insertStuSelectLessonListDataList = new List<StuSelectLessonListEntity>();
                if (TeachClassData.Any())
                {
                    foreach (var itemteachclass in TeachClassData)
                    {
                        var classstulist = stuinfobasicData.Where(m => m.ClassNo == itemteachclass.TeachClassNo)
                            .ToList();
                        foreach (var stu in classstulist)
                        {
                            var insertDatastuselect = new StuSelectLessonListEntity();
                            insertDatastuselect.NoticeBookNo = stu.NoticeNo;
                            insertDatastuselect.StuNo = stu.StuNo;
                            insertDatastuselect.DeptNo = stu.DeptNo;
                            insertDatastuselect.ClassNo = stu.ClassNo;
                            insertDatastuselect.MajorNo = stu.MajorNo;
                            insertDatastuselect.StuName = stu.StuName;
                            insertDatastuselect.GenderNo = stu.GenderNo != null && stu.GenderNo.Value ? "1" : "0";
                            insertDatastuselect.AcademicYearNo = itemteachclass.AcademicYearNo;
                            insertDatastuselect.Semester = itemteachclass.Semester;
                            insertDatastuselect.OpenLessonDeptNo = itemteachclass.DeptNo;
                            insertDatastuselect.OpenLessonMajorNo = itemteachclass.MajorNo;
                            insertDatastuselect.LessonNo = itemteachclass.LessonNo;
                            insertDatastuselect.LessonName = lessonData.FirstOrDefault(m => m.LessonNo == itemteachclass.LessonNo)?.LessonName;
                            insertDatastuselect.PartCode = "";
                            insertDatastuselect.OrdinaryScoreScale = 1;
                            insertDatastuselect.TermInScoreScale = 1;
                            insertDatastuselect.TermEndScoreScale = 1;
                            insertDatastuselect.OtherScoreScale = 1;
                            insertDatastuselect.TeachClassNo = stu.ClassNo;
                            insertDatastuselect.LessonSortNo = lessonData.FirstOrDefault(m => m.LessonNo == itemteachclass.LessonNo)?.LessonSortNo;
                            insertDatastuselect.StuSortNo = "02";
                            insertDatastuselect.Grade = stu.Grade;
                            insertDatastuselect.StudyScore = 0;
                            insertDatastuselect.TotalStudyHour = 0;
                            insertDatastuselect.IsInEffect = "1";
                            insertDatastuselect.EmpNo = itemteachclass.EmpNo;
                            insertDatastuselect.IsPitchOn = "1";
                            insertDatastuselect.CheckMark = "1";
                            insertDatastuselect.InsertTime = DateTime.Now;
                            insertDatastuselect.F_SchoolId = itemteachclass.F_SchoolId;
                            if (stuSelectLessonListEntityData.Count(m => m.StuNo == insertDatastuselect.StuNo &&
                                                                         m.AcademicYearNo == insertDatastuselect.AcademicYearNo &&
                                                                         m.Semester == insertDatastuselect.Semester &&
                                                                         m.DeptNo == insertDatastuselect.DeptNo &&
                                                                         m.MajorNo == insertDatastuselect.MajorNo &&
                                                                         m.LessonNo == insertDatastuselect.LessonNo &&
                                                                         m.Grade == insertDatastuselect.Grade &&
                                                                         m.OpenLessonDeptNo == insertDatastuselect.OpenLessonDeptNo &&
                                                                         m.OpenLessonMajorNo == insertDatastuselect.OpenLessonMajorNo &&
                                                                         m.EmpNo == insertDatastuselect.EmpNo && m.ClassNo == insertDatastuselect.ClassNo &&
                                                                         m.F_SchoolId == insertDatastuselect.F_SchoolId) == 0 &&
                                                                                    insertStuSelectLessonListDataList.Count(m => m.StuNo == insertDatastuselect.StuNo &&
                                                                                    m.AcademicYearNo == insertDatastuselect.AcademicYearNo &&
                                                                                    m.Semester == insertDatastuselect.Semester &&
                                                                                    m.DeptNo == insertDatastuselect.DeptNo &&
                                                                                    m.MajorNo == insertDatastuselect.MajorNo &&
                                                                                    m.LessonNo == insertDatastuselect.LessonNo &&
                                                                                    m.Grade == insertDatastuselect.Grade &&
                                                                                    m.OpenLessonDeptNo == insertDatastuselect.OpenLessonDeptNo &&
                                                                                    m.OpenLessonMajorNo == insertDatastuselect.OpenLessonMajorNo &&
                                                                                    m.EmpNo == insertDatastuselect.EmpNo && m.ClassNo == insertDatastuselect.ClassNo &&
                                                                                    m.F_SchoolId == insertDatastuselect.F_SchoolId) == 0)
                            {
                                insertStuSelectLessonListDataList.Add(insertDatastuselect);
                            }
                        }
                    }
                    await BaseRepository("CollegeMIS").InsertAsync(insertStuSelectLessonListDataList);
                }
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
            return true;
        }

        /// <summary>
        /// 按条件清空排课数据
        /// </summary>
        /// <returns></returns>
        public async Task<bool> AsyncModifyArrangeLessonDataByCondition(ArrangeLessonTermEntity entity)
        {
            bool result = false;
            var db = BaseRepository("CollegeMIS");
            try
            {
                if (entity.SyncType == "1")
                {
                    HttpContent httpContent = new StringContent("{\"school\":\"" + entity.F_SchoolId + "\",\"year\":\"" + entity.AcademicYearNo + "\",\"number\":\"" + entity.Semester + "\"}");
                    httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
                    string apiData = await Client.PostAsync(Config.GetValue("ModifyArrangeLessonAPI"), httpContent).Result.Content.ReadAsStringAsync();

                    if (!string.IsNullOrEmpty(apiData))
                    {
                        var data = JsonConvert.DeserializeObject<Root>(apiData);
                        if (data.success)
                        {
                            db.BeginTrans();
                            db.ExecuteBySql(
                                $"delete from ArrangeLessonTerm where F_SchoolId='{entity.F_SchoolId}' and AcademicYearNo='{entity.AcademicYearNo}' and Semester='{entity.Semester}' ");
                            db.Commit();
                            result = true;
                        }
                    }
                }
                else
                {
                    db.BeginTrans();
                    db.ExecuteBySql(
                         $"delete from TeachClass where F_SchoolId='{entity.F_SchoolId}' and AcademicYearNo='{entity.AcademicYearNo}' and Semester='{entity.Semester}' ");
                    db.ExecuteBySql(
                        $"delete from OpenLessonPlan where F_SchoolId='{entity.F_SchoolId}' and AcademicYearNo='{entity.AcademicYearNo}' and Semester='{entity.Semester}' ");
                    db.ExecuteBySql(
                        $"delete from StuSelectLessonList where F_SchoolId='{entity.F_SchoolId}' and AcademicYearNo='{entity.AcademicYearNo}' and Semester='{entity.Semester}' ");
                    db.Commit();
                    result = true;
                }
            }
            catch (Exception ex)
            {
                db.Rollback();
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
            return result;
        }


        /// <summary>
        /// 课程表
        /// </summary>
        /// <param name="userAccount">账号</param>
        /// <param name="userType">用户类型 学生 教师</param>
        /// <param name="startDate">查询开始时间</param>
        /// <param name="endDate">查询截止时间</param>
        /// <returns></returns>
        public IEnumerable<TimeTable> GetTimeTable(string userAccount, string userType, string startDate, string endDate)
        {
            var semesterAndYear = Common.GetSemesterAndYear(startDate);
            var strAcademicYear = semesterAndYear.AcademicYearShort;
            var strSemester = semesterAndYear.Semester;
            string sql;
            if (userType == "学生")
            {
                sql = @"SELECT 
                      b.LessonNo,b.AcademicYearNo as AcademicYear,b.LessonName,b.LessonTime,b.LessonDate,b.Empname EmpName,b.EmpNo,c.ClassroomName,b.Semester,b.ClassroomNo as ClassRoomNo,b.LessonSortNo,d.ClassName,e.EnName from StuSelectLessonList a 
                      left join ArrangeLessonTerm b on b.TeachClassNo=RTRIM(a.LessonName) + RTRIM(a.PartCode) + RTRIM(a.TeachClassNo) 
                      left join ClassroomInfo c on c.ClassroomNo=b.classroomNo 
                      left join ClassInfo d on replace(b.TeachClassNo,b.LessonName,'')=d.ClassNo 
                      left join LessonInfo e on a.LessonNo=e.LessonNo 
                      where a.StuNo=@userAccount and a.AcademicYearNo=@strAcademicYear and a.Semester=@strSemester 
                      and b.AcademicYearNo=@strAcademicYear and b.Semester=@strSemester 
                      and b.LessonDate>=@startDate and b.LessonDate<=@endDate and b.CheckMark=1";
            }
            else
            {
                sql = @"select b.AcademicYearNo as AcademicYear,b.LessonNo,e.EnName,b.LessonName,b.LessonTime,b.LessonDate,b.EmpNo,b.Empname EmpName,replace(b.TeachClassNo,b.LessonName,'') TeachClassNo, c.ClassroomName,b.Semester,b.ClassroomNo as ClassRoomNo,b.LessonSortNo,d.ClassName from ArrangeLessonTerm b 
                        left join ClassroomInfo c on c.ClassroomNo=b.classroomNo
                        left join ClassInfo d on replace(b.TeachClassNo,b.LessonName,'')=d.ClassNo 
                        left join LessonInfo e on b.LessonNo=e.LessonNo 
                        where b.EmpNo=@userAccount and b.AcademicYearNo=@strAcademicYear and b.Semester=@strSemester
                        and b.LessonDate>=@startDate and b.LessonDate<=@endDate and b.CheckMark=1";
            }

            try
            {
                var result = BaseRepository("CollegeMIS").FindList<TimeTable>(sql, new { userAccount, startDate, endDate, strAcademicYear, strSemester });
                return result;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        public IEnumerable<CdMajorEntity> GetMajors(string academicYearNo, string semester)
        {
            try
            {
                //var data = BaseRepository("CollegeMIS").FindList<CdMajorEntity>(m => m.CheckMark == true);

                //根据学年学期判断排课同步数据表中是否有数据：若有，说明该学年学期同步过；若没有，修改基础表，false；
                var aa = this.BaseRepository("CollegeMIS").FindEntity<ArrangeLessonSyncEntity>(x => x.AcademicYearNo == academicYearNo && x.Semester == semester && x.STypeId == "3");
                if (aa == null)
                {
                    this.BaseRepository("CollegeMIS").ExecuteBySql("update CdMajor set SyncFlag='false' ");
                }

                //数据
                var db = BaseRepository("CollegeMIS");
                db.BeginTrans();
                var data = db.FindList<CdMajorEntity>("select * from CdMajor where CheckMark=1 and ID not in (select STableId from ArrangeLessonSync where AcademicYearNo='" + academicYearNo + "' and Semester='" + semester + "' )");
                DateTime syncdate = DateTime.Now;
                foreach (var item in data.Select(m => m.ID))
                {
                    ArrangeLessonSyncEntity alsEntity = new ArrangeLessonSyncEntity();
                    alsEntity.Create();
                    alsEntity.AcademicYearNo = academicYearNo;
                    alsEntity.Semester = semester;
                    alsEntity.STypeId = "3";
                    alsEntity.SDate = syncdate;
                    alsEntity.STableId = item;
                    db.Insert(alsEntity);
                }
                db.Commit();
                return data;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }
        public IEnumerable<CdMajorEntity> GetMajorsNotRecord(string academicYearNo, string semester)
        {
            try
            {
                //var data = BaseRepository("CollegeMIS").FindList<CdMajorEntity>(m => m.CheckMark == true);

                var db = BaseRepository("CollegeMIS");
                db.BeginTrans();
                var data = db.FindList<CdMajorEntity>("select * from CdMajor where CheckMark=1 and ID not in (select STableId from ArrangeLessonSync where AcademicYearNo='" + academicYearNo + "' and Semester='" + semester + "' )");

                db.Commit();
                return data;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }

        public IEnumerable<ClassroomInfoEntity> GetClassrooms(string academicYearNo, string semester)
        {
            try
            {
                //var data = BaseRepository("CollegeMIS").FindList<ClassroomInfoEntity>(m => m.CheckMark == true);

                //根据学年学期判断排课同步数据表中是否有数据：若有，说明该学年学期同步过；若没有，修改基础表，false；
                var aa = this.BaseRepository("CollegeMIS").FindEntity<ArrangeLessonSyncEntity>(x => x.AcademicYearNo == academicYearNo && x.Semester == semester && x.STypeId == "6");
                if (aa == null)
                {
                    this.BaseRepository("CollegeMIS").ExecuteBySql("update ClassroomInfo set SyncFlag='false' ");
                }

                //数据
                var db = BaseRepository("CollegeMIS");
                db.BeginTrans();
                var data = db.FindList<ClassroomInfoEntity>("select * from ClassroomInfo where CheckMark=1 and ClassroomId not in (select STableId from ArrangeLessonSync where AcademicYearNo='" + academicYearNo + "' and Semester='" + semester + "' )");
                DateTime syncdate = DateTime.Now;
                foreach (var item in data.Select(m => m.ClassroomId))
                {
                    ArrangeLessonSyncEntity alsEntity = new ArrangeLessonSyncEntity();
                    alsEntity.Create();
                    alsEntity.AcademicYearNo = academicYearNo;
                    alsEntity.Semester = semester;
                    alsEntity.STypeId = "6";
                    alsEntity.SDate = syncdate;
                    alsEntity.STableId = item;
                    db.Insert(alsEntity);
                }
                db.Commit();
                return data;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }
        public IEnumerable<ClassroomInfoEntity> GetClassroomsNotRecord(string academicYearNo, string semester)
        {
            try
            {
                //var data = BaseRepository("CollegeMIS").FindList<ClassroomInfoEntity>(m => m.CheckMark == true);

                var db = BaseRepository("CollegeMIS");
                db.BeginTrans();
                var data = db.FindList<ClassroomInfoEntity>("select * from ClassroomInfo where CheckMark=1 and ClassroomId not in (select STableId from ArrangeLessonSync where AcademicYearNo='" + academicYearNo + "' and Semester='" + semester + "' )");

                db.Commit();
                return data;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }

        public IEnumerable<CdClassTypeEntity> GetClassType()
        {
            try
            {
                var data = BaseRepository("CollegeMIS").FindList<CdClassTypeEntity>();
                return data;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }

        public IEnumerable<LessonInfoEntity> GetLessons(string academicYearNo, string semester)
        {
            try
            {
                //var data = BaseRepository("CollegeMIS").FindList<LessonInfoEntity>(m => m.CheckMark == true);

                //根据学年学期判断排课同步数据表中是否有数据：若有，说明该学年学期同步过；若没有，修改基础表，false；
                var aa = this.BaseRepository("CollegeMIS").FindEntity<ArrangeLessonSyncEntity>(x => x.AcademicYearNo == academicYearNo && x.Semester == semester && x.STypeId == "5");
                if (aa == null)
                {
                    this.BaseRepository("CollegeMIS").ExecuteBySql("update LessonInfo set SyncFlag='false' ");
                }

                //数据
                var db = BaseRepository("CollegeMIS");
                db.BeginTrans();
                var data = db.FindList<LessonInfoEntity>("select * from LessonInfo where CheckMark=1 and LessonId not in (select STableId from ArrangeLessonSync where AcademicYearNo='" + academicYearNo + "' and Semester='" + semester + "' )");
                DateTime syncdate = DateTime.Now;
                foreach (var item in data.Select(m => m.LessonId))
                {
                    ArrangeLessonSyncEntity alsEntity = new ArrangeLessonSyncEntity();
                    alsEntity.Create();
                    alsEntity.AcademicYearNo = academicYearNo;
                    alsEntity.Semester = semester;
                    alsEntity.STypeId = "5";
                    alsEntity.SDate = syncdate;
                    alsEntity.STableId = item;
                    db.Insert(alsEntity);
                }
                db.Commit();
                return data;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }
        public IEnumerable<LessonInfoEntity> GetLessonsNotRecord(string academicYearNo, string semester)
        {
            try
            {
                //var data = BaseRepository("CollegeMIS").FindList<LessonInfoEntity>(m => m.CheckMark == true);

                var db = BaseRepository("CollegeMIS");
                db.BeginTrans();
                var data = db.FindList<LessonInfoEntity>("select * from LessonInfo where CheckMark=1 and LessonId not in (select STableId from ArrangeLessonSync where AcademicYearNo='" + academicYearNo + "' and Semester='" + semester + "' )");

                db.Commit();
                return data;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }

        public IEnumerable<CdLessonSortDetailEntity> GetLessonSortDetails()
        {
            try
            {
                var data = BaseRepository("CollegeMIS").FindList<CdLessonSortDetailEntity>();
                return data;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }

        public IEnumerable<CdLessonSortEntity> GetLessonSorts()
        {
            try
            {
                var data = BaseRepository("CollegeMIS").FindList<CdLessonSortEntity>();
                return data;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }

        public IEnumerable<EmpInfoEntity> GetTeachers(string academicYearNo, string semester)
        {
            try
            {
                //var data = BaseRepository("CollegeMIS").FindList<EmpInfoEntity>("select a.*,b.F_Password,b.F_Secretkey from dbo.EmpInfo a left join adms7ultimate2.dbo.LR_Base_User b  on a.EmpNo=b.F_EnCode where a.CheckMark=1");

                //根据学年学期判断排课同步数据表中是否有数据：若有，说明该学年学期同步过；若没有，修改基础表，false；
                var aa = this.BaseRepository("CollegeMIS").FindEntity<ArrangeLessonSyncEntity>(x => x.AcademicYearNo == academicYearNo && x.Semester == semester && x.STypeId == "7");
                if (aa == null)
                {
                    this.BaseRepository("CollegeMIS").ExecuteBySql("update EmpInfo set SyncFlag='false' ");
                }

                //数据
                var db = BaseRepository("CollegeMIS");
                var dbbase = BaseRepository();
                db.BeginTrans();
                var data = db.FindList<EmpInfoEntity>("select a.*,b.F_Password,b.F_Secretkey from dbo.EmpInfo a left join " + dbbase.getDbConnection().Database + ".dbo.LR_Base_User b  on a.EmpNo=b.F_EnCode where a.CheckMark=1 and a.ishaslesson=1 and b.F_DeleteMark=0 and a.EmpId not in (select STableId from ArrangeLessonSync where AcademicYearNo='" + academicYearNo + "' and Semester='" + semester + "' )");
                DateTime syncdate = DateTime.Now;
                foreach (var item in data.Select(m => m.EmpId))
                {
                    ArrangeLessonSyncEntity alsEntity = new ArrangeLessonSyncEntity();
                    alsEntity.Create();
                    alsEntity.AcademicYearNo = academicYearNo;
                    alsEntity.Semester = semester;
                    alsEntity.STypeId = "7";
                    alsEntity.SDate = syncdate;
                    alsEntity.STableId = item;
                    db.Insert(alsEntity);
                }
                db.Commit();
                return data;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }
        public IEnumerable<EmpInfoEntity> GetTeachersNotRecord(string academicYearNo, string semester)
        {
            try
            {
                //var data = BaseRepository("CollegeMIS").FindList<EmpInfoEntity>("select a.*,b.F_Password,b.F_Secretkey from dbo.EmpInfo a left join adms7ultimate2.dbo.LR_Base_User b  on a.EmpNo=b.F_EnCode where a.CheckMark=1");

                var db = BaseRepository("CollegeMIS");
                var dbbase = BaseRepository();
                db.BeginTrans();
                var data = db.FindList<EmpInfoEntity>("select a.*,b.F_Password,b.F_Secretkey from dbo.EmpInfo a left join " + dbbase.getDbConnection().Database + ".dbo.LR_Base_User b  on a.EmpNo=b.F_EnCode where a.CheckMark=1 and a.ishaslesson=1 and b.F_DeleteMark=0 and a.EmpId not in (select STableId from ArrangeLessonSync where AcademicYearNo='" + academicYearNo + "' and Semester='" + semester + "' )");

                db.Commit();
                return data;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }

        public IEnumerable<ClassInfoEntity> GetClasses(string academicYearNo, string semester)
        {
            try
            {
                //var data = BaseRepository("CollegeMIS").FindList<ClassInfoEntity>(m => m.CheckMark == true);

                //根据学年学期判断排课同步数据表中是否有数据：若有，说明该学年学期同步过；若没有，修改基础表，false；
                var aa = this.BaseRepository("CollegeMIS").FindEntity<ArrangeLessonSyncEntity>(x => x.AcademicYearNo == academicYearNo && x.Semester == semester && x.STypeId == "4");
                if (aa == null)
                {
                    this.BaseRepository("CollegeMIS").ExecuteBySql("update ClassInfo set SyncFlag='false' ");
                }

                //数据
                var db = BaseRepository("CollegeMIS");
                db.BeginTrans();
                var data = db.FindList<ClassInfoEntity>("select * from ClassInfo where CheckMark=1 and ClassId not in (select STableId from ArrangeLessonSync where AcademicYearNo='" + academicYearNo + "' and Semester='" + semester + "' )");
                DateTime syncdate = DateTime.Now;
                foreach (var item in data.Select(m => m.ClassId))
                {
                    ArrangeLessonSyncEntity alsEntity = new ArrangeLessonSyncEntity();
                    alsEntity.Create();
                    alsEntity.AcademicYearNo = academicYearNo;
                    alsEntity.Semester = semester;
                    alsEntity.STypeId = "4";
                    alsEntity.SDate = syncdate;
                    alsEntity.STableId = item;
                    db.Insert(alsEntity);
                }
                db.Commit();
                return data;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }
        public IEnumerable<ClassInfoEntity> GetClassesNotRecord(string academicYearNo, string semester)
        {
            try
            {
                //var data = BaseRepository("CollegeMIS").FindList<ClassInfoEntity>(m => m.CheckMark == true);

                var db = BaseRepository("CollegeMIS");
                db.BeginTrans();
                var data = db.FindList<ClassInfoEntity>("select * from ClassInfo where CheckMark=1 and ClassId not in (select STableId from ArrangeLessonSync where AcademicYearNo='" + academicYearNo + "' and Semester='" + semester + "' )");

                db.Commit();
                return data;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }

        public IEnumerable<StuInfoBasicEntity> GetStus(string academicYearNo, string semester)
        {
            try
            {
                //var data = BaseRepository("CollegeMIS").FindList<StuInfoBasicEntity>(@"select a.StuId,a.StuNo,a.DeptNo,a.MajorNo,a.Grade,a.ClassNo,a.StuName,a.GenderNo,a.Birthday,b.F_Password,b.F_Secretkey from dbo.StuInfoBasic a left join adms7ultimate2.dbo.LR_Base_User b  on a.StuNo=b.F_EnCode where a.CheckMark='1'");

                //根据学年学期判断排课同步数据表中是否有数据：若有，说明该学年学期同步过；若没有，修改基础表，false；
                var aa = this.BaseRepository("CollegeMIS").FindEntity<ArrangeLessonSyncEntity>(x => x.AcademicYearNo == academicYearNo && x.Semester == semester && x.STypeId == "8");
                if (aa == null)
                {
                    this.BaseRepository("CollegeMIS").ExecuteBySql("update StuInfoBasic set SyncFlag='false' ");
                }

                //数据
                var db = BaseRepository("CollegeMIS");
                var dbbase = BaseRepository();
                db.BeginTrans();
                var data = db.FindList<StuInfoBasicEntity>("select a.*,b.F_Password,b.F_Secretkey from dbo.StuInfoBasic a left join " + dbbase.getDbConnection().Database + ".dbo.LR_Base_User b  on a.StuNo=b.F_EnCode where a.CheckMark=1 and a.StuId not in (select STableId from ArrangeLessonSync where AcademicYearNo='" + academicYearNo + "' and Semester='" + semester + "' )");
                DateTime syncdate = DateTime.Now;
                foreach (var item in data.Select(m => m.StuId))
                {
                    ArrangeLessonSyncEntity alsEntity = new ArrangeLessonSyncEntity();
                    alsEntity.Create();
                    alsEntity.AcademicYearNo = academicYearNo;
                    alsEntity.Semester = semester;
                    alsEntity.STypeId = "8";
                    alsEntity.SDate = syncdate;
                    alsEntity.STableId = item;
                    db.Insert(alsEntity);
                }
                db.Commit();
                return data;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }

        public IEnumerable<StuInfoBasicEntity> GetStusNotRecord(string academicYearNo, string semester)
        {
            try
            {
                //var data = BaseRepository("CollegeMIS").FindList<StuInfoBasicEntity>(@"select a.StuId,a.StuNo,a.DeptNo,a.MajorNo,a.Grade,a.ClassNo,a.StuName,a.GenderNo,a.Birthday,b.F_Password,b.F_Secretkey from dbo.StuInfoBasic a left join adms7ultimate2.dbo.LR_Base_User b  on a.StuNo=b.F_EnCode where a.CheckMark='1'");

                //数据
                var db = BaseRepository("CollegeMIS");
                var dbbase = BaseRepository();
                db.BeginTrans();
                var data = db.FindList<StuInfoBasicEntity>("select a.*,b.F_Password,b.F_Secretkey from dbo.StuInfoBasic a left join " + dbbase.getDbConnection().Database + ".dbo.LR_Base_User b  on a.StuNo=b.F_EnCode where a.CheckMark=1 and a.StuId not in (select STableId from ArrangeLessonSync where AcademicYearNo='" + academicYearNo + "' and Semester='" + semester + "' )");

                db.Commit();
                return data;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }
        public IEnumerable<StuInfoBasicEntity> GetStudents()
        {
            try
            {
                var data = BaseRepository("CollegeMIS").FindList<StuInfoBasicEntity>(@"select a.StuId,a.StuNo,a.DeptNo,a.MajorNo,a.Grade,a.ClassNo,
a.StuName,GenderNo,a.Birthday,b.F_Password,b.F_Secretkey from 
dbo.StuInfoBasic a left join adms7ultimate2.dbo.LR_Base_User b  on a.StuNo=b.F_EnCode where a.CheckMark='1'");
                return data;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }

        public IEnumerable<TeachClassEntity> GetClassLessons()
        {
            try
            {
                var data = BaseRepository("CollegeMIS").FindList<TeachClassEntity>(@"select AcademicYearNo,Semester,DeptNo,MajorNo,LessonNo,TeachClassNo,EmpNo,LessonSortNo from TeachClass 
group by  AcademicYearNo,Semester,DeptNo,MajorNo,LessonNo,TeachClassNo,EmpNo,LessonSortNo");
                return data;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }


        /// <summary>
        /// 课程表【教务】
        /// </summary>
        /// <param name="startDate">查询开始时间</param>
        /// <param name="endDate">查询截止时间</param>
        /// <param name="classNo">班级编号</param>
        /// <param name="empNo">教师编号</param>
        /// <returns></returns>
        public IEnumerable<TimeTable> GetTimeTableInEducation(string startDate, string endDate, string classNo, string empNo, string schoolId)
        {
            var semesterAndYear = Common.GetSemesterAndYear(startDate);
            var strAcademicYear = semesterAndYear.AcademicYearShort;
            var strSemester = semesterAndYear.Semester;
            string sql = @"select b.F_SchoolId,b.DeptNo,b.MajorNo,b.AcademicYearNo as AcademicYear,b.LessonNo,b.LessonName,b.LessonTime,b.LessonDate,b.EmpNo,b.Empname EmpName,replace (b.TeachClassNo,b.LessonName,'') TeachClassNo, c.ClassroomName,b.Semester,b.ClassroomNo as ClassRoomNo,b.LessonSortNo,d.ClassName 
                            from ArrangeLessonTerm b 
                            left join ClassroomInfo c on c.ClassroomNo=b.classroomNo 
                            left join ClassInfo d on replace(b.TeachClassNo,b.LessonName,'')=d.ClassNo 
                            where b.AcademicYearNo=@strAcademicYear and b.Semester=@strSemester  
                            and b.LessonDate>=@startDate and b.LessonDate<=@endDate 
                            and b.CheckMark=1";
            try
            {
                var result = BaseRepository("CollegeMIS").FindList<TimeTable>(sql, new { startDate, endDate, strAcademicYear, strSemester });
                if (!string.IsNullOrEmpty(classNo))
                {
                    result = result.Where(x => x.TeachClassNo == classNo);
                }
                if (!string.IsNullOrEmpty(empNo))
                {
                    result = result.Where(x => x.EmpNo == empNo);
                }
                if (!string.IsNullOrEmpty(schoolId))
                {
                    result = result.Where(x => x.F_SchoolId == schoolId);
                }
                return result;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        /// <summary>
        /// 课程表【教务】--班级下拉框信息
        /// </summary>
        /// <returns></returns>
        public IEnumerable<SelectModel> GetClassData(string schoolId)
        {
            try
            {
                //前三年-后三年
                var preYear = DateTime.Now.AddYears(-3).Year;
                var nextYear = DateTime.Now.AddYears(3).Year;
                var yearList = new List<string>();
                for (int i = preYear; i <= nextYear; i++)
                {
                    yearList.Add(string.Format("'{0}-{1}'", i.ToString().Substring(2), (i + 1).ToString().Substring(2)));
                }
                var yearListStr = string.Join(",", yearList.ToArray());

                var strSql = new StringBuilder();
                strSql.Append("select distinct REPLACE(a.TeachClassNo,a.LessonName,'') as value,c.ClassName as text from ");
                strSql.Append("ArrangeLessonTerm a inner join ClassInfo c on REPLACE(a.TeachClassNo,a.LessonName,'')=c.ClassNo ");
                strSql.Append("where a.AcademicYearNo in (" + yearListStr + ") ");
                if (!string.IsNullOrEmpty(schoolId))
                {
                    strSql.Append(" and a.F_SchoolId = '" + schoolId + "' ");
                }

                var result = this.BaseRepository("CollegeMIS").FindList<SelectModel>(strSql.ToString()).OrderBy(x => x.value);
                return result;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        /// <summary>
        /// 课程表【教务】--教师下拉框信息
        /// </summary>
        /// <param name="startDate"></param>
        /// <returns></returns>
        public IEnumerable<SelectModel> GetTeacherData(string schoolId)
        {
            try
            {
                //前三年-后三年
                var preYear = DateTime.Now.AddYears(-3).Year;
                var nextYear = DateTime.Now.AddYears(3).Year;
                var yearList = new List<string>();
                for (int i = preYear; i <= nextYear; i++)
                {
                    yearList.Add(string.Format("{0}-{1}", i.ToString().Substring(2), (i + 1).ToString().Substring(2)));
                }
                var aa = new List<SelectModel>();
                //必修课
                var teacherData = this.BaseRepository("CollegeMIS").FindList<ArrangeLessonTermEntity>(x => yearList.Contains(x.AcademicYearNo));
                if (!string.IsNullOrEmpty(schoolId))
                {
                    teacherData = teacherData.Where(x => x.F_SchoolId == schoolId);
                }
                var teacherDataModel = teacherData.Select(x => new { x.EmpNo, x.EmpName }).Distinct().ToList()
                    .Select(x => new SelectModel()
                    {
                        text = x.EmpName,
                        value = x.EmpNo
                    });
                aa.AddRange(teacherDataModel);
                //选修课
                var teacherData2 = this.BaseRepository("CollegeMIS").FindList<ArrangeLessonTermOfElectiveEntity>(x => yearList.Contains(x.AcademicYearNo));
                if (!string.IsNullOrEmpty(schoolId))
                {
                    teacherData2 = teacherData2.Where(x => x.F_SchoolId == schoolId);
                }
                var teacherDataModel2 = teacherData2.Select(x => new { x.EmpNo, x.EmpName }).Distinct().ToList()
                    .Select(x => new SelectModel()
                    {
                        text = x.EmpName,
                        value = x.EmpNo
                    });
                aa.AddRange(teacherDataModel2);

                var aaaa = aa.Select(x => new { x.text, x.value }).Distinct().ToList();
                var aaaaa = aaaa.Select(x => new SelectModel()
                {
                    text = x.text,
                    value = x.value
                }).OrderBy(x => x.value);

                return aaaaa;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        public IEnumerable<CdDeptEntity> GetDepts(string academicYearNo, string semester)
        {
            try
            {
                //var data = BaseRepository("CollegeMIS").FindList<CdDeptEntity>();

                //根据学年学期判断排课同步数据表中是否有数据：若有，说明该学年学期同步过；若没有，修改基础表，false；
                var aa = this.BaseRepository("CollegeMIS").FindEntity<ArrangeLessonSyncEntity>(x => x.AcademicYearNo == academicYearNo && x.Semester == semester && x.STypeId == "2");
                if (aa == null)
                {
                    this.BaseRepository("CollegeMIS").ExecuteBySql("update CdDept set SyncFlag='false' ");
                }

                //数据
                var db = BaseRepository("CollegeMIS");
                db.BeginTrans();
                var data = db.FindList<CdDeptEntity>("select * from CdDept where DeptId not in (select STableId from ArrangeLessonSync where AcademicYearNo='" + academicYearNo + "' and Semester='" + semester + "' )");
                DateTime syncdate = DateTime.Now;
                foreach (var item in data.Select(m => m.DeptId))
                {
                    ArrangeLessonSyncEntity alsEntity = new ArrangeLessonSyncEntity();
                    alsEntity.Create();
                    alsEntity.AcademicYearNo = academicYearNo;
                    alsEntity.Semester = semester;
                    alsEntity.STypeId = "2";
                    alsEntity.SDate = syncdate;
                    alsEntity.STableId = item;
                    db.Insert(alsEntity);
                }
                db.Commit();
                return data;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }
        public IEnumerable<CdDeptEntity> GetDeptsNotRecord(string academicYearNo, string semester)
        {
            try
            {
                //var data = BaseRepository("CollegeMIS").FindList<CdDeptEntity>();

                var db = BaseRepository("CollegeMIS");
                db.BeginTrans();
                var data = db.FindList<CdDeptEntity>("select * from CdDept where DeptId not in (select STableId from ArrangeLessonSync where AcademicYearNo='" + academicYearNo + "' and Semester='" + semester + "' )");

                db.Commit();
                return data;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }

        public IEnumerable<CompanyEntity> GetSchools(string academicYearNo, string semester)
        {
            try
            {
                //var data = BaseRepository().FindList<CompanyEntity>();

                //根据学年学期判断排课同步数据表中是否有数据：若有，说明该学年学期同步过；若没有，修改基础表，false；
                var aa = this.BaseRepository("CollegeMIS").FindEntity<ArrangeLessonSyncEntity>(x => x.AcademicYearNo == academicYearNo && x.Semester == semester && x.STypeId == "1");
                if (aa == null)
                {
                    this.BaseRepository().ExecuteBySql("update LR_Base_Company set SyncFlag='false' ");
                }

                //数据
                var dbCollegeMIS = BaseRepository("CollegeMIS");
                dbCollegeMIS.BeginTrans();
                var data = BaseRepository().FindList<CompanyEntity>("select * from LR_Base_Company where F_CompanyId not in (select STableId from " + dbCollegeMIS.getDbConnection().Database + ".dbo.ArrangeLessonSync where AcademicYearNo='" + academicYearNo + "' and Semester='" + semester + "' )");
                DateTime syncdate = DateTime.Now;
                foreach (var item in data.Select(m => m.F_CompanyId))
                {
                    ArrangeLessonSyncEntity alsEntity = new ArrangeLessonSyncEntity();
                    alsEntity.Create();
                    alsEntity.AcademicYearNo = academicYearNo;
                    alsEntity.Semester = semester;
                    alsEntity.STypeId = "1";
                    alsEntity.SDate = syncdate;
                    alsEntity.STableId = item;
                    dbCollegeMIS.Insert(alsEntity);
                }
                dbCollegeMIS.Commit();
                return data;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }
        public IEnumerable<CompanyEntity> GetSchoolsNotRecord(string academicYearNo, string semester)
        {
            try
            {
                //var data = BaseRepository().FindList<CompanyEntity>();

                var dbCollegeMIS = BaseRepository("CollegeMIS");
                dbCollegeMIS.BeginTrans();
                var data = BaseRepository().FindList<CompanyEntity>("select * from LR_Base_Company where F_CompanyId not in (select STableId from " + dbCollegeMIS.getDbConnection().Database + ".dbo.ArrangeLessonSync where AcademicYearNo='" + academicYearNo + "' and Semester='" + semester + "' )");

                dbCollegeMIS.Commit();
                return data;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }

        public IEnumerable<CdLessonTypeEntity> GetLessonTypes()
        {
            try
            {
                var data = BaseRepository("CollegeMIS").FindList<CdLessonTypeEntity>();
                return data;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }
        public IEnumerable<ArrangeLessonTermEntity> GetPageListForTeacherWorkload(Pagination paginationobj, string queryJson)
        {
            try
            {
                var queryParam = queryJson.ToJObject();
                var strSql = new StringBuilder();
                strSql.Append("select count(ALTId)as lessoncount,EmpName,EmpNo,1 as coefficient from ArrangeLessonTerm ");
                strSql.Append(" WHERE 1=1 ");
                strSql.Append($"and AcademicYearNo='{ queryParam["AcademicYearNo"]}' and Semester='{queryParam["Semester"]}'  group by EmpName,EmpNo order by EmpNo ");
                return this.BaseRepository("CollegeMIS").FindList<ArrangeLessonTermEntity>(strSql.ToString());


            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 教学工作量
        /// </summary>
        /// <param name="paginationobj"></param>
        /// <param name="queryJson"></param>
        /// <returns></returns>
        public IEnumerable<ArrangeLessonTermEntity> GetPageListForTeacherWorkloadByEmpNo(Pagination paginationobj, string queryJson, string empNo)
        {
            try
            {
                var queryParam = queryJson.ToJObject();
                var strSql = new StringBuilder();
                strSql.Append("select count(t.ALTId) as lessoncount,t.LessonNo,t.LessonName,1 as coefficient from ArrangeLessonTerm t ");
                strSql.Append($" WHERE 1=1 and t.EmpNo='{empNo}' ");
                strSql.Append(" group by t.LessonNo,t.LessonName ");
                return this.BaseRepository("CollegeMIS").FindList<ArrangeLessonTermEntity>(strSql.ToString());

            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        /// <summary>
        /// 教学调度【教务】--课程下拉框信息
        /// </summary>
        /// <returns></returns>
        public IEnumerable<SelectModel> GetLessonDataInTerm(string queryJson)
        {
            try
            {
                return this.BaseRepository("CollegeMIS").FindList<SelectModel>("select distinct t.LessonNo as value,t.LessonName as text from  ArrangeLessonTerm t where 1=1 ");
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        /// <summary>
        /// 获取本学期开课计划
        /// </summary>
        /// <param name="academicYearNo"></param>
        /// <param name="semester"></param>
        /// <returns></returns>
        public IEnumerable<TimeTable> GetAllClassLesson(string academicYearNo, string semester)
        {
            try
            {
                return this.BaseRepository("CollegeMIS").FindList<TimeTable>(@"select b.F_SchoolId,b.DeptNo,b.MajorNo,b.AcademicYearNo as AcademicYear,b.Semester,b.LessonNo,
                b.LessonName, b.LessonTime, b.EmpNo, b.Empname EmpName, replace(b.TeachClassNo, b.LessonName, '') TeachClassNo, c.ClassroomName, b.ClassroomNo as ClassRoomNo, d.ClassName
                    from ArrangeLessonTerm b
                left
                    join ClassroomInfo c on c.ClassroomNo = b.classroomNo

                left
                    join ClassInfo d on replace(b.TeachClassNo, b.LessonName, '') = d.ClassNo
                where b.AcademicYearNo = '" + academicYearNo + "' and b.Semester = '" + semester + @"'
                and b.CheckMark = 1
                group by b.F_SchoolId, b.DeptNo, b.MajorNo, b.AcademicYearNo, b.Semester, b.LessonNo, b.LessonName, b.LessonTime, b.EmpNo, b.Empname, b.TeachClassNo, c.ClassroomName, b.ClassroomNo, d.ClassName
                ");
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 按条件重置基础数据同步状态
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public bool InitAsyncDataByCondition(ArrangeLessonTermEntity entity)
        {
            bool result = true;
            var db = BaseRepository("CollegeMIS").BeginTrans();
            try
            {
                foreach (var tablename in entity.SyncBasicTable.Split(','))
                {
                    if (tablename == "CdDept")
                    {
                        //清空同步记录表
                        db.ExecuteBySql("delete from ArrangeLessonSync where AcademicYearNo='" +
                                                   entity.AcademicYearNo + "' and Semester='" + entity.Semester +
                                                   "' and STypeId='2'");
                    }
                    if (tablename == "CdMajor")
                    {
                        //清空同步记录表
                        db.ExecuteBySql("delete from ArrangeLessonSync where AcademicYearNo='" +
                                                   entity.AcademicYearNo + "' and Semester='" + entity.Semester +
                                                   "' and STypeId='3'");
                    }
                    if (tablename == "ClassInfo")
                    {
                        //清空同步记录表
                        db.ExecuteBySql("delete from ArrangeLessonSync where AcademicYearNo='" +
                                                   entity.AcademicYearNo + "' and Semester='" + entity.Semester +
                                                   "' and STypeId='4'");
                    }
                    if (tablename == "ClassroomInfo")
                    {
                        //清空同步记录表
                        db.ExecuteBySql("delete from ArrangeLessonSync where AcademicYearNo='" +
                                                   entity.AcademicYearNo + "' and Semester='" + entity.Semester +
                                                   "' and STypeId='6'");
                    }
                    if (tablename == "LessonInfo")
                    {
                        //清空同步记录表
                        db.ExecuteBySql("delete from ArrangeLessonSync where AcademicYearNo='" +
                                                   entity.AcademicYearNo + "' and Semester='" + entity.Semester +
                                                   "' and STypeId='5'");
                    }
                    if (tablename == "EmpInfo")
                    {
                        //清空同步记录表
                        db.ExecuteBySql("delete from ArrangeLessonSync where AcademicYearNo='" +
                                                   entity.AcademicYearNo + "' and Semester='" + entity.Semester +
                                                   "' and STypeId='7'");
                    }
                    //重置基础数据表
                    db.ExecuteBySql("update " + tablename + " set SyncFlag=0");
                }
                db.Commit();
            }
            catch (Exception e)
            {
                result = false;
            }
            return result;
        }
    }


    #region MyRegion

    public class TimeTable
    {
        public DateTime LessonDate { get; set; }
        public string EnName { get; set; }
        public string AcademicYear { get; set; }
        public string LessonNo { get; set; }
        public string LessonName { get; set; }
        public string LessonTime { get; set; }
        public string EmpNo { get; set; }
        public string EmpName { get; set; }
        public string TeachClassNo { get; set; }
        public string ClassroomName { get; set; }
        public string Semester { get; set; }
        public string ClassRoomNo { get; set; }
        public string LessonSortNo { get; set; }
        public string ClassName { get; set; }

        public string OLPEId { get; set; }
        /// <summary>
        /// 排考结构Id
        /// </summary>
        public string StructureId { get; set; }
        public string LeaveType { get; set; }
        public string IsCheck { get; set; }
        /// <summary>
        /// 校区Id
        /// </summary>
        public string F_SchoolId { get; set; }
        public string DeptNo { get; set; }
        public string MajorNo { get; set; }

    }

    public class Common
    {
        /// <summary>
        /// 根据当前时间获取学年和学期
        /// </summary>
        /// <returns></returns>
        public static (string AcademicYearShort, string AcademicYearLong, string Semester) GetSemesterAndYear(string startDate = "")
        {
            string AcademicYearShort = "";//短格式学年度
            string AcademicYearLong = "";//长格式学年度
            string Semester = "";//学期
            DateTime dateParam = DateTime.Now;
            if (!string.IsNullOrEmpty(startDate))
            {
                dateParam = DateTime.Parse(startDate);
            }
            if (dateParam.Month >= 8)
            {
                AcademicYearShort = dateParam.Year.ToString().Substring(2, 2) + "-";
                AcademicYearShort += (dateParam.Year + 1).ToString().Substring(2, 2);
                AcademicYearLong = dateParam.Year.ToString() + "-";
                AcademicYearLong += (dateParam.Year + 1).ToString();
                Semester = "1";
            }
            else
            {
                if (dateParam.Month >= 2)//根据当前时间获取学年和学期,注意跨年份
                {
                    AcademicYearShort = (dateParam.Year - 1).ToString().Substring(2, 2) + "-";
                    AcademicYearShort += dateParam.Year.ToString().Substring(2, 2);
                    AcademicYearLong = (dateParam.Year - 1).ToString() + "-";
                    AcademicYearLong += dateParam.Year.ToString();
                    Semester = "2";
                }
                else
                {
                    AcademicYearShort = (dateParam.Year - 1).ToString().Substring(2, 2) + "-";
                    AcademicYearShort += dateParam.Year.ToString().Substring(2, 2);
                    AcademicYearLong = (dateParam.Year - 1).ToString() + "-";
                    AcademicYearLong += dateParam.Year.ToString();
                    Semester = "1";
                }
            }
            return (AcademicYearShort, AcademicYearLong, Semester);
        }
        /// <summary>
        /// 计算周一的时间
        /// </summary>
        /// <param name="someDate"></param>
        /// <returns></returns>
        public static DateTime CalculateFirstDateOfWeek(DateTime someDate)
        {
            int i = someDate.DayOfWeek - DayOfWeek.Monday;
            if (i == -1) i = 6;// i值 > = 0 ，因为枚举原因，Sunday排在最前，此时Sunday-Monday=-1，必须+7=6。
            TimeSpan ts = new TimeSpan(i, 0, 0, 0);
            return someDate.Subtract(ts);
        }
        /// <summary>
        /// 计算周日的时间
        /// </summary>
        /// <param name="someDate"></param>
        /// <returns></returns>
        public static DateTime CalculateLastDateOfWeek(DateTime someDate)
        {
            int i = someDate.DayOfWeek - DayOfWeek.Sunday;
            if (i != 0) i = 7 - i;// 因为枚举原因，Sunday排在最前，相减间隔要被7减。
            TimeSpan ts = new TimeSpan(i, 0, 0, 0);
            return someDate.Add(ts);
        }
    }

    #region 当期学期排课数据同步
    public class Paike
    {
        public string id { get; set; }
        /// <summary>
        /// 20180101
        /// </summary>
        public string clazzId { get; set; }
        /// <summary>
        /// 18学前教育01班
        /// </summary>
        public string clazzName { get; set; }
        /// <summary>
        /// XCMY0016
        /// </summary>
        public string teacherId { get; set; }
        /// <summary>
        /// 薛雅馨
        /// </summary>
        public string teacherName { get; set; }
        /// <summary>
        /// 0103
        /// </summary>
        public string curriculunId { get; set; }
        /// <summary>
        /// 大学体育（学前系）(合)
        /// </summary>
        public string curriculunName { get; set; }

        public string curriculuntype { get; set; }
        /// <summary>
        /// 1
        /// </summary>
        public string section { get; set; }
        /// <summary>
        /// 1
        /// </summary>
        public string week { get; set; }
        /// <summary>
        /// 08:00-09:00
        /// </summary>
        public string curriculunTime { get; set; }
        /// <summary>
        /// 1
        /// </summary>
        public string kebiaoType { get; set; }
        /// <summary>
        /// 1102
        /// </summary>
        public string classRoomId { get; set; }
        /// <summary>
        /// 1102教室
        /// </summary>
        public string classRoomName { get; set; }
        /// <summary>
        /// 1
        /// </summary>
        public string rankSchedule { get; set; }
        /// <summary>
        /// 0
        /// </summary>
        public string periodTime { get; set; }
        /// <summary>
        /// [{"date":"2019-03-04 08:00-09:00","endTime":"2019-03-04 09:00:00","startTime":"2019-03-04 08:00:00"},{"date":"2019-03-18 08:00-09:00","endTime":"2019-03-18 09:00:00","startTime":"2019-03-18 08:00:00"},{"date":"2019-04-01 08:00-09:00","endTime":"2019-04-01 09:00:00","startTime":"2019-04-01 08:00:00"},{"date":"2019-04-15 08:00-09:00","endTime":"2019-04-15 09:00:00","startTime":"2019-04-15 08:00:00"},{"date":"2019-04-29 08:00-09:00","endTime":"2019-04-29 09:00:00","startTime":"2019-04-29 08:00:00"},{"date":"2019-05-13 08:00-09:00","endTime":"2019-05-13 09:00:00","startTime":"2019-05-13 08:00:00"},{"date":"2019-05-27 08:00-09:00","endTime":"2019-05-27 09:00:00","startTime":"2019-05-27 08:00:00"},{"date":"2019-06-10 08:00-09:00","endTime":"2019-06-10 09:00:00","startTime":"2019-06-10 08:00:00"},{"date":"2019-06-24 08:00-09:00","endTime":"2019-06-24 09:00:00","startTime":"2019-06-24 08:00:00"},{"date":"2019-07-08 08:00-09:00","endTime":"2019-07-08 09:00:00","startTime":"2019-07-08 08:00:00"}]
        /// </summary>
        public string timeText { get; set; }
        /// <summary>
        /// 2
        /// </summary>
        public string semester { get; set; }
        /// <summary>
        /// Flag
        /// </summary>
        public bool flag { get; set; }
        public string year { get; set; }
        public string number { get; set; }
        public string curriculunNumber { get; set; }
        public string teacherNumber { get; set; }
        public string classRoomNumber { get; set; }
    }

    public class StuScore
    {
        public string id { get; set; }
        public string examname { get; set; }
        public string stuno { get; set; }
        public string stuname { get; set; }
        public string classno { get; set; }
        public string classname { get; set; }
        public string teachclassno { get; set; }
        public string termendscore { get; set; }
        public string examtime { get; set; }
        public string lessonno { get; set; }
        public string lessonname { get; set; }
        public string scoolYear { get; set; }
        public string term { get; set; }
    }

    public class Major
    {
        /// <summary>
        /// 01
        /// </summary>
        public string id { get; set; }
        /// <summary>
        /// 学前教育
        /// </summary>
        public string majorName { get; set; }
        /// <summary>
        /// 01
        /// </summary>
        public string majorNumber { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public string bz { get; set; }
    }

    public class semester
    {
        public DateTime? starttime { get; set; }
        public DateTime? endtime { get; set; }
        public string zhouci { get; set; }
        public string shangxia { get; set; }
    }

    public class List
    {
        public StuScore stuscore { get; set; }

        /// <summary>
        /// Paike
        /// </summary>
        public Paike paike { get; set; }
        /// <summary>
        /// 2019-03-04 08:00-09:00
        /// </summary>
        public string times { get; set; }
        /// <summary>
        /// Major
        /// </summary>
        public Major major { get; set; }
        /// <summary>
        /// 18-19
        /// </summary>
        public string schoolYear { get; set; }
        /// <summary>
        /// 学期类
        /// </summary>
        public semester semester { get; set; }
        /// <summary>
        /// 第几级
        /// </summary>
        public string grade { get; set; }
        /// <summary>
        /// 专业编号
        /// </summary>
        public string majorNumber { get; set; }
        /// <summary>
        /// 课程名称
        /// </summary>
        public string curriculumName { get; set; }
        /// <summary>
        /// 课程编号
        /// </summary>
        public string curriculumNumber { get; set; }
        /// <summary>
        /// 选修必修
        /// </summary>
        public string isElective { get; set; }
        /// <summary>
        /// 周学时
        /// </summary>
        public string classhour { get; set; }
        /// <summary>
        /// 教师编号
        /// </summary>
        public string teacherId { get; set; }
        /// <summary>
        /// 教师姓名
        /// </summary>
        public string teacherName { get; set; }
        /// <summary>
        /// 学校主键
        /// </summary>
        public string schoolId { get; set; }

    }

    public class Entity
    {
        /// <summary>
        /// true
        /// </summary>
        public string opflag { get; set; }
        /// <summary>
        /// 1000
        /// </summary>
        public string opCode { get; set; }
        /// <summary>
        /// OK!
        /// </summary>
        public string message { get; set; }
        /// <summary>
        /// List
        /// </summary>
        public List<List> list { get; set; }

        public List<StuScore> stuScoreList { get; set; }
    }

    public class Root
    {
        /// <summary>
        /// 操作成功
        /// </summary>
        public string message { get; set; }
        /// <summary>
        /// Success
        /// </summary>
        public bool success { get; set; }
        /// <summary>
        /// Entity
        /// </summary>
        public Entity entity { get; set; }
    }


    #endregion

    #region 按条件同步排课数据

    public class RootByCondition
    {
        /// <summary>
        /// 操作成功
        /// </summary>
        public string message { get; set; }
        /// <summary>
        /// Success
        /// </summary>
        public bool success { get; set; }
        /// <summary>
        /// Entity
        /// </summary>
        public EntityByCondition entity { get; set; }
    }
    public class EntityByCondition
    {
        /// <summary>
        /// true
        /// </summary>
        public string opflag { get; set; }
        /// <summary>
        /// 1000
        /// </summary>
        public string opCode { get; set; }
        /// <summary>
        /// OK!
        /// </summary>
        public string message { get; set; }
        /// <summary>
        /// List
        /// </summary>
        public List<ListByCondition> list { get; set; }
    }
    public class ListByCondition
    {
        public string year { get; set; }
        public string number { get; set; }
        public string curriculunNumber { get; set; }
        public string curriculunName { get; set; }

        /// <summary>
        /// Paike
        /// </summary>
        public PaikeByCondition paike { get; set; }
        /// <summary>
        /// "2019-03-12,2019-03-26,2019-04-09,2019-04-23,2019-05-07,2019-05-21,2019-06-04,2019-06-18,2019-07-02,2019-07-16,2019-07-30,"
        /// </summary>
        public string timeText { get; set; }
        /// <summary>
        /// Major
        /// </summary>
        public MajorByCondition major { get; set; }

        public string teacherNumber { get; set; }
        public string teacherName { get; set; }
        public string curriculunSid { get; set; }
        public string classRoomSid { get; set; }
        public string schoolSid { get; set; }
        public object week { get; set; }
        public string section { get; set; }
        public string clazzSid { get; set; }
    }
    public class PaikeByCondition
    {
        public string id { get; set; }
        /// <summary>
        /// 班级Id
        /// </summary>
        public string clazzId { get; set; }
        /// <summary>
        /// 班级名称
        /// </summary>
        public string clazzName { get; set; }
        /// <summary>
        /// 班级编号
        /// </summary>
        public string clazzSid { get; set; }
        /// <summary>
        /// 年级
        /// </summary>
        public string grade { get; set; }
        /// <summary>
        /// 教师Id
        /// </summary>
        public string teacherId { get; set; }
        /// <summary>
        /// 教师名称
        /// </summary>
        public string teacherName { get; set; }
        /// <summary>
        /// 教师编号
        /// </summary>
        public string teacherSid { get; set; }
        /// <summary>
        /// 课程Id
        /// </summary>
        public string curriculunId { get; set; }
        /// <summary>
        /// 课程名称
        /// </summary>
        public string curriculunName { get; set; }
        /// <summary>
        /// 课程编号
        /// </summary>
        public string curriculunSid { get; set; }
        /// <summary>
        /// 第几节次
        /// </summary>
        public string section { get; set; }
        /// <summary>
        /// 星期几
        /// </summary>
        public string week { get; set; }
        /// <summary>
        /// 课表类型
        /// </summary>
        public string kebiaoType { get; set; }
        /// 教室Id
        /// </summary>
        public string classRoomId { get; set; }
        /// <summary>
        /// 教室名称
        /// </summary>
        public string classRoomName { get; set; }
        /// <summary>
        /// 教室编号
        /// </summary>
        public string classRoomSid { get; set; }
        /// <summary>
        /// 排课安排
        /// </summary>
        public string rankSchedule { get; set; }
        /// <summary>
        /// "2019-03-12,2019-03-26,2019-04-09,2019-04-23,2019-05-07,2019-05-21,2019-06-04,2019-06-18,2019-07-02,2019-07-16,2019-07-30,"
        /// </summary>
        public string timeText { get; set; }
        /// <summary>
        /// 学年
        /// </summary>
        public string semester { get; set; }
        /// <summary>
        /// Flag
        /// </summary>
        public bool flag { get; set; }
    }
    public class MajorByCondition
    {
        /// <summary>
        /// 专业Id
        /// </summary>
        public string id { get; set; }
        /// <summary>
        /// 专业名称
        /// </summary>
        public string name { get; set; }
        /// <summary>
        /// 专业编号
        /// </summary>
        public string number { get; set; }
        /// <summary>
        /// 系
        /// </summary>
        public DepartmentByCondition department { get; set; }
        /// <summary>
        /// 学年学期
        /// </summary>
        public SemesterByCondition semester { get; set; }
        /// <summary>
        /// 学校
        /// </summary>
        public SchoolByCondition school { get; set; }
        public string sid { get; set; }
        public string qsid { get; set; }
    }
    public class DepartmentByCondition
    {
        /// <summary>
        /// 系Id
        /// </summary>
        public string id { get; set; }
        /// <summary>
        /// 系名称
        /// </summary>
        public string name { get; set; }
        /// <summary>
        /// 系编号【开课计划接口】
        /// </summary>
        public string number { get; set; }
    }
    public class SemesterByCondition
    {
        public string id { get; set; }
        /// <summary>
        /// 学年
        /// </summary>
        public string year { get; set; }
        /// <summary>
        /// 学期
        /// </summary>
        public string number { get; set; }

        /// <summary>
        /// 开始时间【开课计划接口】
        /// </summary>
        public DateTime starTime { get; set; }
        /// <summary>
        /// 结束时间【开课计划接口】
        /// </summary>
        public DateTime endTime { get; set; }
        /// <summary>
        /// 开始周次【开课计划接口】
        /// </summary>
        public int yesNo { get; set; }
        /// <summary>
        /// 结束周次【开课计划接口】
        /// </summary>
        public int week { get; set; }
    }
    public class SchoolByCondition
    {
        /// <summary>
        /// 学校Id
        /// </summary>
        public string sid { get; set; }
        /// <summary>
        /// 学校名称
        /// </summary>
        public string name { get; set; }
    }

    public class RootOfPlanByCondition
    {
        /// <summary>
        /// 操作成功
        /// </summary>
        public string message { get; set; }
        /// <summary>
        /// Success
        /// </summary>
        public bool success { get; set; }
        /// <summary>
        /// Entity
        /// </summary>
        public EntityOfPlanByCondition entity { get; set; }
    }
    public class EntityOfPlanByCondition
    {
        /// <summary>
        /// true
        /// </summary>
        public string opflag { get; set; }
        /// <summary>
        /// 1000
        /// </summary>
        public string opCode { get; set; }
        /// <summary>
        /// OK!
        /// </summary>
        public string message { get; set; }
        /// <summary>
        /// List
        /// </summary>
        public List<ListOfPlanByCondition> list { get; set; }
    }
    public class ListOfPlanByCondition
    {
        public SchoolByCondition school { get; set; }
        public SemesterByCondition semester { get; set; }
        public DepartmentByCondition department { get; set; }
        public MajorByCondition major { get; set; }
        /// <summary>
        /// 开课计划
        /// </summary>
        public CourseOfPlanByCondition course { get; set; }
        public int? classhour { get; set; }
        public int? credit { get; set; }
        public string grade { get; set; }

    }
    public class CourseOfPlanByCondition
    {
        /// <summary>
        /// 开课计划Id
        /// </summary>
        public string id { get; set; }
        /// <summary>
        /// 课程编号
        /// </summary>
        public string number { get; set; }
        /// <summary>
        /// 课程信息
        /// </summary>
        public CourseInfoOfPlanByCondition course { get; set; }
        /// <summary>
        /// 课程名称
        /// </summary>
        public string coursename { get; set; }
    }
    public class CourseInfoOfPlanByCondition
    {
        /// <summary>
        /// 课程Id
        /// </summary>
        public string id { get; set; }
        /// <summary>
        /// 课程名称
        /// </summary>
        public string name { get; set; }

        public string number { get; set; }

    }


    #endregion

    public class paikeList
    {
        public string week { get; set; }
        public string section { get; set; }
        public string timetext { get; set; }
        public string classname { get; set; }
        public string classnumber { get; set; }
        public string roomname { get; set; }
        public string ClassroomNo { get; set; }
        public string teachername { get; set; }
        public string teacherNumber { get; set; }
        public string curriculunName { get; set; }
        public string curriculunNumber { get; set; }
        public string year { get; set; }
        public string semester { get; set; }
        public string schoolno { get; set; }
    }
    #endregion
}