JW/学校扩展文件/EMIS.ExtensionLogic.HBGD/ServiceLogic/CultureplanManage/CoursematerialServices.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using Bowin.Common.Utility;
using EMIS.Entities;
using EMIS.ViewModel;
using EMIS.ViewModel.CacheManage;
using EMIS.ViewModel.Cultureplan;

namespace EMIS.ExtensionLogic.ServiceLogic.CultureplanManage
{
    public class CoursematerialServices : EMIS.CommonLogic.Cultureplan.CoursematerialServices
    {
        /// <summary>
        /// 编辑（新增、修改）
        /// 注：业务主键为课程代码唯一（河北工业大学,相同课程名称不同课程代码,用于区分专业基础课、专业课）
        /// </summary>
        /// <param name="coursematerialView"></param>
        public override void CoursematerialEdit(CoursematerialView coursematerialView)
        {
            try
            {
                //查询数据库进行验证
                var courseCodeVerify = CoursematerialDAL.CoursematerialRepository
                        .GetList(x => x.CoursematerialID != coursematerialView.CoursematerialID
                                && x.CourseCode == coursematerialView.CourseCode).SingleOrDefault();
                if (courseCodeVerify == null)
                {
                    //数据有误验证
                    if (coursematerialView.CoursematerialID != Guid.Empty)
                    {
                        var course = CoursematerialDAL.CoursematerialRepository
                                .GetList(x => x.CoursematerialID == coursematerialView.CoursematerialID).SingleOrDefault();
                        if (course == null)
                        {
                            throw new Exception("数据有误，请核查。");
                        }
                        else
                        {
                            //表示修改
                            course.CourseCode = coursematerialView.CourseCode;
                            course.CourseName = coursematerialView.CourseName;
                            course.Abbreviation = coursematerialView.Abbreviation;
                            course.EnglishName = coursematerialView.EnglishName;
                            course.StandardName = coursematerialView.StandardName;
                            course.CourseEdition = coursematerialView.CourseEdition;
                            course.CourseLevelID = coursematerialView.CourseLevelID;
                            course.CourseScienceID = coursematerialView.CourseScienceID;
                            course.ClassGroupingID = coursematerialView.ClassGroupingID;
                            course.CourseSynopsis = coursematerialView.CourseSynopsis;
                            course.CourseReserve = coursematerialView.CourseReserve;
                            course.IsEnable = coursematerialView.IsEnable;
                            course.Remark = coursematerialView.Remark;
                            SetModifyStatus(course);
                        }
                    }
                    else
                    {
                        //表示新增
                        var newCourse = new EM_Coursematerial();
                        newCourse.CoursematerialID = Guid.NewGuid();
                        newCourse.CourseCode = coursematerialView.CourseCode;
                        newCourse.CourseName = coursematerialView.CourseName;
                        newCourse.Abbreviation = coursematerialView.Abbreviation;
                        newCourse.EnglishName = coursematerialView.EnglishName;
                        newCourse.StandardName = coursematerialView.StandardName;
                        newCourse.CourseEdition = coursematerialView.CourseEdition;
                        newCourse.CourseLevelID = coursematerialView.CourseLevelID;
                        newCourse.CourseScienceID = coursematerialView.CourseScienceID;
                        newCourse.ClassGroupingID = coursematerialView.ClassGroupingID;
                        newCourse.CourseSynopsis = coursematerialView.CourseSynopsis;
                        newCourse.CourseReserve = coursematerialView.CourseReserve;
                        newCourse.IsEnable = coursematerialView.IsEnable;
                        newCourse.Remark = coursematerialView.Remark;
                        SetNewStatus(newCourse);
                        UnitOfWork.Add(newCourse);
                    }
                    //事务提交
                    UnitOfWork.Commit();
                }
                else
                {
                    throw new Exception("已存在相同的课程代码，请核查。");
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

        /// <summary>
        /// 课程信息导入
        /// 注：业务主键为课程代码唯一（河北工业大学,相同课程名称不同课程代码,用于区分专业基础课、专业课）
        /// </summary>
        /// <param name="cellheader"></param>
        /// <param name="inCount"></param>
        /// <param name="upCount"></param>
        /// <param name="errdataList"></param>
        /// <param name="errCount"></param>
        /// <param name="sourcePhysicalPath"></param>
        public override void CoursematerialImport(Dictionary<string, string> cellheader, out int? inCount, out int? upCount, out List<CoursematerialView> errdataList, out int? errCount, string sourcePhysicalPath)
        {
            try
            {
                StringBuilder errorMsg = new StringBuilder(); // 错误信息
                List<CoursematerialView> errList = new List<CoursematerialView>();

                // 1.1解析文件，存放到一个List集合里
                cellheader.Remove("ErrorMessage");//移除“未导入原因”列(ErrorMessage)
                List<CoursematerialView> enlist = NpoiExcelHelper.ExcelToEntityList<CoursematerialView>(cellheader, sourcePhysicalPath, out errorMsg, out errList);
                cellheader.Add("ErrorMessage", "未导入原因");

                //对List集合进行有效性校验
                if (enlist.Count() <= 0)
                {
                    throw new Exception("Excel文件数据为空，请检查。");
                }

                Regex reg = null; //正则表达式
                //DateTime result; //用于返回判断日期字段格式
                //bool isListPass = true; //List判断标识
                inCount = 0; //导入个数
                upCount = 0; //更新个数
                errCount = 0; //失败个数
                string errorMsgStr = ""; //错误信息

                List<EM_Coursematerial> newCoursematerialInList = new List<EM_Coursematerial>();
                List<EM_Coursematerial> newCoursematerialUpList = new List<EM_Coursematerial>();

                //将循环中相关数据库查询统一查询出来进行匹配(尽量避免在循环中进行数据库查询)
                //课程信息
                var courseList = CoursematerialDAL.CoursematerialRepository.GetList(x => true).ToList();
                //课程代码
                var courseCodeList = enlist.Where(x => !string.IsNullOrWhiteSpace(x.CourseCode)).Select(x => x.CourseCode.Trim()).ToList();
                //课程名称
                var courseNameList = enlist.Where(x => !string.IsNullOrWhiteSpace(x.CourseName)).Select(x => x.CourseName.Trim()).ToList();
                //对比后的newCourseList
                var newCourseList = courseList.Where(x => courseCodeList.Contains(x.CourseCode) || courseNameList.Contains(x.CourseName)).ToList();
                //课程级别
                var courseLevelList = IdNameExt.GetDictionaryItem(DictionaryItem.CF_CourseLevel).ToList();
                //课程科类
                var courseScienceList = IdNameExt.GetDictionaryItem(DictionaryItem.CF_CourseScience).ToList();
                //上课类型信息
                var classGroupingList = CoursematerialDAL.ClassGroupingRepository.GetList(x => true).ToList();
                //上课类型
                var classNameList = enlist.Where(x => !string.IsNullOrWhiteSpace(x.ClassName)).Select(x => x.ClassName.Trim()).ToList();
                //对比后的newClassGroupingList
                var newClassGroupingList = classGroupingList.Where(x => classNameList.Contains(x.ClassName)).ToList();
                //是否启用
                var generalPurposeList = IdNameExt.GetDictionaryItem(DictionaryItem.CF_GeneralPurpose).ToList();

                //循环检测数据列,对各数据列进行验证（必填、字典项验证、数据格式等）
                for (int i = 0; i < enlist.Count; i++)
                {
                    CoursematerialView en = enlist[i]; //Excel表数据视图
                    EM_Coursematerial newCoursematerial = new EM_Coursematerial();

                    //课程代码
                    if (string.IsNullOrWhiteSpace(en.CourseCode))
                    {
                        errCount++;
                        errorMsgStr = "课程代码不能为空";
                        en.ErrorMessage = errorMsgStr;
                        errList.Add(en);
                        errorMsg.AppendLine(errorMsgStr);
                        continue;
                    }
                    else
                    {
                        reg = new Regex(@"^[0-9a-zA-Z\s?]+$"); //正则表达式(请输入数字或英文字母)
                        if (!reg.IsMatch(en.CourseCode.Trim()))
                        {
                            errCount++;
                            errorMsgStr = "课程代码格式不正确，请检查(数字或英文字母)";
                            en.ErrorMessage = errorMsgStr;
                            errList.Add(en);
                            errorMsg.AppendLine(errorMsgStr);
                            continue;
                        }
                        else
                        {
                            //课程代码
                            newCoursematerial.CourseCode = en.CourseCode.Trim();
                        }
                    }
                    //课程名称
                    if (string.IsNullOrWhiteSpace(en.CourseName))
                    {
                        errCount++;
                        errorMsgStr = "课程名称不能为空";
                        en.ErrorMessage = errorMsgStr;
                        errList.Add(en);
                        errorMsg.AppendLine(errorMsgStr);
                        continue;
                    }
                    else
                    {
                        //课程名称
                        newCoursematerial.CourseName = en.CourseName.Trim();
                    }
                    //课程简称
                    if (string.IsNullOrWhiteSpace(en.Abbreviation))
                    {
                        //默认
                        newCoursematerial.Abbreviation = en.CourseName.Trim();
                    }
                    else
                    {
                        newCoursematerial.Abbreviation = en.Abbreviation.Trim();
                    }
                    //英文名称
                    if (string.IsNullOrWhiteSpace(en.EnglishName))
                    {
                        //暂不考虑
                    }
                    else
                    {
                        newCoursematerial.EnglishName = en.EnglishName.Trim();
                    }
                    //课程规范名
                    if (string.IsNullOrWhiteSpace(en.StandardName))
                    {
                        //默认
                        newCoursematerial.StandardName = en.CourseName.Trim();
                    }
                    else
                    {
                        newCoursematerial.StandardName = en.StandardName.Trim();
                    }
                    //课程版本
                    if (string.IsNullOrWhiteSpace(en.CourseEdition))
                    {
                        //暂不考虑
                    }
                    else
                    {
                        newCoursematerial.CourseEdition = en.CourseEdition.Trim();
                    }
                    //课程级别
                    if (string.IsNullOrWhiteSpace(en.CourseLevelStr))
                    {
                        //暂不考虑
                    }
                    else
                    {
                        var courseLevel = courseLevelList.Where(x => x.Name == en.CourseLevelStr.Trim()).SingleOrDefault();
                        if (courseLevel == null)
                        {
                            errCount++;
                            errorMsgStr = "课程级别不存在，请检查";
                            en.ErrorMessage = errorMsgStr;
                            errList.Add(en);
                            errorMsg.AppendLine(errorMsgStr);
                            continue;
                        }
                        else
                        {
                            //课程级别
                            newCoursematerial.CourseLevelID = courseLevel.Value;
                        }
                    }
                    //课程科类
                    if (string.IsNullOrWhiteSpace(en.CourseScienceStr))
                    {
                        //暂不考虑
                    }
                    else
                    {
                        var courseScience = courseScienceList.Where(x => x.Name == en.CourseScienceStr.Trim()).SingleOrDefault();
                        if (courseScience == null)
                        {
                            errCount++;
                            errorMsgStr = "课程科类不存在，请检查";
                            en.ErrorMessage = errorMsgStr;
                            errList.Add(en);
                            errorMsg.AppendLine(errorMsgStr);
                            continue;
                        }
                        else
                        {
                            //课程科类
                            newCoursematerial.CourseScienceID = courseScience.Value;
                        }
                    }
                    //上课类型
                    if (string.IsNullOrWhiteSpace(en.ClassName))
                    {
                        //暂不考虑
                    }
                    else
                    {
                        var classGrouping = newClassGroupingList.Where(x => x.ClassName == en.ClassName.Trim()).SingleOrDefault();
                        if (classGrouping == null)
                        {
                            errCount++;
                            errorMsgStr = "上课类型不存在，请检查";
                            en.ErrorMessage = errorMsgStr;
                            errList.Add(en);
                            errorMsg.AppendLine(errorMsgStr);
                            continue;
                        }
                        else
                        {
                            //上课类型ID
                            newCoursematerial.ClassGroupingID = classGrouping.ClassGroupingID;
                        }
                    }
                    //课程简介
                    if (string.IsNullOrWhiteSpace(en.CourseSynopsis))
                    {
                        //暂不考虑
                    }
                    else
                    {
                        newCoursematerial.CourseSynopsis = en.CourseSynopsis.Trim();
                    }
                    //预修课程集
                    if (string.IsNullOrWhiteSpace(en.CourseReserve))
                    {
                        //暂不考虑
                    }
                    else
                    {
                        newCoursematerial.CourseReserve = en.CourseReserve.Trim();
                    }
                    //是否启用
                    if (string.IsNullOrWhiteSpace(en.IsEnableStr))
                    {
                        errCount++;
                        errorMsgStr = "是否启用不能为空";
                        en.ErrorMessage = errorMsgStr;
                        errList.Add(en);
                        errorMsg.AppendLine(errorMsgStr);
                        continue;
                    }
                    else
                    {
                        var generalPurpose = generalPurposeList.Where(x => x.Name == en.IsEnableStr.Trim()).SingleOrDefault();
                        if (generalPurpose == null)
                        {
                            errCount++;
                            errorMsgStr = "是否启用不存在，请检查";
                            en.ErrorMessage = errorMsgStr;
                            errList.Add(en);
                            errorMsg.AppendLine(errorMsgStr);
                            continue;
                        }
                        else
                        {
                            //是否启用
                            newCoursematerial.IsEnable = generalPurpose.Value == (int)CF_GeneralPurpose.IsYes ? true : false;
                        }
                    }
                    //备注
                    if (string.IsNullOrWhiteSpace(en.Remark))
                    {
                        //不考虑
                    }
                    else
                    {
                        newCoursematerial.Remark = en.Remark.Trim();
                    }

                    ////Excel表重复性验证（注：当数据表中没有此记录，但是Excel中有重复数据时的去掉）
                    //for (int j = i + 1; j < enlist.Count; j++)
                    //{
                    //    CoursematerialView enA = enlist[j];

                    //    //根据Excel表中的业务主键进行去重（课程代码唯一）
                    //    if (en.No == enA.No && en.Name == enA.Name)
                    //    {
                    //        //用于标识Excel表中的重复记录（由于是批量进行插入数据表）

                    //    }
                    //}

                    //数据表重复性验证（课程代码唯一）
                    var courseCodeVerify = newCourseList.Where(x => x.CourseCode == newCoursematerial.CourseCode).SingleOrDefault();
                    if (courseCodeVerify == null)
                    {
                        //新增
                        if (!newCoursematerialInList.Any(x => x.CourseCode == newCoursematerial.CourseCode))
                        {
                            newCoursematerial.CoursematerialID = Guid.NewGuid();
                            SetNewStatus(newCoursematerial);
                            newCoursematerialInList.Add(newCoursematerial);
                            inCount++;
                        }
                        else
                        {
                            //Excel表重复性验证
                            //（注：当数据表中没有此记录，但是Excel中有重复数据,可在此处进行抛出到失败数据文件中,目前暂不考虑）
                            inCount++;
                        }
                    }
                    else
                    {
                        //更新(Excel有重复时，以最后一条记录的更新为准)
                        //courseCodeVerify.CourseCode = newCoursematerial.CourseCode;
                        courseCodeVerify.CourseName = newCoursematerial.CourseName;
                        courseCodeVerify.Abbreviation = newCoursematerial.Abbreviation;
                        courseCodeVerify.EnglishName = newCoursematerial.EnglishName;
                        courseCodeVerify.StandardName = newCoursematerial.StandardName;
                        courseCodeVerify.CourseEdition = newCoursematerial.CourseEdition;
                        courseCodeVerify.CourseLevelID = newCoursematerial.CourseLevelID;
                        courseCodeVerify.CourseScienceID = newCoursematerial.CourseScienceID;
                        courseCodeVerify.ClassGroupingID = newCoursematerial.ClassGroupingID;
                        courseCodeVerify.CourseSynopsis = newCoursematerial.CourseSynopsis;
                        courseCodeVerify.CourseReserve = newCoursematerial.CourseReserve;
                        courseCodeVerify.IsEnable = newCoursematerial.IsEnable;
                        courseCodeVerify.Remark = newCoursematerial.Remark;
                        SetModifyStatus(courseCodeVerify);
                        newCoursematerialUpList.Add(courseCodeVerify);
                        upCount++;
                    }
                }
                //批量插入
                UnitOfWork.BulkInsert(newCoursematerialInList);
                //批量统一提交更新
                if (newCoursematerialUpList != null && newCoursematerialUpList.Count() > 0)
                {
                    UnitOfWork.BatchUpdate(newCoursematerialUpList);
                }
                errdataList = errList.Distinct().ToList(); //错误列表List
            }
            catch (Exception)
            {
                throw;
            }
        }

    }
}