DigitalScholl/Learun.Framework.Ultimate V7/Learun.Framework.Module/Learun.Application.Module/Learun.Application.TwoDevelopment/EducationalAdministration/StuInfoBasic/StuInfoBasicService.cs

using Dapper;
using Learun.DataBase.Repository;
using Learun.Util;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using Learun.Application.Base.AuthorizeModule;
using Learun.Application.Organization;
using System.Reflection;
using Learun.Application.Base.SystemModule;
using Learun.Application.TwoDevelopment.LogisticsManagement;
using Learun.Cache.Base;
using Learun.Cache.Factory;
using System.IO;
using System.Security.Policy;
using System.Data.SqlClient;

namespace Learun.Application.TwoDevelopment.EducationalAdministration
{
    /// <summary>
    /// 版 本 Learun-ADMS-Ultimate V7.0.0 数字化智慧校园 
    /// Copyright (c) 2013-2018 北京泉江科技有限公司 
    /// 创 建：超级管理员
    /// 日 期：2019-02-21 16:53
    /// 描 述：学生学籍
    /// </summary>
    public class StuInfoBasicService : RepositoryFactory
    {
        #region  获取数据

        /// <summary>
        /// 获取页面显示列表数据
        /// <summary>
        /// <param name="queryJson">查询参数</param>
        /// <returns></returns>
        public IEnumerable<StuInfoBasicEntity> GetPageList(Pagination pagination, string queryJson)
        {
            try
            {
                var strSql = new StringBuilder();
                strSql.Append("SELECT t.* ");
                strSql.Append("  FROM StuInfoBasic t ");
                strSql.Append("  WHERE 1=1 ");
                var queryParam = queryJson.ToJObject();
                // 虚拟参数
                var dp = new DynamicParameters(new { });
                if (!queryParam["StuNo"].IsEmpty())
                {
                    dp.Add("StuNo", "%" + queryParam["StuNo"].ToString() + "%", DbType.String);
                    strSql.Append(" AND t.StuNo Like @StuNo ");
                }
                if (!queryParam["StuName"].IsEmpty())
                {
                    dp.Add("StuName", "%" + queryParam["StuName"].ToString() + "%", DbType.String);
                    strSql.Append(" AND t.StuName Like @StuName ");
                }
                if (!queryParam["DeptNo"].IsEmpty())
                {
                    dp.Add("DeptNo", "" + queryParam["DeptNo"].ToString() + "", DbType.String);
                    strSql.Append(" AND t.DeptNo=@DeptNo ");
                }
                if (!queryParam["MajorNo"].IsEmpty())
                {
                    dp.Add("MajorNo", "" + queryParam["MajorNo"].ToString() + "", DbType.String);
                    strSql.Append(" AND t.MajorNo=@MajorNo ");
                }
                if (!queryParam["ClassNo"].IsEmpty())
                {
                    dp.Add("ClassNo", "" + queryParam["ClassNo"].ToString() + "", DbType.String);
                    strSql.Append(" AND t.ClassNo=@ClassNo ");
                }
                if (!queryParam["Grade"].IsEmpty())
                {
                    dp.Add("Grade", "" + queryParam["Grade"].ToString() + "", DbType.String);
                    strSql.Append(" AND t.Grade=@Grade ");
                }
                if (!queryParam["GenderNo"].IsEmpty())
                {
                    dp.Add("GenderNo", "" + queryParam["GenderNo"].ToString() + "", DbType.String);
                    strSql.Append(" AND t.GenderNo=@GenderNo ");
                }
                if (!queryParam["IdentityCardNo"].IsEmpty())
                {
                    dp.Add("IdentityCardNo", "%" + queryParam["IdentityCardNo"].ToString() + "%", DbType.String);
                    strSql.Append(" AND t.IdentityCardNo Like @IdentityCardNo ");
                }
                if (!queryParam["NationalityNo"].IsEmpty())
                {
                    dp.Add("NationalityNo", "" + queryParam["NationalityNo"].ToString() + "", DbType.String);
                    strSql.Append(" AND t.NationalityNo = @NationalityNo ");
                }
                if (!queryParam["FinishSchoolMark"].IsEmpty())
                {
                    dp.Add("FinishSchoolMark", "" + queryParam["FinishSchoolMark"].ToString() + "", DbType.String);
                    if (queryParam["FinishSchoolMark"].ToString() == "0")
                    {
                        strSql.Append(" AND (t.FinishSchoolMark is null or t.FinishSchoolMark='0') ");
                    }
                    else
                    {
                        strSql.Append(" AND t.FinishSchoolMark=@FinishSchoolMark ");
                    }
                }
                if (!queryParam["Remark"].IsEmpty())
                {
                    dp.Add("Remark", "%" + queryParam["Remark"].ToString() + "%", DbType.String);
                    strSql.Append(" AND t.Remark Like @Remark ");
                }

                if (!queryParam["CheckMark"].IsEmpty())
                {
                    dp.Add("CheckMark", "" + queryParam["CheckMark"].ToString() + "", DbType.String);
                    if (queryParam["CheckMark"].ToString() == "1")
                    {
                        strSql.Append(" AND t.CheckMark=@CheckMark ");
                    }
                    else
                    {
                        strSql.Append(" AND (t.CheckMark is null or t.CheckMark='0') ");
                    }
                }
                if (!queryParam["StuCode"].IsEmpty())
                {
                    dp.Add("StuCode", "%" + queryParam["StuCode"].ToString() + "%", DbType.String);
                    strSql.Append(" AND t.StuCode Like @StuCode ");
                }
                if (!queryParam["PartyFaceNo"].IsEmpty())
                {
                    dp.Add("PartyFaceNo", "" + queryParam["PartyFaceNo"].ToString() + "", DbType.String);
                    strSql.Append(" AND t.PartyFaceNo = @PartyFaceNo ");
                }
                if (!queryParam["EduSystem"].IsEmpty())
                {
                    dp.Add("EduSystem", "" + queryParam["EduSystem"].ToString() + "", DbType.String);
                    strSql.Append(" AND t.EduSystem = @EduSystem ");
                }
                if (!queryParam["HealthStatus"].IsEmpty())
                {
                    dp.Add("HealthStatus", "" + queryParam["HealthStatus"].ToString() + "", DbType.String);
                    strSql.Append(" AND t.HealthStatus = @HealthStatus ");
                }
                if (!queryParam["StudyModality"].IsEmpty())
                {
                    dp.Add("StudyModality", "" + queryParam["StudyModality"].ToString() + "", DbType.String);
                    strSql.Append(" AND t.StudyModality = @StudyModality ");
                }

                if (!queryParam["Photo"].IsEmpty())
                {
                    dp.Add("Photo", "" + queryParam["Photo"].ToString() + "", DbType.String);
                    if (queryParam["Photo"].ToString() == "1")
                    {
                        strSql.Append(" AND t.Photo is not null ");
                    }
                    else
                    {
                        strSql.Append(" AND t.Photo is null  ");
                    }
                }

                #region 学籍异动专项查询条件 与其他无关
                if (!queryParam["Mustsql"].IsEmpty())
                {
                    strSql.Append(" AND stuno not in(select stuno from StuTransferInfo where F_EnabledMark =0) ");
                }
                //查询去除 退学,休学,开除,死亡,失踪,注销,自动退学
                if (!queryParam["RestAgainSql"].IsEmpty())
                {
                    strSql.Append("  AND stuno not in(select stuno from StuTransferInfo where anomaloustype = '02,05,06,10,11,12,13,14' and F_EnabledMark =0 )");
                }
                if (!queryParam["RolloffSql"].IsEmpty())//转出
                {
                    strSql.Append(" AND stuno not in(select stuno from StuTransferInfo where anomaloustype = '02')");
                }
                #endregion
                return this.BaseRepository("CollegeMIS").FindList<StuInfoBasicEntity>(strSql.ToString(), dp, pagination);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        internal List<string> GetSaveClassStudents(string account)
        {
            try
            {
                var classNO = this.BaseRepository("CollegeMIS").FindEntity<StuInfoBasicEntity>(a => a.StuNo == account).ClassNo;
                return this.BaseRepository("CollegeMIS").FindList<StuInfoBasicEntity>(a => a.ClassNo == classNO).Select(a => a.StuNo).ToList();

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

        internal bool GetAny()
        {
            try
            {
                return this.BaseRepository("CollegeMIS").FindList<StuInfoBasicEntity>().ToList().Count > 0 ? true : false;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        internal StuInfoBasicEntity GetStuInfoBasicEntityByStuNo(string enCode)
        {
            try
            {
                var data = this.BaseRepository("CollegeMIS").FindEntity<StuInfoBasicEntity>(a => a.StuNo == enCode);
                if (data != null && (data.Photo != null && data.Photo != ""))
                {
                    var url = this.BaseRepository().FindEntity<AnnexesFileEntity>(a => a.F_FolderId == data.Photo)?.F_FilePath;
                    if (!string.IsNullOrEmpty(url))
                    {
                        url = "/" + url.Substring(url.IndexOf("Resource"));
                        data.Photo = url;
                    }
                }
                return data;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        public StuInfoBasicEntity GetStuInfoBasicEntityByStuName(string name)
        {
            try
            {
                return this.BaseRepository("CollegeMIS").FindEntity<StuInfoBasicEntity>(a => a.StuName == name);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        public StuInfoBasicEntity GetStuInfoBasicEntityByStuNoOrStuName(string stuno, string stuname)
        {
            try
            {
                string sql = "select * from StuInfoBasic where 1=1";
                if (!string.IsNullOrEmpty(stuno))
                {
                    sql += $" and stuno='{stuno}'";
                }
                if (!string.IsNullOrEmpty(stuname))
                {
                    sql += $" and stuname='{stuname}'";
                }
                return this.BaseRepository("CollegeMIS").FindList<StuInfoBasicEntity>(sql).FirstOrDefault();
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 获取StuInfoBasic表实体数据
        /// <param name="keyValue">主键</param>
        /// <summary>
        /// <returns></returns>
        public StuInfoBasicEntity GetStuInfoBasicEntity(string keyValue)
        {
            try
            {
                return this.BaseRepository("CollegeMIS").FindEntity<StuInfoBasicEntity>(keyValue);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 获取准许毕业的学生的专业
        /// <summary>
        /// <returns></returns>
        public List<CdMajorEntity> GetMajorInfoWithGraduation()
        {
            try
            {
                var stuInfo = this.BaseRepository("CollegeMIS")
                    .FindList<StuInfoBasicEntity>(a => a.FinishSchoolMark == "1").ToList();
                var majorNoList = stuInfo.GroupBy(a => a.MajorNo).Select(a => a.Key).ToList();

                var majorList = this.BaseRepository("CollegeMIS")
                    .FindList<CdMajorEntity>(a => majorNoList.Contains(a.MajorNo)).ToList();
                return majorList;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        /// <summary>
        /// 获取StuInfoBasic表实体数据
        /// <param name="keyValue">主键</param>
        /// <summary>
        /// <returns></returns>
        public void CreateGraduateNoByMajor(string CityCode, string SchoolCode, string MajorList)
        {
            try
            {
                var year = DateTime.Now.Year.ToString().Substring(2, 2);
                var firstStr = year + CityCode + SchoolCode;
                //获取最大的序号
                var DiplomaNoList = this.BaseRepository("CollegeMIS")
                    .FindList<StuInfoBasicEntity>(a => a.DiplomaNo.Contains(firstStr)).Select(a => a.DiplomaNo.Substring(a.DiplomaNo.Length - 4, 4).ToInt()).ToList();
                var orderNo = 1;
                if (DiplomaNoList.Count() > 0)
                {

                    var MaxDiplomaNo = DiplomaNoList.Max(a => a);
                    orderNo = MaxDiplomaNo + 1;
                }


                var ListMajorNo = MajorList.Split(',').ToList();
                foreach (var MajorNo in ListMajorNo)
                {
                    var stuList = this.BaseRepository("CollegeMIS")
                        .FindList<StuInfoBasicEntity>(a => a.MajorNo == MajorNo)
                        .Where(a => a.DiplomaNo == null || a.DiplomaNo == "");
                    if (stuList.Count() > 0)
                    {
                        foreach (var stuInfo in stuList)
                        {
                            stuInfo.DiplomaNo = firstStr + orderNo.ToString().PadLeft(4, '0');
                            this.BaseRepository("CollegeMIS").Update(stuInfo);
                            orderNo++;
                        }
                    }
                }

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

        /// <summary>
        /// 获取StuInfoBasic表实体数据
        /// <param name="keyValue">主键</param>
        /// <summary>
        /// <returns></returns>
        public void DoCreateGraduateNo()
        {
            var db = this.BaseRepository("CollegeMIS").BeginTrans();
            try
            {
                //年份
                var year = DateTime.Now.Year.ToString().Substring(2, 2);
                //学校编码十位
                var schoolCode = "3642000004";
                //顺序号四位
                var numberCode = 1;

                //获取最大的序号
                var DiplomaNoList = this.BaseRepository("CollegeMIS").FindList<StuInfoBasicEntity>(x => x.DiplomaNo.Contains(year + schoolCode)).Select(x => x.DiplomaNo).ToList();
                if (DiplomaNoList.Any())
                {
                    numberCode = DiplomaNoList.Max(x => x).Substring(12, 4).ToInt() + 1;
                }

                //获取所有要毕业的学生按年级查询出来，再按学号进行由小到大排序，
                var stuList = this.BaseRepository("CollegeMIS").FindList<StuInfoBasicEntity>(x => (x.FinishSchoolMark == "1" || x.FinishSchoolMark == "2") && (x.DiplomaNo == null || x.DiplomaNo == "")).OrderBy(x => x.Grade).ThenBy(x => x.StuNo);
                foreach (var item in stuList)
                {
                    item.DiplomaNo = year + schoolCode + numberCode.ToString().PadLeft(4, '0');
                    db.Update(item);

                    numberCode++;
                }

                db.Commit();
            }
            catch (Exception ex)
            {
                db.Rollback();
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 获取StuInfoBasic表实体数据
        /// <param name="keyValue">主键</param>
        /// <summary>
        /// <returns></returns>
        public StuInfoBasicEntity GetStuNoByAccount(string keyValue)
        {
            try
            {
                return this.BaseRepository("CollegeMIS").FindEntity<StuInfoBasicEntity>(a => a.StuNo == keyValue);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }


        /// <summary> 
        /// 获取树形数据 
        /// </summary> 
        /// <returns></returns> 
        public DataTable GetSqlTree()
        {
            try
            {
                var ClassDiredctorNo = LoginUserInfo.Get().account;
                string sql = " SELECT * FROM dbo.ClassInfo  where CheckMark=1 ";
                if (ClassDiredctorNo.ToUpper() != "SYSTEM" && !LoginUserInfo.Get().roleIds.Contains("818c298e-ea1d-41d5-be4a-f06b092a420f"))
                {
                    sql += $"  and ClassDiredctorNo='{ClassDiredctorNo}' or ClassTutorNo='{ClassDiredctorNo}'";
                }
                return this.BaseRepository("CollegeMIS").FindTable(sql);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        #endregion

        #region  提交数据

        /// <summary>
        /// 审核全部
        /// </summary>
        public void CheckAll()
        {
            try
            {
                this.BaseRepository("CollegeMIS").ExecuteBySql("update StuInfoBasic set CheckMark=1");
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 准许毕业操作
        /// </summary>
        public void AllowGraduate(string stuNo, string status)
        {
            var db = this.BaseRepository("CollegeMIS").BeginTrans();
            try
            {
                var list = stuNo.Split(',').ToList().Select(a => "'" + a + "'");
                var stulist = string.Join(",", list);

                if (status == "1")//准许毕业
                {
                    //判断离校手续是否全办完，若满足则修改毕业状态为已毕业和毕业时间，若不满足则修改毕业状态为准许毕业；
                    foreach (var item in stuNo.Split(','))
                    {
                        var itementity = db.FindEntity<StuInfoBasicEntity>(x => x.StuNo == item);
                        if (itementity.ReturnBooksStatus == "1" && itementity.EmployAgreeStatus == "1" && itementity.FeeSettleStatus == "1" && itementity.CheckOutStatus == "1" && itementity.CardDeregistrateStatus == "1" && itementity.DiplomaReceiveStatus == "1" && itementity.FileTransferStatus == "1")
                        {
                            db.ExecuteBySql($"UPDATE dbo.StuInfoBasic SET FinishSchoolMark ='2',FinishSchoolDate='" + DateTime.Now + "' WHERE StuNo='" + item + "' ");
                        }
                        else
                        {
                            db.ExecuteBySql($"UPDATE dbo.StuInfoBasic SET FinishSchoolMark ='{status}',FinishSchoolDate=null WHERE StuNo='" + item + "' ");
                        }
                    }
                }
                else//不准毕业
                {
                    //毕业状态修改为不准毕业，毕业时间为空；
                    db.ExecuteBySql($"UPDATE dbo.StuInfoBasic SET FinishSchoolMark ='{status}',FinishSchoolDate=null WHERE StuNo in({stulist})");
                }

                db.Commit();
            }
            catch (Exception ex)
            {
                db.Rollback();
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        public void SynPhoto()
        {
            try
            {
                var stuList = this.BaseRepository("CollegeMIS").FindList<StuInfoBasicEntity>().ToList();
                var url = Config.GetValue("AnnexesFile");
                var loginUserInfo = LoginUserInfo.Get();
                foreach (var stuInfo in stuList)
                {
                    if (!string.IsNullOrEmpty(stuInfo.IdentityCardNo))
                    {
                        //判断要上传的照片在本地服务器中是否存在
                        var photoPath = $"{url}/UserPhoto/{stuInfo.IdentityCardNo}.jpg";
                        if (System.IO.File.Exists(photoPath))
                        {
                            //文件大小
                            FileInfo fileInfo = new FileInfo(photoPath);
                            var size = fileInfo.Length;
                            //学籍表中照片字段不为空
                            if (!string.IsNullOrEmpty(stuInfo.Photo))
                            {
                                var annex = this.BaseRepository().FindEntity<AnnexesFileEntity>(a => a.F_FolderId == stuInfo.Photo);
                                if (annex == null)
                                {
                                    var annexEntity = new AnnexesFileEntity()
                                    {
                                        F_Id = Guid.NewGuid().ToString(),
                                        F_FolderId = stuInfo.Photo,
                                        F_FileName = stuInfo.IdentityCardNo + ".jpg",
                                        F_FilePath = photoPath,
                                        F_FileSize = size.ToString(),
                                        F_FileExtensions = ".jpg",
                                        F_FileType = "jpg",
                                        F_CreateUserId = loginUserInfo.userId,
                                        F_CreateUserName = loginUserInfo.realName
                                    };
                                    annexEntity.Create();
                                    this.BaseRepository().Insert(annexEntity);

                                }
                                else
                                {
                                    annex.F_FileName = stuInfo.IdentityCardNo + ".jpg";
                                    annex.F_FilePath = photoPath;
                                    annex.F_FileSize = size.ToString();
                                    annex.F_FileExtensions = ".jpg";
                                    annex.F_FileType = "jpg";
                                    annex.F_CreateDate = DateTime.Now;
                                    annex.F_CreateUserId = loginUserInfo.userId;
                                    annex.F_CreateUserName = loginUserInfo.realName;
                                    this.BaseRepository().Update(annex);
                                }
                            }
                            else
                            {
                                //学籍表
                                stuInfo.Photo = Guid.NewGuid().ToString();
                                //附件表
                                var annexEntity = new AnnexesFileEntity()
                                {
                                    F_Id = Guid.NewGuid().ToString(),
                                    F_FolderId = stuInfo.Photo,
                                    F_FileName = stuInfo.IdentityCardNo + ".jpg",
                                    F_FilePath = photoPath,
                                    F_FileSize = size.ToString(),
                                    F_FileExtensions = ".jpg",
                                    F_FileType = "jpg",
                                    F_CreateUserId = loginUserInfo.userId,
                                    F_CreateUserName = loginUserInfo.realName
                                };
                                annexEntity.Create();
                                this.BaseRepository("CollegeMIS").Update(stuInfo);
                                this.BaseRepository().Insert(annexEntity);
                            }
                        }

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

        /// <summary>
        /// 删除实体数据
        /// <param name="keyValue">主键</param>
        /// <summary>
        /// <returns></returns>
        public void DeleteEntity(string keyValue)
        {
            var db = this.BaseRepository("CollegeMIS").BeginTrans();
            try
            {
                //单个删除
                //this.BaseRepository("CollegeMIS").Delete<StuInfoBasicEntity>(t => t.StuId == keyValue);

                //多个删除
                var keyValueArr = keyValue.Split(',');
                foreach (var item in keyValueArr)
                {
                    db.Delete<StuInfoBasicEntity>(t => t.StuId == item);
                }
                db.Commit();
            }
            catch (Exception ex)
            {
                db.Rollback();
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 领取毕业证
        /// <param name="keyValue">主键</param>
        /// <summary>
        /// <returns></returns>
        public void GetCard(string keyValue, string status, StuInfoBasicEntity entity)
        {
            var db = this.BaseRepository("CollegeMIS").BeginTrans();
            try
            {
                if (status == "1")//领取
                {
                    var now = DateTime.Now;
                    var keyValueArr = keyValue.Split(',');
                    foreach (var item in keyValueArr)
                    {
                        var sql = $"UPDATE StuInfoBasic SET DiplomaReceiveStatus='{status}',DiplomaReceiveDate='{now}',DiplomaReceiveSign='{entity.DiplomaReceiveSign}',DiplomaReceiveIdcard='{entity.DiplomaReceiveIdcard}',DiplomaReceiveRemark='{entity.DiplomaReceiveRemark}' WHERE StuId='{item}'";
                        db.ExecuteBySql(sql);

                        //判断离校手续是否全办完 且 毕业状态为准许毕业，若同时满足则修改毕业状态为已毕业和毕业时间；
                        var sql2 = $"update StuInfoBasic set FinishSchoolMark='2',FinishSchoolDate='{now}' where StuId='{item}' and FinishSchoolMark='1' and ReturnBooksStatus='1' and EmployAgreeStatus='1' and FeeSettleStatus='1' and CheckOutStatus='1' and CardDeregistrateStatus='1' and FileTransferStatus='1' and TissueStatus='1' ";
                        db.ExecuteBySql(sql2);
                    }
                }
                else
                {

                    var keyValueArr = keyValue.Split(',');
                    foreach (var item in keyValueArr)
                    {
                        var sql = $"UPDATE StuInfoBasic SET DiplomaReceiveStatus='{status}',DiplomaReceiveDate=null,DiplomaReceiveSign=null,DiplomaReceiveIdcard=null,DiplomaReceiveRemark=null WHERE StuId='{item}'";
                        db.ExecuteBySql(sql);

                        //判断毕业状态是否为已毕业，若是，则毕业状态修改为准许毕业，毕业时间为空；
                        var sql2 = $"UPDATE StuInfoBasic SET FinishSchoolMark='1',FinishSchoolDate=null WHERE StuId='{item}' and FinishSchoolMark='2' ";
                        db.ExecuteBySql(sql2);
                    }
                }

                db.Commit();
            }
            catch (Exception ex)
            {
                db.Rollback();
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 图书资料归还
        /// <param name="keyValue">主键</param>
        /// <summary>
        /// <returns></returns>
        public void IsReturnBooks(string keyValue, string status)
        {
            var db = this.BaseRepository("CollegeMIS").BeginTrans();
            try
            {
                if (status == "1")//归还
                {
                    var now = DateTime.Now;
                    var keyValueArr = keyValue.Split(',');
                    foreach (var item in keyValueArr)
                    {
                        var sql = $"UPDATE StuInfoBasic SET ReturnBooksStatus='{status}',ReturnBooksDate='{now}' WHERE StuId='{item}'";
                        db.ExecuteBySql(sql);

                        //判断离校手续是否全办完 且 毕业状态为准许毕业，若同时满足则修改毕业状态为已毕业和毕业时间；
                        var sql2 = $"update StuInfoBasic set FinishSchoolMark='2',FinishSchoolDate='{now}' where StuId='{item}' and FinishSchoolMark='1' and EmployAgreeStatus='1' and FeeSettleStatus='1' and CheckOutStatus='1' and CardDeregistrateStatus='1' and DiplomaReceiveStatus='1' and FileTransferStatus='1' and TissueStatus='1'  ";
                        db.ExecuteBySql(sql2);
                    }
                }
                else
                {

                    var keyValueArr = keyValue.Split(',');
                    foreach (var item in keyValueArr)
                    {
                        var sql = $"UPDATE StuInfoBasic SET ReturnBooksStatus='{status}',ReturnBooksDate=null WHERE StuId='{item}'";
                        db.ExecuteBySql(sql);

                        //判断毕业状态是否为已毕业，若是，则毕业状态修改为准许毕业，毕业时间为空；
                        var sql2 = $"UPDATE StuInfoBasic SET FinishSchoolMark='1',FinishSchoolDate=null WHERE StuId='{item}' and FinishSchoolMark='2' ";
                        db.ExecuteBySql(sql2);
                    }
                }

                db.Commit();
            }
            catch (Exception ex)
            {
                db.Rollback();
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 就业协议备案
        /// <param name="keyValue">主键</param>
        /// <summary>
        /// <returns></returns>
        public void IsEmployAgree(string keyValue, string status)
        {
            var db = this.BaseRepository("CollegeMIS").BeginTrans();
            try
            {
                if (status == "1")//备案
                {
                    var now = DateTime.Now;
                    var keyValueArr = keyValue.Split(',');
                    foreach (var item in keyValueArr)
                    {
                        var sql = $"UPDATE StuInfoBasic SET EmployAgreeStatus='{status}',EmployAgreeDate='{now}' WHERE StuId='{item}'";
                        db.ExecuteBySql(sql);

                        //判断离校手续是否全办完 且 毕业状态为准许毕业，若同时满足则修改毕业状态为已毕业和毕业时间；
                        var sql2 = $"update StuInfoBasic set FinishSchoolMark='2',FinishSchoolDate='{now}' where StuId='{item}' and FinishSchoolMark='1' and ReturnBooksStatus='1' and FeeSettleStatus='1' and CheckOutStatus='1' and CardDeregistrateStatus='1' and DiplomaReceiveStatus='1' and FileTransferStatus='1' and TissueStatus='1'  ";
                        db.ExecuteBySql(sql2);
                    }
                }
                else
                {

                    var keyValueArr = keyValue.Split(',');
                    foreach (var item in keyValueArr)
                    {
                        var sql = $"UPDATE StuInfoBasic SET EmployAgreeStatus='{status}',EmployAgreeDate=null WHERE StuId='{item}'";
                        db.ExecuteBySql(sql);

                        //判断毕业状态是否为已毕业，若是，则毕业状态修改为准许毕业，毕业时间为空；
                        var sql2 = $"UPDATE StuInfoBasic SET FinishSchoolMark='1',FinishSchoolDate=null WHERE StuId='{item}' and FinishSchoolMark='2' ";
                        db.ExecuteBySql(sql2);
                    }
                }

                db.Commit();
            }
            catch (Exception ex)
            {
                db.Rollback();
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 学杂费结算
        /// <param name="keyValue">主键</param>
        /// <summary>
        /// <returns></returns>
        public void IsFeeSettle(string keyValue, string status)
        {
            var db = this.BaseRepository("CollegeMIS").BeginTrans();
            try
            {
                if (status == "1")//结算
                {
                    var now = DateTime.Now;
                    var keyValueArr = keyValue.Split(',');
                    foreach (var item in keyValueArr)
                    {
                        var sql = $"UPDATE StuInfoBasic SET FeeSettleStatus='{status}',FeeSettleDate='{now}' WHERE StuId='{item}'";
                        db.ExecuteBySql(sql);

                        //判断离校手续是否全办完 且 毕业状态为准许毕业，若同时满足则修改毕业状态为已毕业和毕业时间；
                        var sql2 = $"update StuInfoBasic set FinishSchoolMark='2',FinishSchoolDate='{now}' where StuId='{item}' and FinishSchoolMark='1' and ReturnBooksStatus='1' and EmployAgreeStatus='1' and CheckOutStatus='1' and CardDeregistrateStatus='1' and DiplomaReceiveStatus='1' and FileTransferStatus='1' and TissueStatus='1'  ";
                        db.ExecuteBySql(sql2);
                    }
                }
                else
                {

                    var keyValueArr = keyValue.Split(',');
                    foreach (var item in keyValueArr)
                    {
                        var sql = $"UPDATE StuInfoBasic SET FeeSettleStatus='{status}',FeeSettleDate=null WHERE StuId='{item}'";
                        db.ExecuteBySql(sql);

                        //判断毕业状态是否为已毕业，若是，则毕业状态修改为准许毕业，毕业时间为空；
                        var sql2 = $"UPDATE StuInfoBasic SET FinishSchoolMark='1',FinishSchoolDate=null WHERE StuId='{item}' and FinishSchoolMark='2' ";
                        db.ExecuteBySql(sql2);
                    }
                }

                db.Commit();
            }
            catch (Exception ex)
            {
                db.Rollback();
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 办理退住手续
        /// <param name="keyValue">主键</param>
        /// <summary>
        /// <returns></returns>
        public void IsCheckOut(string keyValue, string status)
        {
            var db = this.BaseRepository("CollegeMIS").BeginTrans();
            try
            {
                if (status == "1")//办理
                {
                    var now = DateTime.Now;
                    var keyValueArr = keyValue.Split(',');
                    foreach (var item in keyValueArr)
                    {
                        var sql = $"UPDATE StuInfoBasic SET CheckOutStatus='{status}',CheckOutDate='{now}' WHERE StuId='{item}'";
                        db.ExecuteBySql(sql);

                        //判断离校手续是否全办完 且 毕业状态为准许毕业，若同时满足则修改毕业状态为已毕业和毕业时间；
                        var sql2 = $"update StuInfoBasic set FinishSchoolMark='2',FinishSchoolDate='{now}' where StuId='{item}' and FinishSchoolMark='1' and ReturnBooksStatus='1' and EmployAgreeStatus='1' and FeeSettleStatus='1' and CardDeregistrateStatus='1' and DiplomaReceiveStatus='1' and FileTransferStatus='1' and TissueStatus='1'  ";
                        db.ExecuteBySql(sql2);
                    }
                }
                else
                {

                    var keyValueArr = keyValue.Split(',');
                    foreach (var item in keyValueArr)
                    {
                        var sql = $"UPDATE StuInfoBasic SET CheckOutStatus='{status}',CheckOutDate=null WHERE StuId='{item}'";
                        db.ExecuteBySql(sql);

                        //判断毕业状态是否为已毕业，若是，则毕业状态修改为准许毕业，毕业时间为空；
                        var sql2 = $"UPDATE StuInfoBasic SET FinishSchoolMark='1',FinishSchoolDate=null WHERE StuId='{item}' and FinishSchoolMark='2' ";
                        db.ExecuteBySql(sql2);
                    }
                }

                db.Commit();
            }
            catch (Exception ex)
            {
                db.Rollback();
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 校园卡注销
        /// <param name="keyValue">主键</param>
        /// <summary>
        /// <returns></returns>
        public void IsCardDeregistrate(string keyValue, string status)
        {
            var db = this.BaseRepository("CollegeMIS").BeginTrans();
            try
            {
                if (status == "1")//注销
                {
                    var now = DateTime.Now;
                    var keyValueArr = keyValue.Split(',');
                    foreach (var item in keyValueArr)
                    {
                        var sql = $"UPDATE StuInfoBasic SET CardDeregistrateStatus='{status}',CardDeregistrateDate='{now}' WHERE StuId='{item}'";
                        db.ExecuteBySql(sql);

                        //判断离校手续是否全办完 且 毕业状态为准许毕业，若同时满足则修改毕业状态为已毕业和毕业时间；
                        var sql2 = $"update StuInfoBasic set FinishSchoolMark='2',FinishSchoolDate='{now}' where StuId='{item}' and FinishSchoolMark='1' and ReturnBooksStatus='1' and EmployAgreeStatus='1' and FeeSettleStatus='1' and CheckOutStatus='1' and DiplomaReceiveStatus='1' and FileTransferStatus='1' and TissueStatus='1'  ";
                        db.ExecuteBySql(sql2);
                    }
                }
                else
                {

                    var keyValueArr = keyValue.Split(',');
                    foreach (var item in keyValueArr)
                    {
                        var sql = $"UPDATE StuInfoBasic SET CardDeregistrateStatus='{status}',CardDeregistrateDate=null WHERE StuId='{item}'";
                        db.ExecuteBySql(sql);

                        //判断毕业状态是否为已毕业，若是，则毕业状态修改为准许毕业，毕业时间为空；
                        var sql2 = $"UPDATE StuInfoBasic SET FinishSchoolMark='1',FinishSchoolDate=null WHERE StuId='{item}' and FinishSchoolMark='2' ";
                        db.ExecuteBySql(sql2);
                    }
                }

                db.Commit();
            }
            catch (Exception ex)
            {
                db.Rollback();
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 档案与组织关系转出
        /// <param name="keyValue">主键</param>
        /// <summary>
        /// <returns></returns>
        public void IsFileTransfer(string keyValue, string status, string fort)
        {
            var db = this.BaseRepository("CollegeMIS").BeginTrans();
            try
            {
                if (status == "1")//转出
                {
                    var now = DateTime.Now;
                    var keyValueArr = keyValue.Split(',');
                    foreach (var item in keyValueArr)
                    {
                        if (fort == "0")
                        {
                            //档案
                            var sql = $"UPDATE StuInfoBasic SET FileTransferStatus='{status}',FileTransferDate='{now}' WHERE StuId='{item}'";
                            db.ExecuteBySql(sql);

                            //判断离校手续是否全办完 且 毕业状态为准许毕业，若同时满足则修改毕业状态为已毕业和毕业时间；
                            var sql2 = $"update StuInfoBasic set FinishSchoolMark='2',FinishSchoolDate='{now}' where StuId='{item}' and FinishSchoolMark='1' and ReturnBooksStatus='1' and EmployAgreeStatus='1' and FeeSettleStatus='1' and CheckOutStatus='1' and CardDeregistrateStatus='1' and DiplomaReceiveStatus='1' and TissueStatus='1'";
                            db.ExecuteBySql(sql2);
                        }
                        else
                        {
                            //组织
                            var sql1 = $"UPDATE StuInfoBasic SET TissueStatus='{status}',TissueDate='{now}' WHERE StuId='{item}'";
                            db.ExecuteBySql(sql1);

                            //判断离校手续是否全办完 且 毕业状态为准许毕业，若同时满足则修改毕业状态为已毕业和毕业时间；
                            var sql2 = $"update StuInfoBasic set FinishSchoolMark='2',FinishSchoolDate='{now}' where StuId='{item}' and FinishSchoolMark='1' and ReturnBooksStatus='1' and EmployAgreeStatus='1' and FeeSettleStatus='1' and CheckOutStatus='1' and CardDeregistrateStatus='1' and DiplomaReceiveStatus='1'  and FileTransferStatus= '1'";
                            db.ExecuteBySql(sql2);
                        }

                        ////判断离校手续是否全办完 且 毕业状态为准许毕业，若同时满足则修改毕业状态为已毕业和毕业时间；
                        //var sql2 = $"update StuInfoBasic set FinishSchoolMark='2',FinishSchoolDate='{now}' where StuId='{item}' and FinishSchoolMark='1' and ReturnBooksStatus='1' and EmployAgreeStatus='1' and FeeSettleStatus='1' and CheckOutStatus='1' and CardDeregistrateStatus='1' and DiplomaReceiveStatus='1' ";
                        //db.ExecuteBySql(sql2);
                    }
                }
                else
                {

                    var keyValueArr = keyValue.Split(',');
                    foreach (var item in keyValueArr)
                    {
                        if (fort == "0")
                        {
                            var sql = $"UPDATE StuInfoBasic SET FileTransferStatus='{status}',FileTransferDate=null WHERE StuId='{item}'";
                            db.ExecuteBySql(sql);
                        }
                        else
                        {
                            var sql1 = $"UPDATE StuInfoBasic SET TissueStatus='{status}',TissueDate=null WHERE StuId='{item}'";
                            db.ExecuteBySql(sql1);
                        }

                        //判断毕业状态是否为已毕业，若是，则毕业状态修改为准许毕业，毕业时间为空；
                        var sql2 = $"UPDATE StuInfoBasic SET FinishSchoolMark='1',FinishSchoolDate=null WHERE StuId='{item}' and FinishSchoolMark='2' ";
                        db.ExecuteBySql(sql2);
                    }
                }

                db.Commit();
            }
            catch (Exception ex)
            {
                db.Rollback();
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 毕业生归档
        /// <summary>
        /// <returns></returns>
        public void StuStore()
        {
            /*
             1.毕业生归档必须在6-8月份进行； <br>  
             2.归档后的学生信息如：操行、奖惩、成绩、毕业证书等只有通过毕业生信息管理才能查询或打印；<br> 
             3.毕业学生的账户将自动取消；<br> 
             4.学生所占的床位也将自动退掉；<br> 
             5.学生所在的班级置为已毕业班级；<br> 
             6.归档操作后不可撤消，请谨慎操作！
             */

            var db = this.BaseRepository("CollegeMIS").BeginTrans();
            var adb = this.BaseRepository().BeginTrans();
            try
            {
                //归档前提为毕业标志为2(已毕业)的学生
                var stuInfos = db.FindList<StuInfoBasicEntity>(a => a.FinishSchoolMark == "2");
                foreach (var item in stuInfos)
                {
                    //var StuInfoType = typeof(StuInfoBasicEntity);
                    //var PropertyInfoStuInfo = StuInfoType.GetProperties();
                    //var GraduateEntity = new StuInfoGraduateEntity();
                    //var typegraduate = typeof(StuInfoGraduateEntity);
                    //var PropertyInfoGraduate = typegraduate.GetProperties();
                    //foreach (var itemStuInfo in PropertyInfoStuInfo)
                    //{
                    //    var objStuInfoType = itemStuInfo.GetValue(StuInfoType);
                    //    foreach (var itemGraduate in PropertyInfoGraduate)
                    //    {
                    //        if (itemGraduate.Name == itemStuInfo.Name)
                    //        {
                    //            itemGraduate.SetValue(GraduateEntity, objStuInfoType, null);
                    //        }
                    //    }

                    //}

                    var accountInfo = adb.FindEntity<UserEntity>(a => a.F_Account == item.StuNo);
                    if (accountInfo != null)
                    {
                        //删除账户
                        adb.Delete(accountInfo);
                    }
                    //清空宿舍信息
                    var dormitory = db.FindEntity<Acc_DormitoryBuildEntity>(a => a.StudentID == item.StuNo);
                    if (dormitory != null)
                    {
                        dormitory.StudentID = "";
                        dormitory.StuName = "";
                        db.Update(dormitory);
                        //宿舍上一级房间，入住人数-1
                        var room = db.FindEntity<Acc_DormitoryBuildEntity>(x => x.ID == dormitory.ParentID);
                        if (room != null)
                        {
                            if (room.CheckInStu.HasValue && room.CheckInStu.Value > 0)
                            {
                                room.CheckInStu--;
                                db.Update(room);
                            }
                        }
                    }
                    //班级置为已毕业班级
                    var classInfo = db.FindEntity<ClassInfoEntity>(x => x.ClassNo == item.ClassNo);
                    if (classInfo != null && classInfo.ClassStatus != "1")
                    {
                        classInfo.ClassStatus = "1";
                        db.Update(classInfo);
                    }
                    //删除学籍表信息
                    db.Delete(item);
                    //增加学生毕业表信息
                    var addSql = $"insert into StuInfoGraduate select * from StuInfoBasic where StuId='{item.StuId}'";
                    db.ExecuteBySql(addSql);
                    //db.Insert(GraduateEntity);
                }
                db.Commit();
                adb.Commit();
            }
            catch (Exception ex)
            {
                db.Rollback();
                adb.Rollback();
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        /// <summary>
        /// 保存实体数据（新增、修改）
        /// <param name="keyValue">主键</param>
        /// <summary>
        /// <returns></returns>
        public void SaveEntity(string keyValue, StuInfoBasicEntity entity)
        {
            var db = this.BaseRepository("CollegeMIS").BeginTrans();
            try
            {
                UserIBLL userIBLL = new UserBLL();
                var loginUser = LoginUserInfo.Get();
                if (!string.IsNullOrEmpty(keyValue))
                {
                    entity.Modify(keyValue);
                    // wx 根据要求去除
                    #region 编辑加入学籍异动信息
                    //                  var oldEntity = this.BaseRepository("CollegeMIS").FindEntity<StuInfoBasicEntity>(keyValue);
                    //                  List<StuInfoBasic_ChangeLogEntity> list = new List<StuInfoBasic_ChangeLogEntity>();
                    //                  var tableInfos = this.BaseRepository("CollegeMIS").FindTable(@"SELECT t.[name] AS 表名,c.[name] AS 字段名,cast(ep.[value] 
                    //as varchar(100)) AS [字段说明]
                    //FROM sys.tables AS t
                    //INNER JOIN sys.columns 
                    //AS c ON t.object_id = c.object_id
                    // LEFT JOIN sys.extended_properties AS ep 
                    //ON ep.major_id = c.object_id AND ep.minor_id = c.column_id WHERE ep.class =1 
                    //AND t.name='StuInfoBasic'");

                    //                  PropertyInfo[] properties = oldEntity.GetType().GetProperties();
                    //                  foreach (System.Reflection.PropertyInfo item in properties)
                    //                  {
                    //                      string name = item.Name;
                    //                      object oldValue = item.GetValue(oldEntity);
                    //                      object newValue = item.GetValue(entity);
                    //                      if (oldValue == null || newValue == null)
                    //                      {
                    //                          continue;
                    //                      }
                    //                      if (!oldValue.Equals(newValue))
                    //                      {
                    //                          var columnName = "";
                    //                          foreach (DataRow rows in tableInfos.Rows)
                    //                          {
                    //                              if (rows["字段名"].ToString() == item.Name)
                    //                              {
                    //                                  columnName = rows["字段说明"].ToString();
                    //                              }

                    //                          }
                    //                          var changeEntity = new StuInfoBasic_ChangeLogEntity
                    //                          {
                    //                              StuID = keyValue,
                    //                              BeforeChange = oldValue.ToString(),
                    //                              AfterChange = newValue.ToString(),
                    //                              FieldName = columnName,
                    //                              UpdateBy = loginUser.userId,
                    //                              UpdateTime = DateTime.Now,
                    //                              StuChangeType = "09",
                    //                              StuChangeRemark = "点击学籍信息管理-修改按钮进行操作"
                    //                          };
                    //                          changeEntity.Create();
                    //                          list.Add(changeEntity);
                    //                      }

                    //                  }

                    //                  if (list.Count > 0)
                    //                  {
                    //                      db.Insert(list);
                    //                  } 
                    #endregion

                    var annexesFileEntity = this.BaseRepository().FindEntity<AnnexesFileEntity>(a => a.F_FolderId == entity.Photo);
                    var url = "";
                    if (annexesFileEntity != null)
                    {
                        url = annexesFileEntity.F_FilePath;
                        url = "/" + url.Substring(url.IndexOf("Resource"), url.Length - url.IndexOf("Resource"));


                    }
                    var baseUser = userIBLL.GetEntityByAccount(entity.StuNo);
                    if (baseUser != null)
                    {

                        baseUser.F_HeadIcon = url;
                        userIBLL.SaveEntity(baseUser.F_UserId, baseUser);
                    }

                    db.Update(entity);
                }
                else
                {
                    entity.Create();
                    // wx 根据要求去除
                    #region 学籍异动日志表
                    //if (entity.IsTran == "0")//转入/进
                    //{
                    //    //学籍异动日志表
                    //    var changeEntity = new StuInfoBasic_ChangeLogEntity
                    //    {
                    //        StuID = entity.StuId,
                    //        BeforeChange = null,
                    //        AfterChange = entity.StuId,
                    //        FieldName = "学籍表主键",
                    //        UpdateBy = loginUser.userId,
                    //        UpdateTime = DateTime.Now,
                    //        StuChangeType = "04",
                    //        StuChangeRemark = "点击学籍信息管理-异动转入按钮进行操作"
                    //    };
                    //    changeEntity.Create();
                    //    db.Insert(changeEntity);
                    //} 
                    #endregion
                    db.Insert(entity);
                }

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

        #region  缓存定义
        private ICache cache = CacheFactory.CaChe();
        private string cacheKey = "Learun_adms_excelError_";       // +公司主键
        #endregion

        /// <summary>
        /// 学生学籍信息修改
        /// </summary>
        /// <param name="dt"></param>
        public string StuInfoBasicImport(DataTable dt, string fileId)
        {
            try
            {
                int snum = 0;
                int fnum = 0;
                if (dt.Rows.Count > 0)
                {
                    DataTable failDt = new DataTable();
                    dt.Columns.Add("导入错误", typeof(string));
                    foreach (DataColumn dc in dt.Columns)
                    {
                        failDt.Columns.Add(dc.ColumnName, dc.DataType);
                    }
                    IEnumerable<StuInfoBasicEntity> stuInfoBasicEntities = this.BaseRepository("CollegeMIS").FindList<StuInfoBasicEntity>("select * from StuInfoBasic");
                    //修改学生list
                    List<StuInfoBasicEntity> insertedorderlist = new List<StuInfoBasicEntity>();
                    var db = this.BaseRepository("CollegeMIS").BeginTrans();
                    // 循环遍历导入
                    foreach (DataRow dr in dt.Rows)
                    {
                        try
                        {
                            //检测是否有空值
                            if (dr[0].ToString() == "" || dr[1].ToString() == "" || dr[2].ToString() == "" || dr[3].ToString() == "")
                            {
                                throw (new Exception("行内数据有空值，不能为空！"));
                            }
                            if (stuInfoBasicEntities.Count(m => m.IdentityCardNo.ToUpper() == dr[0].ToString().ToUpper()) == 0)
                            {
                                throw (new Exception("【身份证号】不存在，请核对！"));
                            }
                            //写入要导入的数据
                            StuInfoBasicEntity stuUpdateList = new StuInfoBasicEntity();
                            stuUpdateList.StuId = stuInfoBasicEntities.FirstOrDefault(s => s.IdentityCardNo.ToUpper() == dr[0].ToString().ToUpper())?.StuId.ToString();
                            stuUpdateList.StuCode = dr[1].ToString();
                            stuUpdateList.MailAddress = dr[2].ToString();
                            stuUpdateList.mobile = dr[3].ToString();
                            insertedorderlist.Add(stuUpdateList);
                            snum++;
                        }
                        catch (Exception ex)
                        {
                            fnum++;
                            dr["导入错误"] = ex.Message;
                            failDt.Rows.Add(dr.ItemArray);
                        }
                    }
                    //执行导入
                    db.Update(insertedorderlist);
                    db.Commit();
                    if (failDt.Rows.Count > 0)
                    {
                        string errordt = failDt.ToJson();
                        cache.Write<string>(cacheKey + fileId, errordt, CacheId.excel);
                    }
                }
                return snum + "|" + fnum;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        #endregion


        public class TableInfo
        {
            public string TableName { get; set; }
            public string ColumnName { get; set; }
            public string ColumnDescription { get; set; }
        }
        public class StuInfoStatisticsModel
        {
            /// <summary>
            /// 民族
            /// </summary>
            public string NationalityNo { get; set; }
            /// <summary>
            /// 性别
            /// </summary>
            public string GenderNo { get; set; }
            /// <summary>
            /// 专业
            /// </summary>
            public string MajorNo { get; set; }
            /// <summary>
            /// 生源地(省)
            /// </summary>
            public string F_ProvinceId { get; set; }
        }
        public void GenerateAccout()
        {
            UserRelationIBLL userRelationIBLL = new UserRelationBLL();
            UserIBLL userIBLL = new UserBLL();
            try
            {
                var stuInfoBasicEntities = BaseRepository("CollegeMIS").FindList<StuInfoBasicEntity>(m => m.CheckMark != "0");
                var alluserlist = userIBLL.GetAllList().Where(m => m.F_Description == "学生");
                var roleId = Config.GetValue("GenerateStudentsRoleId");
                var defaultpwd = Config.GetValue("defaultpwd");
                //读取默认密码配置中已启用的密码
                var Sys_DefaultPwdConfigEntity = this.BaseRepository().FindEntity<Sys_DefaultPwdConfigEntity>(x => x.IsEnabled == true);
                if (Sys_DefaultPwdConfigEntity != null)
                {
                    defaultpwd = Sys_DefaultPwdConfigEntity.Pwd;
                }
                var studentList = new List<UserEntity>();
                foreach (var tEntity in stuInfoBasicEntities)
                {
                    if (alluserlist.Count(m => m.F_Account == tEntity.StuNo) > 0)
                    {
                        continue;
                    }

                    var annexesFileEntity = this.BaseRepository().FindEntity<AnnexesFileEntity>(a => a.F_FolderId == tEntity.Photo);
                    var url = "";
                    if (annexesFileEntity != null)
                    {
                        url = annexesFileEntity.F_FilePath;
                        url = "/" + url.Substring(url.IndexOf("Resource"));

                    }

                    UserEntity userbase = new UserEntity();
                    userbase.F_Account = tEntity.StuNo;
                    userbase.F_RealName = tEntity.StuName;
                    userbase.F_EnCode = tEntity.StuNo;
                    userbase.F_Password = Md5Helper.Encrypt(defaultpwd, 32).ToLower();
                    userbase.F_HeadIcon = string.IsNullOrEmpty(url) ? Config.GetValue("defaultheadimg") : url;
                    userbase.F_Gender = tEntity.GenderNo.HasValue ? Convert.ToInt32(tEntity.GenderNo.Value) : 1;
                    userbase.F_DeleteMark = 0;
                    userbase.F_EnabledMark = 1;
                    userbase.F_Mobile = tEntity.mobile;
                    userbase.F_Description = "学生";
                    userbase.F_CompanyId = tEntity.F_SchoolId;
                    userbase.F_DepartmentId = tEntity.DeptNo;
                    userbase.F_IdentityCardNo = tEntity.IdentityCardNo;
                    userIBLL.SaveEntity(null, userbase);
                    studentList.Add(userbase);
                }
                if (studentList.Any())
                {
                    string s = studentList.Select(m => m.F_UserId).Aggregate((current, userEntity) => current + "," + userEntity);
                    userRelationIBLL.SaveEntityList2(roleId, 1, s);
                }
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        public void UpdateAccount()
        {
            try
            {
                UserIBLL userIBLL = new UserBLL();
                var teacherList = this.BaseRepository("CollegeMIS").FindList<StuInfoBasicEntity>();
                var baseTeacherList = userIBLL.GetAllList().Where(m => m.F_Description == "学生");
                foreach (var baseTeacher in baseTeacherList)
                {
                    var num = 0;
                    var teacher = teacherList.FirstOrDefault(a => a.StuNo == baseTeacher.F_Account);
                    if (teacher != null)
                    {
                        if (baseTeacher.F_RealName != teacher.StuName)
                        {
                            baseTeacher.F_RealName = teacher.StuName;
                            num++;
                        }
                        if (baseTeacher.F_Gender != Convert.ToInt32(teacher.GenderNo))
                        {
                            baseTeacher.F_Gender = Convert.ToInt32(teacher.GenderNo);
                            num++;
                        }
                        if (baseTeacher.F_Mobile != teacher.mobile)
                        {
                            baseTeacher.F_Mobile = teacher.mobile;
                            num++;
                        }
                        if (baseTeacher.F_CompanyId != teacher.F_SchoolId)
                        {
                            baseTeacher.F_CompanyId = teacher.F_SchoolId;
                            num++;
                        }
                        if (baseTeacher.F_DepartmentId != teacher.DeptNo)
                        {
                            baseTeacher.F_DepartmentId = teacher.DeptNo;
                            num++;
                        }
                        if (baseTeacher.F_IdentityCardNo != teacher.IdentityCardNo)
                        {
                            baseTeacher.F_IdentityCardNo = teacher.IdentityCardNo;
                            num++;
                        }
                        if (num > 0)
                        {
                            userIBLL.UpdateEntity(baseTeacher);
                        }
                    }
                }

            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        public void UpdateState(string keyValue, string state)
        {
            var db = this.BaseRepository().BeginTrans();
            try
            {
                var keyValueArr = keyValue.Split(',');
                foreach (var item in keyValueArr)
                {
                    var StuNo = this.BaseRepository("CollegeMIS").FindEntity<StuInfoBasicEntity>(item).StuNo;
                    if (!StuNo.IsEmpty())
                    {
                        if (state == "1")
                        {
                            db.ExecuteBySql("update LR_Base_User set F_EnabledMark=1 where F_EnCode='" + StuNo + "'");
                        }
                        else
                        {
                            db.ExecuteBySql("update LR_Base_User set F_EnabledMark=0 where F_EnCode='" + StuNo + "'");
                        }
                    }
                }
                db.Commit();
            }
            catch (Exception ex)
            {
                db.Rollback();
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        public IEnumerable<StuInfoBasicEntity> GetAllList()
        {
            try
            {
                return this.BaseRepository("CollegeMIS").FindList<StuInfoBasicEntity>(m => m.CheckMark == "1");
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        public IEnumerable<StuInfoStatisticsModel> GetAllStatistics()
        {
            return this.BaseRepository("CollegeMIS").FindList<StuInfoStatisticsModel>("select F_ProvinceId,NationalityNo,GenderNo,MajorNo FROM StuInfoBasic");
        }
        /// <summary>
        /// 班级不看学籍异动
        /// </summary>
        /// <param name="ChangeType"></param>
        /// <returns></returns>
        public IEnumerable<StuInfoBasicEntity> GetAllList(string ChangeType)
        {
            try
            {
                StringBuilder sb = new StringBuilder();
                sb.Append(@"select * from StuInfoBasic 
                where stuNo not in (select Stuno from StuInfoBasicChange where StuChangeType in ('02', '05', '06'))");
                return this.BaseRepository("CollegeMIS").FindList<StuInfoBasicEntity>(sb.ToString());
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        public IEnumerable<StuInfoBasicEntity> GetStuInfoByClassNo(string classNo)
        {
            try
            {
                return this.BaseRepository("CollegeMIS").FindList<StuInfoBasicEntity>(m => m.CheckMark == "1" && m.ClassNo == classNo);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
    }
}