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 { });
                //dp.Add("startTime", queryParam["StartTime"].ToDate(), DbType.DateTime);
                var strSql = new StringBuilder();
                strSql.Append("SELECT ");
                strSql.Append(fieldSql);
                strSql.Append(" FROM ArrangeLessonTerm t ");
                return this.BaseRepository("CollegeMIS").FindList<ArrangeLessonTermEntity>(strSql.ToString());
            }
            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;
        }


        private string stringSchoolId;
        private string stringAcademicYear;
        private string stringSemester;
        /// <summary>
        /// 按条件同步排课数据
        /// </summary>
        /// <returns></returns>
        public async Task<bool> AsyncArrangeLessonDataByCondition(ArrangeLessonTermEntity entity)
        {
            bool result = false;
            try
            {
                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("ArrangeLessonAPI"), httpContent).Result.Content.ReadAsStringAsync();

                if (!string.IsNullOrEmpty(apiData))
                {
                    var data = JsonConvert.DeserializeObject<RootByCondition>(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();
                        var classroomData = (await BaseRepository("CollegeMIS").FindListAsync<ClassroomInfoEntity>()).ToList();
                        foreach (var item in dataList)
                        {
                            var classinfo = classData.FirstOrDefault(m => m.ClassId == item.clazzSid);

                            var timesArr = item.timeText.Substring(0, item.timeText.Length - 1).Split(',');
                            foreach (var timesItem in timesArr)
                            {
                                if (item.section.Contains(","))
                                {
                                    foreach (var sec in item.section.Split(','))
                                    {
                                        var insertData = new ArrangeLessonTermEntity
                                        {
                                            ALTId = Guid.NewGuid().ToString(),
                                            LessonDate = DateTime.Parse(timesItem),
                                            AcademicYearNo = item.year,
                                            Semester = item.number,
                                            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.LessonId == item.curriculunSid)?.LessonSortNo,
                                            ClassroomNo = classroomData.FirstOrDefault(m => m.ClassroomId == item.classRoomSid)?.ClassroomNo,
                                            LessonTime = item.week + sec,
                                            CheckMark = "1",
                                            F_SchoolId = item.schoolSid
                                        };
                                        stringSchoolId = insertData.F_SchoolId;
                                        stringAcademicYear = insertData.AcademicYearNo;
                                        stringSemester = 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);
                                        }
                                        //if (!oldArrangeLessonTermList.Any(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)
                                        //    && !insertDataList.Any(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))
                                        //{
                                        //    insertDataList.Add(insertData);
                                        //}
                                    }
                                }
                                else
                                {
                                    var insertData = new ArrangeLessonTermEntity
                                    {
                                        ALTId = Guid.NewGuid().ToString(),
                                        LessonDate = DateTime.Parse(timesItem),
                                        AcademicYearNo = item.year,
                                        Semester = item.number,
                                        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.LessonId == item.curriculunSid)?.LessonSortNo,
                                        ClassroomNo = classroomData.FirstOrDefault(m => m.ClassroomId == item.classRoomSid)?.ClassroomNo,
                                        LessonTime = item.week + item.section,
                                        CheckMark = "1",
                                        F_SchoolId = item.schoolSid
                                    };
                                    stringSchoolId = insertData.F_SchoolId;
                                    stringAcademicYear = insertData.AcademicYearNo;
                                    stringSemester = 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 F_SchoolId,AcademicYearNo,Semester,DeptNo,majorno,lessonno,replace(teachclassno,lessonname,'') as teachclassno,empno from [dbo].[ArrangeLessonTerm] 
where (AcademicYearNo = '" + stringAcademicYear + "') and semester='" + stringSemester + "' and F_SchoolId = '" + stringSchoolId + @"'
group by F_SchoolId,AcademicYearNo,Semester,DeptNo,majorno,lessonno,replace(teachclassno,lessonname,'') ,empno ")).ToList();
                        var TeachClassData = (await BaseRepository("CollegeMIS").FindListAsync<TeachClassEntity>(@"SELECT   *
FROM      TeachClass
WHERE   (AcademicYearNo = '" + stringAcademicYear + "') and semester='" + stringSemester + "' and F_SchoolId='" + stringSchoolId + "'  ")).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 ="1",
                                    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 AsyncOpenLessonPlanDataByCondition(entity);
                        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> AsyncOpenLessonPlanDataByCondition(ArrangeLessonTermEntity entity)
        {
            bool result = false;
            try
            {
                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("OpenLessonPlanAPI"), httpContent).Result.Content.ReadAsStringAsync();

                if (!string.IsNullOrEmpty(apiData))
                {
                    var data = JsonConvert.DeserializeObject<RootOfPlanByCondition>(apiData);
                    var dataList = data.entity.list;
                    var openLessonPlanData = await BaseRepository("CollegeMIS").FindListAsync<OpenLessonPlanEntity>();
                    if (dataList.Any())
                    {
                        var insertDataList = new List<OpenLessonPlanEntity>();
                        var majorData = (await BaseRepository("CollegeMIS").FindListAsync<CdMajorEntity>()).ToList();
                        var lessonData = (await BaseRepository("CollegeMIS").FindListAsync<LessonInfoEntity>()).ToList();
                        var now = DateTime.Now;
                        foreach (var item in dataList)
                        {
                            var insertData = new OpenLessonPlanEntity()
                            {
                                MakeDate = now,
                                AcademicYearNo = item.semester.year,
                                Semester = item.semester.number,
                                DeptNo = majorData.FirstOrDefault(m => m.ID == item.major.sid)?.DeptNo,
                                MajorNo = item.major.number,
                                LessonNo = item.course.course.number,
                                LessonName = item.course.course.name,
                                PartCode = "",
                                Grade = item.grade,
                                LessonSortNo = lessonData.FirstOrDefault(m => m.LessonNo == item.course.course.number)?.LessonSortNo,
                                LessonSortDetailNo = lessonData.FirstOrDefault(m => m.LessonNo == item.course.course.number)?.LessonSortDetailNo,
                                StartWeek = item.semester.yesNo,
                                EndWeek = item.semester.week,
                                CheckStyleNo = "1",
                                ScoreRecordStyleNo = "1",
                                TeachDeptNo = majorData.FirstOrDefault(m => m.ID == item.major.sid)?.DeptNo,
                                StudyScore = 0,
                                AmendDate = now,
                                ClassroomType = 1,
                                ClassroomPracticeType = 99,
                                CheckMarkDept = "1",
                                CheckMark = "1",
                                TestMark = 0,
                                F_SchoolId = item.school.sid
                            };
                            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 = '" + stringAcademicYear + "') and semester='" + stringSemester + "' and F_SchoolId='" + stringSchoolId + "'  ")).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);
                        }
                        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> AsyncModifyArrangeLessonDataByCondition(ArrangeLessonTermEntity entity)
        {
            bool result = false;
            try
            {
                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)
                    {
                        var executeResult = await BaseRepository("CollegeMIS").ExecuteAsyncBySql(
                            $"delete from ArrangeLessonTerm where F_SchoolId='{entity.F_SchoolId}' and AcademicYearNo='{entity.AcademicYearNo}' and Semester='{entity.Semester}' ");
                        await BaseRepository("CollegeMIS").ExecuteAsyncBySql(
                              $"delete from TeachClass where F_SchoolId='{entity.F_SchoolId}' and AcademicYearNo='{entity.AcademicYearNo}' and Semester='{entity.Semester}' ");
                        await BaseRepository("CollegeMIS").ExecuteAsyncBySql(
                              $"delete from OpenLessonPlan where F_SchoolId='{entity.F_SchoolId}' and AcademicYearNo='{entity.AcademicYearNo}' and Semester='{entity.Semester}' ");
                        await BaseRepository("CollegeMIS").ExecuteAsyncBySql(
                            $"delete from StuSelectLessonList where F_SchoolId='{entity.F_SchoolId}' and AcademicYearNo='{entity.AcademicYearNo}' and Semester='{entity.Semester}' ");
                        if (executeResult > 0)
                        {
                            result = true;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                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


    #endregion
}