JW/ServiceLogic/EMIS.CommonLogic/DegreeManage/DegreeSetting/DegreeConditionServices.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;
using Bowin.Common.Linq.Entity;
using Bowin.Common.Linq;
using EMIS.ViewModel;
using EMIS.Entities;
using EMIS.ViewModel.DegreeManage.DegreeSetting;
using EMIS.DataLogic.DegreeManage.DegreeSetting;
using EMIS.DataLogic.GraduationManage.GraduationSetting;
using EMIS.CommonLogic.ScoreManage.LevelScoreManage;
using EMIS.CommonLogic.SystemServices;

namespace EMIS.CommonLogic.DegreeManage.DegreeSetting
{
    public class DegreeConditionServices : BaseServices, IDegreeConditionServices
    {
        public DegreeConditionDAL DegreeConditionDAL { get; set; }
        public Lazy<GraduationConditionDAL> GraduationConditionDAL { get; set; }
        public Lazy<IParameterServices> ParameterServices { get; set; }
        public Lazy<ILevelScoreServices> LevelScoreServices { get; set; }

        /// <summary>
        /// 查询学位条件信息View
        /// </summary>
        /// <param name="configuretView"></param>
        /// <param name="isCurrent"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        public IGridResultSet<DegreeConditionView> GetDegreeConditionViewGrid(ConfiguretView configuretView, int? isCurrent, int pageIndex, int pageSize)
        {
            //学位条件
            Expression<Func<ER_DegreeCondition, bool>> exp = (x => true);
            if (isCurrent.HasValue)
            {
                if (isCurrent == 1)
                {
                    exp = exp.And(x => x.RecordStatus >= (int)SYS_STATUS.USABLE);
                }
                if (isCurrent == 0)
                {
                    exp = exp.And(x => x.RecordStatus <= (int)SYS_STATUS.UNUSABLE);
                }
            }

            var query = DegreeConditionDAL.GetDegreeConditionViewQueryable(exp);

            //查询条件
            if (!string.IsNullOrEmpty(configuretView.ConditionValue))
            {
                query = query.DynamicWhere(configuretView.Attribute, configuretView.Condition, configuretView.ConditionValue.Trim());
            }

            return query.OrderBy(x => x.OrderNo).ToGridResultSet<DegreeConditionView>(pageIndex, pageSize);
        }

        /// <summary>
        /// 查询学位条件信息List
        /// </summary>
        /// <param name="configuretView"></param>
        /// <param name="isCurrent"></param>
        /// <returns></returns>
        public List<DegreeConditionView> GetDegreeConditionViewList(ConfiguretView configuretView, int? isCurrent)
        {
            //学位条件
            Expression<Func<ER_DegreeCondition, bool>> exp = (x => true);
            if (isCurrent.HasValue)
            {
                if (isCurrent == 1)
                {
                    exp = exp.And(x => x.RecordStatus >= (int)SYS_STATUS.USABLE);
                }
                if (isCurrent == 0)
                {
                    exp = exp.And(x => x.RecordStatus <= (int)SYS_STATUS.UNUSABLE);
                }
            }

            var query = DegreeConditionDAL.GetDegreeConditionViewQueryable(exp);

            //查询条件
            if (!string.IsNullOrEmpty(configuretView.ConditionValue))
            {
                query = query.DynamicWhere(configuretView.Attribute, configuretView.Condition, configuretView.ConditionValue.Trim());
            }

            return query.OrderBy(x => x.OrderNo).ToList();
        }

        /// <summary>
        /// 根据学位条件ID查询对应学位条件DegreeConditionView
        /// </summary>
        /// <param name="DegreeConditionID"></param>
        /// <returns></returns>
        public DegreeConditionView GetDegreeConditionView(Guid? DegreeConditionID)
        {
            try
            {
                var query = DegreeConditionDAL.GetDegreeConditionViewQueryable(x => x.DegreeConditionID == DegreeConditionID).SingleOrDefault();

                return query;
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

        /// <summary>
        /// 编辑
        /// </summary>
        /// <param name="degreeConditionView"></param>
        public void DegreeConditionEdit(DegreeConditionView degreeConditionView)
        {
            try
            {
                //查询数据库进行验证
                var degreeConditionVerify = DegreeConditionDAL.DegreeConditionRepository.GetList(x => x.DegreeConditionID != degreeConditionView.DegreeConditionID && x.Title == degreeConditionView.Title).SingleOrDefault();
                if (degreeConditionVerify == null)
                {
                    //数据有误验证
                    if (degreeConditionView.DegreeConditionID != Guid.Empty)
                    {
                        var degreeCondition = DegreeConditionDAL.DegreeConditionRepository.GetList(x => x.DegreeConditionID == degreeConditionView.DegreeConditionID).SingleOrDefault();
                        if (degreeCondition == null)
                        {
                            throw new Exception("数据有误，请核查");
                        }
                        else
                        {
                            //表示修改
                            degreeCondition.OrderNo = (short?)degreeConditionView.OrderNo;
                            degreeCondition.Title = degreeConditionView.Title;
                            degreeCondition.RecordStatus = degreeConditionView.IsEnable ? (int)SYS_STATUS.USABLE : (int)SYS_STATUS.UNUSABLE;
                            SetModifyStatus(degreeCondition);
                        }
                    }
                    else
                    {
                        //表示新增
                        ER_DegreeCondition degreeCondition = new ER_DegreeCondition();
                        degreeCondition.DegreeConditionID = Guid.NewGuid();
                        degreeCondition.OrderNo = (short?)degreeConditionView.OrderNo;
                        degreeCondition.Title = degreeConditionView.Title;
                        degreeCondition.MethodFullName = degreeConditionView.MethodFullName;
                        SetNewStatus(degreeCondition);
                        UnitOfWork.Add(degreeCondition);
                    }
                }
                else
                {
                    throw new Exception("已存在相同条件名称的学位条件，请核查");
                }
                //事务提交
                UnitOfWork.Commit();
            }
            catch (Exception ex)
            {

                throw new Exception(ex.Message);
            }
        }

        /// <summary>
        /// 无条件
        /// </summary>
        /// <param name="userID"></param>
        /// <returns></returns>
        public string NoCondition(Guid? userID)
        {
            return "Pass";
        }

        /// <summary>
        /// 毕业审核通过（此处毕业审核通过表示学生信息中在校状态为毕业）
        /// </summary>
        /// <param name="userID"></param>
        /// <returns></returns>
        public string GraduationApprovePass(Guid? userID)
        {
            try
            {
                //查询对应的学生信息
                var student = DegreeConditionDAL.StudentRepository.GetList(x => x.UserID == userID).SingleOrDefault();
                if (student == null)
                {
                    return "数据有误，请核查";
                }
                else
                {
                    if (student.InSchoolStatusID != (int)CF_InschoolStatus.Graduation)
                    {
                        return "毕业审核未通过";
                    }
                }
                return "Pass";
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

        /// <summary>
        /// 毕业设计（论文）成绩通过(匹配配置信息表--优、良，通常大于等于80分)
        /// 注：成绩类型明细划分
        /// 小于60-不及格、大于等于60且小于70-及格、大于等于70且小于80-中等、大于等于80且小于90-良好、大于等于90优秀以上
        /// </summary>
        /// <param name="userID"></param>
        /// <returns></returns>
        public string GraduateDesignCoursePass(Guid? userID)
        {
            try
            {
                var degreeGraDesignCoursePassScore = ParameterServices.Value.GetParameterValue(CF_ParameterType.DegreeGraDesignCoursePass);
                if (string.IsNullOrEmpty(degreeGraDesignCoursePassScore))
                {
                    throw new Exception("未设置学位审核毕设成绩通过分数，请设置。");
                }
                //学生信息
                Expression<Func<CF_Student, bool>> expStudent = (x => x.RecordStatus > (int)SYS_STATUS.UNUSABLE);
                expStudent = expStudent.And(x => x.UserID == userID);
                //查询对应的毕业设计课程信息List
                var graduateDesignCourseList = GraduationConditionDAL.Value.GraduateDesignCoursematerialRepository.GetList(x => x.RecordStatus > (int)SYS_STATUS.UNUSABLE).ToList();
                if (graduateDesignCourseList == null || graduateDesignCourseList.Count() <= 0)
                {
                    return "未设置毕业设计课程，请设置";
                }
                //查询对应的毕业设计课程成绩信息List
                var graduateDesignCourseViewList = GraduationConditionDAL.Value.GetGraduateDesignCourseViewQueryable(expStudent).ToList();
                if (graduateDesignCourseViewList == null || graduateDesignCourseViewList.Count() <= 0)
                {
                    return "毕设成绩未录入";
                }
                foreach (var graduateDesignCourseView in graduateDesignCourseViewList)
                {
                    if (graduateDesignCourseView.TotalScore < Convert.ToDecimal(degreeGraDesignCoursePassScore))
                    {
                        return "毕设成绩未达优、良以上";
                    }
                }
                return "Pass";
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

        /// <summary>
        /// 学位外语考试通过(匹配配置信息表--学位外语设置信息表)
        /// </summary>
        /// <param name="userID"></param>
        /// <returns></returns>
        public string DegreeForeignLanguagePass(Guid? userID)
        {
            try
            {
                //查询对应的学位外语设置信息
                var degreeForeignLanguage = DegreeConditionDAL.DegreeForeignLanguageRepository.GetList(x => x.RecordStatus > (int)SYS_STATUS.UNUSABLE).SingleOrDefault();
                if (degreeForeignLanguage == null)
                {
                    return "学位外语设置信息未设置，请设置";
                }
                else
                {
                    if (degreeForeignLanguage.PassScore == null)
                    {
                        return "学位外语成绩通过分数为空，请设置";
                    }
                }
                var levelScorePassStatus = LevelScoreServices.Value.GetCorrectEndStatus();
                if (levelScorePassStatus == null)
                {
                    throw new Exception("工作流平台中，科目成绩录入流程结束环节未配置，请核查。");
                }
                //学生信息
                Expression<Func<CF_Student, bool>> expStudent = (x => x.RecordStatus > (int)SYS_STATUS.UNUSABLE);
                expStudent = expStudent.And(x => x.UserID == userID);
                //查询对应的学位外语成绩信息List
                var degreeForeignLanguageViewList = DegreeConditionDAL.GetDegreeForeignLanguageScoreViewQueryable(expStudent).ToList();
                if (degreeForeignLanguageViewList == null || degreeForeignLanguageViewList.Count() <= 0)
                {
                    return "学位外语成绩未录入";
                }
                else
                {
                    degreeForeignLanguageViewList = degreeForeignLanguageViewList.Where(x => x.ApprovalStatus == levelScorePassStatus).ToList();
                    if (degreeForeignLanguageViewList == null || degreeForeignLanguageViewList.Count() <= 0)
                    {
                        return "学位外语成绩未进行审核";
                    }
                    else if (degreeForeignLanguageViewList.Count() > 1)
                    {
                        return "存在多门审核通过的学位外语成绩";
                    }
                    else
                    {
                        var degreeForeignLanguageView = degreeForeignLanguageViewList.Where(x => true).SingleOrDefault();
                        if (degreeForeignLanguageView.TotalScore < degreeForeignLanguage.PassScore)
                        {
                            return "学位外语成绩未通过";
                        }
                        return "Pass";
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

        /// <summary>
        /// 学位课成绩平均分通过(通常不低于75分)
        /// </summary>
        /// <param name="userID"></param>
        /// <returns></returns>
        public string DegreeCourseAvgPass(Guid? userID)
        {
            try
            {
                var degreeDegCourseAvgPassScore = ParameterServices.Value.GetParameterValue(CF_ParameterType.DegreeDegCourseAvgPass);
                if (string.IsNullOrEmpty(degreeDegCourseAvgPassScore))
                {
                    throw new Exception("未设置学位审核学位课成绩平均分通过分数，请设置。");
                }

                //学生信息
                Expression<Func<CF_Student, bool>> expStudent = (x => x.RecordStatus > (int)SYS_STATUS.UNUSABLE);
                expStudent = expStudent.And(x => x.UserID == userID);

                //查询对应的学生学位课程执行计划信息List
                var studentExecutablePlanViewList = DegreeConditionDAL
                        .GetStudentDegreeCourseExecutablePlanViewQueryable(expStudent).ToList();
                if (studentExecutablePlanViewList == null || studentExecutablePlanViewList.Count() <= 0)
                {
                    return "执行计划中学位课信息为空，请检查";
                }

                //查询对应的学生学位课程最终成绩信息List
                var studentDegreeCourseScoreViewList = DegreeConditionDAL
                        .GetDegreeCourseFinallyScoreExecutablePlanViewQueryable(expStudent).ToList();
                if (studentDegreeCourseScoreViewList == null || studentDegreeCourseScoreViewList.Count() <= 0)
                {
                    return "学位课成绩未录入";
                }
                else
                {
                    decimal? degreeDegCourseAvg = 0;
                    var studentDegreeCourseGroupList = studentDegreeCourseScoreViewList.GroupBy(x => x.UserID).ToList();
                    foreach (var studentDegreeCourseGroup in studentDegreeCourseGroupList)
                    {
                        degreeDegCourseAvg = studentDegreeCourseGroup.Average(x => x.TotalScore);
                        if (degreeDegCourseAvg < Convert.ToDecimal(degreeDegCourseAvgPassScore))
                        {
                            return "学位平均分低于" + degreeDegCourseAvgPassScore 
                                    + "分（" + Math.Round(degreeDegCourseAvg.Value, 1).ToString() 
                                    + "分）";
                        }
                    }
                }

                return "Pass";
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

        /// <summary>
        /// 补考需及格且门数符合要求(通常门数为小于4门)
        /// </summary>
        /// <param name="userID"></param>
        /// <returns></returns>
        public string ResitScoreComplete(Guid? userID)
        {
            try
            {
                var degreeResitLessThanNum = ParameterServices.Value.GetParameterValue(CF_ParameterType.DegreeResitLessThanNum);
                if (string.IsNullOrEmpty(degreeResitLessThanNum))
                {
                    throw new Exception("未设置学位审核补考小于门数，请设置。");
                }

                //学生信息
                Expression<Func<CF_Student, bool>> expStudent = (x => x.RecordStatus > (int)SYS_STATUS.UNUSABLE);
                expStudent = expStudent.And(x => x.UserID == userID);

                //查询对应的学生补考成绩信息List（暂时只查询补考一、毕业前补考，后期考虑根据配置表定义补考）
                var studentResitScoreViewList = GraduationConditionDAL.Value
                        .GetFinallyScoreViewQueryable(expStudent)
                        .Where(x => x.ExamsCategoryID == (int)CF_ExamsCategory.Resit 
                                || x.ExamsCategoryID == (int)CF_ExamsCategory.GraduationExam).ToList();
                if (studentResitScoreViewList != null && studentResitScoreViewList.Count() > 0)
                {
                    if (studentResitScoreViewList.Count() >= Convert.ToInt32(degreeResitLessThanNum))
                    {
                        return "补考门数未小于" + degreeResitLessThanNum
                                + "门（补考" + studentResitScoreViewList.Count().ToString()
                                + "门）";
                    }
                    else
                    {
                        foreach (var studentResitScoreView in studentResitScoreViewList)
                        {
                            if (studentResitScoreView.TotalScore < 60)
                            {
                                return studentResitScoreView.CourseName + "未及格（" 
                                        + studentResitScoreView.StarttermName + "," 
                                        + studentResitScoreView.ExamsCategoryName + "）";
                            }
                        }
                    }
                }

                return "Pass";
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

    }
}