示例#1
0
        /// <summary>
        /// 作者:Raymond
        /// 日期:2014-5-13
        /// 描述:更新合同信息、合同明细、合同级别
        /// -----------------------------------
        /// 更新:Vincen
        /// 时间:2014.06.11
        /// ------------------------------------
        /// 更新:Ark
        /// 时间:2014.08.06
        /// 描述:参数加userId,单个ContractDetail修改为多个
        /// </summary>
        /// <param name="contract"></param>
        /// <param name="userId"></param>
        /// <param name="productIds"></param>
        /// <param name="emeLevels"></param>
        /// <param name="currentLevels"></param>
        /// <param name="contractTypes"></param>
        /// <param name="contractStatuType"></param>
        /// <returns></returns>
        public static bool UpdateContract(Contract contract, int userId, List<int> productIds, List<string> emeLevels, List<int> currentLevels, List<int> contractTypes, int contractStatuType, int loginUserId)
        {
            try
            {
                using (var edb = new EmeEntities())
                {
                    using (var tran = new TransactionScope())
                    {
                        //重新获取对象
                        var contractObj = edb.Contract.FirstOrDefault(p => p.Id == contract.Id);
                        var detailList = edb.ContractDetail.Where(p => p.ContractId == contract.Id).ToList();
                        var detailIds = detailList.Select(d => d.Id).ToList();
                        var contractLevelList = edb.ContractLevel.Where(l => detailIds.Contains(l.ContractDetailId)).ToList();

                        #region 合同状态无效合同相关修改为无效(直接返回)

                        if (contract.Status != ConvertEnum.StatusTypeForActive)
                        {
                            contractObj.Status = contract.Status;
                            contractObj.UpdateBy = contract.UpdateBy;
                            contractObj.UpdateTime = contract.UpdateTime;

                            // 合同明细状态修改为无效
                            foreach (var detail in detailList)
                            {
                                detail.Status = contract.Status;
                                detail.UpdateBy = contract.UpdateBy;
                                detail.UpdateTime = contract.UpdateTime;
                            }
                            // 同时对应的合同级别 ContractLevel 状态修改为无效
                            foreach (var levelItem in contractLevelList)
                            {
                                levelItem.Status = contract.Status;
                                levelItem.UpdateBy = contract.UpdateBy;
                                levelItem.UpdateTime = contract.UpdateTime;
                            }

                            edb.SaveChanges();
                            tran.Complete();
                            return true;  // 直接返回
                        }

                        #endregion
                        #region 1。修改合同

                        if (contractObj != null)
                        {
                            contractObj.CrmContractId = contract.CrmContractId;
                            contractObj.StudentId = contract.StudentId;
                            contractObj.ContractNum = contract.ContractNum;
                            contractObj.Status = contract.Status;
                            contractObj.BeginDate = contract.BeginDate;
                            contractObj.EndDate = contract.EndDate;
                            contractObj.UpdateBy = contract.UpdateBy;
                            contractObj.UpdateTime = contract.UpdateTime;
                            contractObj.Status = contract.Status;

                            edb.Entry(contractObj).State = EntityState.Modified;
                        }

                        #endregion
                        #region 2。合同明细及合同级别状态修改为无效

                        // 合同明细状态修改为无效
                        foreach (var detail in detailList)
                        {
                            detail.Status = ConvertEnum.StatusTypeForInactive;
                            detail.UpdateBy = contract.UpdateBy;
                            detail.UpdateTime = contract.UpdateTime;
                        }
                        // 同时对应的合同级别 ContractLevel 状态修改为无效
                        foreach (var levelItem in contractLevelList)
                        {
                            levelItem.IsCurrent = false;
                            levelItem.Status = ConvertEnum.StatusTypeForInactive;
                            levelItem.UpdateBy = contract.UpdateBy;
                            levelItem.UpdateTime = contract.UpdateTime;
                        }

                        edb.SaveChanges();

                        #endregion
                        #region 3。同步Crm合同明细及合同级别

                        int contractType;
                        ContractDetail contractDetail = null;
                        int productId;
                        //是否vip
                        var isVip = false;
                        int[] levels;
                        var userBranch = UserBLL.GetUserBranch(userId, true);

                        for (int i = 0; i < productIds.Count; i++)
                        {
                            // 主修课时总数
                            int majorTotal = 0;
                            // 选修课时总数
                            int electiveTotal = 0;
                            productId = productIds[i];
                            contractType = contractTypes[i];
                            contractDetail = detailList.FirstOrDefault(d => d.ProductId == productId);
                            levels = Array.ConvertAll<string, int>(emeLevels[i].Trim().Trim(',').Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries),
                                delegate(string s) { return int.Parse(s); });

                            // 此合同明细(产品)存在修改,不存在新增
                            if (null != contractDetail)
                            {
                                var product = edb.Product.FirstOrDefault(p => p.Id == productId);

                                // 获取是否Vip学员,通过产品表Product的IsVip
                                if (null != product)
                                    isVip = product.IsVip;

                                contractDetail.IsVip = isVip;
                                contractDetail.ContractTypeId = contractType;
                                contractDetail.BeginDate = contract.BeginDate;
                                contractDetail.EndDate = contract.EndDate;
                                contractDetail.ContractStatusType = contractStatuType;
                                contractDetail.Status = contract.Status;

                                #region 合同级别

                                foreach (var level in levels)
                                {
                                    // 是否当前级别
                                    var curlevel = (level == currentLevels[i]);
                                    // 合同类型级别(定义主修、选修总课时)
                                    var ctpl = GetContractTypeProductLevel(userBranch.BranchId, contractType, level); // 此处 userBranch.Id 改为 userBranch.BranchId
                                    var repairTotal = ctpl.Repair;
                                    var absenceTotal = ctpl.Absence;
                                    majorTotal += ctpl.MajorTotal;
                                    electiveTotal += ctpl.ElectiveTotal;
                                    var contractLevel = contractLevelList.FirstOrDefault(l => l.ProductLevelId == level);

                                    if (null != contractLevel)
                                    {
                                        contractLevel.IsCurrent = curlevel;
                                        contractLevel.MajorTotal = ctpl.MajorTotal;
                                        contractLevel.ElectiveTotal = ctpl.ElectiveTotal;
                                        contractLevel.RepairTotal = repairTotal;
                                        contractLevel.AbsenceTotal = absenceTotal;
                                        contractLevel.Status = contract.Status;
                                    }
                                    else
                                    {
                                        contractLevel = new ContractLevel()
                                        {
                                            ContractDetailId = contractDetail.Id,
                                            ProductLevelId = level,
                                            IsCurrent = curlevel,
                                            RepairTotal = repairTotal,
                                            AbsenceTotal = absenceTotal,
                                            MajorTotal = ctpl.MajorTotal,           // 主修总课时
                                            ElectiveTotal = ctpl.ElectiveTotal,     // 选修总课时
                                            Status = contract.Status,
                                            CreateBy = contract.CreateBy,
                                            CreateTime = contract.CreateTime,
                                        };
                                        edb.Entry(contractLevel).State = EntityState.Added;
                                    }
                                }

                                #endregion

                                // 修改主选修课时总数
                                contractDetail.MajorTotal = majorTotal;
                                contractDetail.ElectiveTotal = electiveTotal;
                                edb.SaveChanges();
                            }
                            else
                            {
                                // 新增
                                contractDetail = new ContractDetail()
                                {
                                    ContractId = contract.Id,
                                    ContractTypeId = contractType,
                                    ProductId = productId,
                                    MajorTotal = 0,        // 添加时默认0,添加级别后修改
                                    ElectiveTotal = 0,
                                    IsVip = isVip,
                                    BeginDate = contract.BeginDate,
                                    EndDate = contract.EndDate,
                                    IsLimitBook = false,
                                    AllowUnBookTimes = 0,
                                    ContractStatusType = contractStatuType,
                                    Status = contract.Status,
                                    CreateBy = contract.CreateBy,
                                    CreateTime = contract.CreateTime
                                };
                                edb.Entry(contractDetail).State = EntityState.Added;
                                edb.SaveChanges();

                                #region 合同级别

                                foreach (var level in levels)
                                {
                                    // 合同类型级别(定义主修、选修总课时)
                                    var ctpl = GetContractTypeProductLevel(userBranch.BranchId, contractType, level); // 此处 userBranch.Id 改为 userBranch.BranchId
                                    var repairTotal = ctpl.Repair;
                                    var absenceTotal = ctpl.Absence;
                                    majorTotal += ctpl.MajorTotal;
                                    electiveTotal += ctpl.ElectiveTotal;
                                    // 是否当前级别
                                    var curlevel = (level == currentLevels[i]);

                                    var contractLevel = new ContractLevel()
                                    {
                                        ContractDetailId = contractDetail.Id,
                                        ProductLevelId = level,
                                        IsCurrent = curlevel,
                                        RepairTotal = repairTotal,
                                        AbsenceTotal = absenceTotal,
                                        MajorTotal = ctpl.MajorTotal,           // 主修总课时
                                        ElectiveTotal = ctpl.ElectiveTotal,     // 选修总课时
                                        Status = contract.Status,
                                        CreateBy = contract.CreateBy,
                                        CreateTime = contract.CreateTime,
                                    };
                                    edb.Entry(contractLevel).State = EntityState.Added;
                                }

                                // 修改合同明细主先修课时总数
                                contractDetail.MajorTotal = majorTotal;
                                contractDetail.ElectiveTotal = electiveTotal;

                                #endregion
                            }
                        }

                        edb.SaveChanges();
                        tran.Complete();
                        return true;

                        #endregion
                    }
                }
            }
            catch (Exception e)
            {
                // 异常日志消息队列
                Common.MSMQ.QueueManager.AddExceptionLog(new ExceptionLogs()
                {
                    ExceptionType = CommonHelper.To<int>(ExceptionType.Function),
                    Message = string.Format("StudentBLL-UpdateContract:{0};{1};{2}", e.Message, e.InnerException.Message, e.HelpLink),
                    IsTreat = false,
                    CreateBy = loginUserId,
                    CreateTime = DateTime.Now
                });

                return false;
            }
        }
示例#2
0
 /// <summary>
 /// 作者:Raymond
 /// 日期:2014-5-14
 /// 描述:新增合同级别
 /// </summary>
 /// <param name="model"></param>
 /// <returns></returns>
 public static bool CreateContractLevel(ContractLevel model)
 {
     Db.Entry(model).State = EntityState.Added;
     return Db.SaveChanges() > 0;
 }
示例#3
0
        /// <summary>
        /// 作者:Raymond
        /// 日期:2014-5-14
        /// 描述:新增合同、合同明细、合同级别
        /// ------------------------------------
        /// 更新:Vincen
        /// 时间:2014.06.11
        /// ------------------------------------
        /// 更新:Ark
        /// 时间:2014.08.06
        /// 描述:参数加userId,单个ContractDetail修改为多个,获取IsVip通过产品表
        /// </summary>
        /// <param name="contract"></param>
        /// <param name="userId"></param>
        /// <param name="productIds"></param>
        /// <param name="emeLevels"></param>
        /// <param name="currentLevels"></param>
        /// <param name="contractTypes"></param>
        /// <param name="contractStatuType"></param>
        /// <returns></returns>
        public static bool CreateContract(Contract contract, int userId, List<int> productIds, List<string> emeLevels, List<int> currentLevels, List<int> contractTypes, int contractStatuType)
        {
            try
            {
                using (var edb = new EmeEntities())
                {
                    using (var tran = new TransactionScope())
                    {
                        #region 新合同及合同明细、合同级别处理

                        // Step1.新增主合同
                        edb.Contract.Add(contract); // 重新定义Contract并赋值 改为 直接添加
                        edb.SaveChanges();

                        // Step2.合同明细对象
                        int contractType;
                        bool isVip = false;
                        ContractDetail detail = null;
                        UserBranch userBranch = UserBLL.GetUserBranch(userId, true);
                        int[] levels;

                        for (int i = 0; i < productIds.Count; i++)
                        {
                            levels = Array.ConvertAll<string, int>(emeLevels[i].Trim().Trim(',').Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries),
                                delegate(string s) { return int.Parse(s); });
                            contractType = contractTypes[i];

                            var productId = productIds[i];
                            var product = edb.Product.FirstOrDefault(p => p.Id == productId);

                            // 获取是否Vip学员,通过产品表Product的IsVip
                            if (null != product)
                                isVip = product.IsVip;
                            // 添加合同详情
                            detail = new ContractDetail()
                            {
                                ContractId = contract.Id,
                                ContractTypeId = contractType,
                                ProductId = productId,
                                MajorTotal = 0,        // 添加时默认0,添加级别后修改
                                ElectiveTotal = 0,
                                IsVip = isVip,
                                BeginDate = contract.BeginDate,
                                EndDate = contract.EndDate,
                                IsLimitBook = false,
                                AllowUnBookTimes = 0,
                                ContractStatusType = contractStatuType,
                                Status = contract.Status,
                                CreateBy = contract.CreateBy,
                                CreateTime = contract.CreateTime
                            };
                            edb.Entry(detail).State = EntityState.Added;
                            edb.SaveChanges();

                            // Step3.合同级别信息
                            // 获取此合同类型的主修课时总数,选修课时总数
                            // 主修课时总数
                            int majorTotal = 0;
                            // 选修课时总数
                            int electiveTotal = 0;

                            foreach (var level in levels)
                            {
                                // 合同类型级别(定义主修、选修总课时)
                                var ctpl = GetContractTypeProductLevel(userBranch.BranchId, contractType, level); // 此处 userBranch.Id 改为 userBranch.BranchId
                                var repairTotal = ctpl.Repair;
                                var absenceTotal = ctpl.Absence;
                                majorTotal += ctpl.MajorTotal;
                                electiveTotal += ctpl.ElectiveTotal;
                                // 是否当前级别
                                var curlevel = (level == currentLevels[i]);

                                var contractLevel = new ContractLevel()
                                {
                                    ContractDetailId = detail.Id,
                                    ProductLevelId = level,
                                    IsCurrent = curlevel,
                                    RepairTotal = repairTotal,
                                    AbsenceTotal = absenceTotal,
                                    MajorTotal = ctpl.MajorTotal,           // 主修总课时
                                    ElectiveTotal = ctpl.ElectiveTotal,     // 选修总课时
                                    Status = contract.Status,
                                    CreateBy = contract.CreateBy,
                                    CreateTime = contract.CreateTime,
                                };
                                edb.Entry(contractLevel).State = EntityState.Added;
                            }

                            // 修改合同明细主先修课时总数
                            detail.MajorTotal = majorTotal;
                            detail.ElectiveTotal = electiveTotal;

                            edb.SaveChanges();
                        }

                        #endregion

                        #region 合并老合同级别

                        ////判断是否有相同产品的有效级别,如果有就合并
                        //foreach (var oldL in oldLevelList)
                        //{
                        //    //合同级别状态设为无效
                        //    oldL.Status = ConvertEnum.StatusTypeForInactive;
                        //    var newL = new ContractLevel()
                        //    {
                        //        Status = ConvertEnum.StatusTypeForActive,
                        //        ContractDetailId = contractDetailId,
                        //        ProductLevelId = oldL.ProductLevelId,
                        //        IsCurrent = oldL.IsCurrent,
                        //        Online = oldL.Online,
                        //        Offline = oldL.Offline,
                        //        Total = oldL.Total,
                        //        Repair = oldL.Repair,
                        //        Absence = oldL.Absence,
                        //        StartStudyTime = oldL.StartStudyTime,
                        //        EndStudyTime = oldL.EndStudyTime,
                        //        CreateBy = oldL.CreateBy,
                        //        CreateTime = contract.CreateTime,
                        //    };
                        //    //新记录的状态为可用
                        //    edb.Entry(oldL).State = EntityState.Modified;
                        //    edb.Entry(newL).State = EntityState.Added;
                        //    edb.SaveChanges();
                        //}

                        #endregion

                        tran.Complete();
                        return true;
                    }
                }
            }
            catch (Exception e)
            {
                // 异常日志消息队列
                QueueManager.AddExceptionLog(new ExceptionLogs()
                {
                    ExceptionType = CommonHelper.To<int>(ExceptionType.Function),
                    Message = string.Format("StudentBLL-CreateContract:{0};{1};{2}", e.Message, e.InnerException.Message, e.HelpLink),
                    IsTreat = false,
                    CreateBy = contract.CreateBy,
                    CreateTime = DateTime.Now
                });

                return false;
            }
        }
示例#4
0
        /// <summary>
        /// beta
        /// 更新学员合同级别课时数信息
        /// 2015.01.30
        /// </summary>
        /// <param name="currContractLevelId"></param>
        /// <param name="studentId"></param>
        /// <param name="updateUser"></param>
        /// <returns></returns>
        //public static bool UpdateContractLevel(int currContractLevelId, int studentId,int onlineMajor,int offlineMajor, int updateUser)
        //{
        //    using (var edb = new EmeEntities())
        //    {
        //        try
        //        {
        //            //更新合同级别信息
        //            var contractLevelObj = edb.ContractLevel.FirstOrDefault(p => p.Id == currContractLevelId);
        //            if (null != contractLevelObj)
        //            {
        //                contractLevelObj.MajorOffline = offlineMajor;
        //                contractLevelObj.MajorOnline = onlineMajor;
        //                contractLevelObj.UpdateBy = updateUser;
        //                contractLevelObj.UpdateTime = DateTime.Now;
        //            }
        //            var result = edb.SaveChanges() > 0;
        //            return result;
        //        }
        //        catch (Exception e)
        //        {
        //            // 异常日志消息队列
        //            Common.MSMQ.QueueManager.AddExceptionLog(new ExceptionLogs()
        //            {
        //                ExceptionType = CommonHelper.To<int>(ExceptionType.Function),
        //                Message = string.Format("StudentBLL-UpdateContract:{0};{1};{2}", e.Message, e.InnerException.Message, e.HelpLink),
        //                IsTreat = false,
        //                CreateBy = updateUser,
        //                CreateTime = DateTime.Now
        //            });
        //            return false;
        //        }
        //    }
        //}
        public static bool UpdateContractLevel(ContractLevel contractLevel, int loginUserId)
        {
            using (var edb = new EmeEntities())
            {
                try
                {
                    var modelObj = edb.ContractLevel.FirstOrDefault(p => p.Id == contractLevel.Id);
                    if (null == modelObj)
                        return false;

                    modelObj.MajorOffline = contractLevel.MajorOffline;
                    modelObj.MajorOnline = contractLevel.MajorOnline;
                    modelObj.ElectiveOnline = contractLevel.ElectiveOnline;
                    modelObj.ElectiveOffline = contractLevel.ElectiveOffline;
                    modelObj.Absence = contractLevel.Absence;
                    modelObj.Repair = contractLevel.Repair;
                    modelObj.UpdateBy = loginUserId;
                    modelObj.UpdateTime = DateTime.Now;

                    edb.Entry(modelObj).State = EntityState.Modified;
                    var result = edb.SaveChanges() > 0;

                    return result;
                }
                catch (Exception e)
                {
                    Common.MSMQ.QueueManager.AddExceptionLog(new ExceptionLogs()
                    {
                        ExceptionType = CommonHelper.To<int>(ExceptionType.Message),
                        Message = string.Format("StudyBLL-UpdateArrangeCourse:{0};{1};{2}", e.Message, e.InnerException, e.HelpLink),
                        IsTreat = false,
                        CreateBy = loginUserId,
                        CreateTime = DateTime.Now
                    });

                    return false;
                }
            }
        }
示例#5
0
        /// <summary>
        /// 作者:Raymond
        /// 日期:2014-5-13
        /// 描述:更新合同信息、合同明细、合同级别
        /// -----------------------------------
        /// 更新:Vincen
        /// 时间:2014.06.11
        /// ------------------------------------
        /// 更新:Ark
        /// 时间:2014.08.06
        /// 描述:参数加userId,单个ContractDetail修改为多个
        /// </summary>
        /// <param name="contract"></param>
        /// <param name="userId"></param>
        /// <param name="productIds"></param>
        /// <param name="emeLevels"></param>
        /// <param name="currentLevels"></param>
        /// <param name="contractTypes"></param>
        /// <param name="contractStatuType"></param>
        /// <returns></returns>
        public static bool UpdateContract(Contract contract, int userId, List<int> productIds, List<string> emeLevels, List<string> currentLevels, List<int> contractTypes, int contractStatuType, int loginUserId)
        {
            try
            {
                using (var edb = new EmeEntities())
                {
                    using (var tran = new TransactionScope())
                    {
                        //获取对象
                        var contractObj = edb.Contract.FirstOrDefault(p => p.Id == contract.Id);

                        if (null == contractObj)
                            return false;

                        var detailList = edb.ContractDetail.Where(p => p.ContractId == contract.Id).ToList();
                        var detailIds = detailList.Select(d => d.Id).ToList();
                        var contractLevelList = edb.ContractLevel.Where(l => detailIds.Contains(l.ContractDetailId)).ToList();

                        #region 合同状态无效合同相关修改为无效(直接返回)

                        if (contract.Status != ConvertEnum.StatusTypeForActive)
                        {
                            contractObj.Status = contract.Status;
                            contractObj.UpdateBy = contract.UpdateBy;
                            contractObj.UpdateTime = contract.UpdateTime;

                            // 合同明细状态修改为无效
                            foreach (var detail in detailList)
                            {
                                detail.Status = contract.Status;
                                detail.UpdateBy = contract.UpdateBy;
                                detail.UpdateTime = contract.UpdateTime;
                            }
                            // 同时对应的合同级别 ContractLevel 状态修改为无效
                            foreach (var levelItem in contractLevelList)
                            {
                                levelItem.Status = contract.Status;
                                levelItem.UpdateBy = contract.UpdateBy;
                                levelItem.UpdateTime = contract.UpdateTime;
                            }

                            edb.SaveChanges();
                            tran.Complete();
                            return true;  // 直接返回
                        }

                        #endregion
                        #region 1。修改合同

                        if (contractObj != null)
                        {
                            contractObj.CrmContractId = contract.CrmContractId;
                            contractObj.StudentId = contract.StudentId;
                            contractObj.ContractNum = contract.ContractNum;
                            contractObj.BeginDate = contract.BeginDate;
                            contractObj.EndDate = contract.EndDate;
                            contractObj.UpdateBy = contract.UpdateBy;
                            contractObj.UpdateTime = contract.UpdateTime;
                            contractObj.Status = contract.Status;

                            edb.Entry(contractObj).State = EntityState.Modified;
                        }

                        #endregion
                        #region 2。合同明细及合同级别状态修改为无效

                        // 合同明细状态修改为无效
                        foreach (var detail in detailList)
                        {
                            detail.Status = ConvertEnum.StatusTypeForInactive;
                            detail.UpdateBy = contract.UpdateBy;
                            detail.UpdateTime = contract.UpdateTime;
                        }
                        // 同时对应的合同级别 ContractLevel 状态修改为无效
                        foreach (var levelItem in contractLevelList)
                        {
                            levelItem.Status = ConvertEnum.StatusTypeForInactive;
                            levelItem.UpdateBy = contract.UpdateBy;
                            levelItem.UpdateTime = contract.UpdateTime;
                        }

                        // 学员别的合同
                        var otherContractList = edb.Contract.Where(c => c.StudentId == contractObj.StudentId && c.Id != contract.Id);
                        var otherContractIds = otherContractList.Select(c => c.Id);
                        // 学员别的冻结、执行的合同详情
                        var otherDetailList = edb.ContractDetail.Where(d => otherContractIds.Contains(d.ContractId) &&
                            (d.ContractStatusType == ConvertEnum.ContractStatusTypeForExcute || d.ContractStatusType == ConvertEnum.ContractStatusTypeForFreeze));
                        // 学员别的冻结、执行的合同Id
                        var tempContractIds = otherDetailList.Select(d => d.ContractId).Distinct();
                        otherContractList = otherContractList.Where(c => tempContractIds.Contains(c.Id));

                        foreach (var otherContract in otherContractList)
                        {
                            otherContract.BeginDate = contract.BeginDate;
                            otherContract.EndDate = contract.EndDate;
                            edb.Entry(otherContract).State = EntityState.Modified;
                        }
                        foreach (var otherDetail in otherDetailList)
                        {
                            otherDetail.BeginDate = contract.BeginDate;
                            otherDetail.EndDate = contract.EndDate;
                            edb.Entry(otherDetail).State = EntityState.Modified;
                        }

                        edb.SaveChanges();

                        #endregion
                        #region 3。同步Crm合同明细及合同级别

                        int contractType;
                        ContractDetail contractDetail = null;
                        int productId;
                        //是否vip
                        var isVip = false;
                        int[] levels;
                        var userBranch = UserBLL.GetUserBranch(userId, true);

                        for (int i = 0; i < productIds.Count; i++)
                        {
                            // 主修课时总数
                            int majorTotal = 0;
                            // 选修课时总数
                            int electiveTotal = 0;
                            productId = productIds[i];
                            contractType = contractTypes[i];
                            contractDetail = detailList.FirstOrDefault(d => d.ProductId == productId);
                            levels = Array.ConvertAll<string, int>(emeLevels[i].Trim().Trim(',').Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries),
                                delegate(string s) { return int.Parse(s); });
                            List<int> curlastIndexs = new List<int>();
                            int[] productCurLevels = Array.ConvertAll<string, int>(currentLevels[i].Trim().Trim(',').Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries),
                                delegate(string s) { return int.Parse(s); });

                            foreach (var level in productCurLevels)
                            {
                                curlastIndexs.Add(levels.ToList().LastIndexOf(level));
                            }

                            // 取当前级别在级别中的最后索引
                            //int lastIndex = levels.ToList().LastIndexOf(currentLevels[i]);
                            // 临时索引
                            int tempIndex = 0;

                            // 此合同明细(产品)存在修改,不存在新增
                            if (null != contractDetail)
                            {
                                var product = edb.Product.FirstOrDefault(p => p.Id == productId);

                                // 获取是否Vip学员,通过产品表Product的IsVip
                                if (null != product)
                                    isVip = product.IsVip;

                                contractDetail.IsVip = isVip;
                                contractDetail.ContractTypeId = contractType;
                                contractDetail.BeginDate = contract.BeginDate;
                                contractDetail.EndDate = contract.EndDate;
                                contractDetail.ContractStatusType = contractStatuType;
                                contractDetail.Status = contract.Status;

                                #region 合同级别

                                foreach (var level in levels)
                                {
                                    // 是否当前级别 (两索引相等时设为当前级别)
                                    //一个当前级别时采用 索引,取最后一个为当前级别
                                    // var curlevel = (tempIndex == lastIndex); //(level == currentLevels[i]);
                                    //多个当前级别时,每个都设置为当前级别
                                    // if (currentLevels.Count > 1)
                                    //      curlevel = currentLevels.Contains(level);
                                    var curlevel = curlastIndexs.Contains(tempIndex);

                                    // 合同类型级别(定义主修、选修总课时)
                                    var ctpl = edb.ContractTypeProductLevel.FirstOrDefault(p => p.BranchId == userBranch.BranchId && p.ContractTypeId == contractType && p.ProductLevelId == level && p.Status == ConvertEnum.StatusTypeForActive);
                                    if (ctpl == null)
                                    {
                                        ctpl = edb.ContractTypeProductLevel.FirstOrDefault(p => p.ContractTypeId == contractType && p.ProductLevelId == level && p.Status == ConvertEnum.StatusTypeForActive && p.IsSystem == true);
                                    }

                                    var repairTotal = ctpl.Repair;
                                    var absenceTotal = ctpl.Absence;
                                    majorTotal += ctpl.MajorTotal;
                                    electiveTotal += ctpl.ElectiveTotal;
                                    var contractLevel = contractLevelList.FirstOrDefault(l => l.ContractDetailId == contractDetail.Id && l.ProductLevelId == level);

                                    if (null != contractLevel)
                                    {
                                        // 找到级别,缓存移除此级别(为了处理级别转换,两相级别相同)
                                        contractLevelList.Remove(contractLevel);
                                        contractLevel.IsCurrent = curlevel;

                                        //2015.05.25 beta修改,针对特殊修改操作
                                        var remark = "手动修改";
                                        if (contractLevel.Remark != remark)
                                        {
                                            contractLevel.MajorTotal = ctpl.MajorTotal;
                                            contractLevel.ElectiveTotal = ctpl.ElectiveTotal;
                                        }
                                        contractLevel.RepairTotal = repairTotal;
                                        contractLevel.AbsenceTotal = absenceTotal;
                                        contractLevel.Status = contract.Status;
                                    }
                                    else
                                    {
                                        contractLevel = new ContractLevel()
                                        {
                                            ContractDetailId = contractDetail.Id,
                                            ProductLevelId = level,
                                            IsCurrent = curlevel,
                                            RepairTotal = repairTotal,
                                            AbsenceTotal = absenceTotal,
                                            MajorTotal = ctpl.MajorTotal,           // 主修总课时
                                            ElectiveTotal = ctpl.ElectiveTotal,     // 选修总课时
                                            Status = contract.Status,
                                            CreateBy = contract.CreateBy,
                                            CreateTime = contract.CreateTime,
                                        };
                                        edb.Entry(contractLevel).State = EntityState.Added;
                                    }

                                    tempIndex++;
                                }

                                #endregion

                                // 修改主选修课时总数
                                contractDetail.MajorTotal = majorTotal;
                                contractDetail.ElectiveTotal = electiveTotal;
                                edb.SaveChanges();
                            }
                            else
                            {
                                // 新增
                                contractDetail = new ContractDetail()
                                {
                                    ContractId = contract.Id,
                                    ContractTypeId = contractType,
                                    ProductId = productId,
                                    MajorTotal = 0,        // 添加时默认0,添加级别后修改
                                    ElectiveTotal = 0,
                                    IsVip = isVip,
                                    BeginDate = contract.BeginDate,
                                    EndDate = contract.EndDate,
                                    IsLimitBook = false,
                                    AllowUnBookTimes = 0,
                                    ContractStatusType = contractStatuType,
                                    Status = contract.Status,
                                    CreateBy = contract.CreateBy,
                                    CreateTime = contract.CreateTime
                                };
                                edb.Entry(contractDetail).State = EntityState.Added;
                                edb.SaveChanges();

                                #region 合同级别

                                foreach (var level in levels)
                                {
                                    // 合同类型级别(定义主修、选修总课时)
                                    var ctpl = edb.ContractTypeProductLevel.FirstOrDefault(p => p.BranchId == userBranch.BranchId && p.ContractTypeId == contractType && p.ProductLevelId == level && p.Status == ConvertEnum.StatusTypeForActive);
                                    if (ctpl == null)
                                    {
                                        ctpl = edb.ContractTypeProductLevel.FirstOrDefault(p => p.ContractTypeId == contractType && p.ProductLevelId == level && p.Status == ConvertEnum.StatusTypeForActive && p.IsSystem == true);
                                    }
                                    //var ctpl = GetContractTypeProductLevel(userBranch.BranchId, contractType, level); // 此处 userBranch.Id 改为 userBranch.BranchId
                                    var repairTotal = ctpl.Repair;
                                    var absenceTotal = ctpl.Absence;
                                    majorTotal += ctpl.MajorTotal;
                                    electiveTotal += ctpl.ElectiveTotal;
                                    // 是否当前级别 (两索引相等时设为当前级别)
                                    // var curlevel = (tempIndex == lastIndex); //(level == currentLevels[i]);
                                    var curlevel = curlastIndexs.Contains(tempIndex);
                                    var contractLevel = new ContractLevel()
                                    {
                                        ContractDetailId = contractDetail.Id,
                                        ProductLevelId = level,
                                        IsCurrent = curlevel,
                                        RepairTotal = repairTotal,
                                        AbsenceTotal = absenceTotal,
                                        MajorTotal = ctpl.MajorTotal,           // 主修总课时
                                        ElectiveTotal = ctpl.ElectiveTotal,     // 选修总课时
                                        Status = contract.Status,
                                        CreateBy = contract.CreateBy,
                                        CreateTime = contract.CreateTime,
                                    };
                                    edb.Entry(contractLevel).State = EntityState.Added;
                                    tempIndex++;
                                }

                                // 修改合同明细主先修课时总数
                                contractDetail.MajorTotal = majorTotal;
                                contractDetail.ElectiveTotal = electiveTotal;

                                #endregion
                            }
                        }

                        edb.SaveChanges();
                        tran.Complete();
                        return true;

                        #endregion
                    }
                }
            }
            catch (Exception e)
            {
                // 异常日志消息队列
                Common.MSMQ.QueueManager.AddExceptionLog(new ExceptionLogs()
                {
                    ExceptionType = CommonHelper.To<int>(ExceptionType.Function),
                    Message = string.Format("StudentBLL-UpdateContract:{0};{1};{2}", e.Message, e.InnerException.Message, e.HelpLink),
                    IsTreat = false,
                    CreateBy = loginUserId,
                    CreateTime = DateTime.Now
                });

                return false;
            }
        }
示例#6
0
 /// <summary>
 /// 作者:Raymond
 /// 日期:2014-5-14
 /// 描述:新增合同级别
 /// </summary>
 /// <param name="model"></param>
 /// <returns></returns>
 public static bool CreateContractLevel(ContractLevel model)
 {
     using (var edb = new EmeEntities())
     {
         edb.Entry(model).State = EntityState.Added;
         return edb.SaveChanges() > 0;
     }
 }
示例#7
0
        /// <summary>
        /// 作者:Raymond
        /// 日期:2014-5-14
        /// 描述:新增合同、合同明细、合同级别
        /// ------------------------------------
        /// 更新:Vincen
        /// 时间:2014.06.11
        /// ------------------------------------
        /// 更新:Ark
        /// 时间:2014.08.06
        /// 描述:参数加userId,单个ContractDetail修改为多个,获取IsVip通过产品表
        /// </summary>
        /// <param name="contract"></param>
        /// <param name="userId"></param>
        /// <param name="productIds"></param>
        /// <param name="emeLevels"></param>
        /// <param name="currentLevels"></param>
        /// <param name="contractTypes"></param>
        /// <param name="contractStatuType"></param>
        /// <param name="updatingBookRecordIds">需要更新的bookRecordId</param>
        /// <returns></returns>
        public static bool CreateContract(Contract contract, int userId, List<int> productIds, List<string> emeLevels, List<string> currentLevels,
            List<int> contractTypes, int contractStatuType, int[] updatingBookRecordIds, int? oldcontractNum)
        {
            using (var edb = new EmeEntities())
            {
                using (var tran = new TransactionScope())
                {
                    try
                    {
                        #region 新合同及合同明细、合同级别处理

                        // Step1.新增主合同
                        edb.Contract.Add(contract); // 重新定义Contract并赋值 改为 直接添加
                        edb.SaveChanges();

                        // 学员别的合同
                        var otherContractList = edb.Contract.Where(c => c.StudentId == contract.StudentId && c.Id != contract.Id);
                        var otherContractIds = otherContractList.Select(c => c.Id);
                        // 学员别的冻结、执行的合同详情
                        var otherDetailList = edb.ContractDetail.Where(d => otherContractIds.Contains(d.ContractId) &&
                            (d.ContractStatusType == ConvertEnum.ContractStatusTypeForExcute || d.ContractStatusType == ConvertEnum.ContractStatusTypeForFreeze));
                        // 学员别的冻结、执行的合同Id
                        var tempContractIds = otherDetailList.Select(d => d.ContractId).Distinct();
                        otherContractList = otherContractList.Where(c => tempContractIds.Contains(c.Id));

                        foreach (var otherContract in otherContractList)
                        {
                            otherContract.BeginDate = contract.BeginDate;
                            otherContract.EndDate = contract.EndDate;
                            edb.Entry(otherContract).State = EntityState.Modified;
                        }
                        foreach (var otherDetail in otherDetailList)
                        {
                            otherDetail.BeginDate = contract.BeginDate;
                            otherDetail.EndDate = contract.EndDate;
                            edb.Entry(otherDetail).State = EntityState.Modified;
                        }

                        edb.SaveChanges();

                        // Step2.合同明细对象
                        int contractType;
                        bool isVip = false;
                        ContractDetail detail = null;
                        UserBranch userBranch = UserBLL.GetUserBranch(userId, true);
                        int[] levels;

                        for (int i = 0; i < productIds.Count; i++)
                        {
                            levels = Array.ConvertAll<string, int>(emeLevels[i].Trim().Trim(',').Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries),
                                delegate(string s) { return int.Parse(s); });
                            contractType = contractTypes[i];

                            var productId = productIds[i];
                            var product = edb.Product.FirstOrDefault(p => p.Id == productId);

                            List<int> curlastIndexs = new List<int>();
                            int[] productCurLevels = Array.ConvertAll<string, int>(currentLevels[i].Trim().Trim(',').Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries),
                                delegate(string s) { return int.Parse(s); });

                            foreach (var level in productCurLevels)
                            {
                                curlastIndexs.Add(levels.ToList().LastIndexOf(level));
                            }

                            // 获取是否Vip学员,通过产品表Product的IsVip
                            if (null != product)
                                isVip = product.IsVip;
                            // 添加合同详情
                            detail = new ContractDetail()
                            {
                                ContractId = contract.Id,
                                ContractTypeId = contractType,
                                ProductId = productId,
                                MajorTotal = 0,        // 添加时默认0,添加级别后修改
                                ElectiveTotal = 0,
                                IsVip = isVip,
                                BeginDate = contract.BeginDate,
                                EndDate = contract.EndDate,
                                IsLimitBook = false,
                                AllowUnBookTimes = 0,
                                ContractStatusType = contractStatuType,
                                Status = contract.Status,
                                CreateBy = contract.CreateBy,
                                CreateTime = contract.CreateTime
                            };
                            edb.Entry(detail).State = EntityState.Added;
                            edb.SaveChanges();

                            // Step3.合同级别信息
                            // 获取此合同类型的主修课时总数,选修课时总数
                            // 主修课时总数
                            int majorTotal = 0;
                            // 选修课时总数
                            int electiveTotal = 0;
                            // 取当前级别在级别中的最后索引
                            // int lastIndex = levels.ToList().LastIndexOf(currentLevels[i]);
                            // 临时索引
                            int tempIndex = 0;

                            var contractLevelListTemp = new List<ContractLevel>(levels.Length);
                            foreach (var level in levels)
                            {
                                // 合同类型级别(定义主修、选修总课时)
                                var ctpl = edb.ContractTypeProductLevel.FirstOrDefault(p => p.BranchId == userBranch.BranchId && p.ContractTypeId == contractType && p.ProductLevelId == level && p.Status == ConvertEnum.StatusTypeForActive);
                                if (ctpl == null)
                                {
                                    ctpl = edb.ContractTypeProductLevel.FirstOrDefault(p => p.ContractTypeId == contractType && p.ProductLevelId == level && p.Status == ConvertEnum.StatusTypeForActive && p.IsSystem == true);
                                }

                                var repairTotal = ctpl.Repair;
                                var absenceTotal = ctpl.Absence;
                                majorTotal += ctpl.MajorTotal;
                                electiveTotal += ctpl.ElectiveTotal;
                                // 是否当前级别 (两索引相等时设为当前级别)
                                //var curlevel = (tempIndex == lastIndex); //(level == currentLevels[i]);
                                var curlevel = curlastIndexs.Contains(tempIndex);
                                var contractLevel = new ContractLevel()
                                {
                                    ContractDetailId = detail.Id,
                                    ProductLevelId = level,
                                    IsCurrent = curlevel,
                                    RepairTotal = repairTotal,
                                    AbsenceTotal = absenceTotal,
                                    MajorTotal = ctpl.MajorTotal,           // 主修总课时
                                    ElectiveTotal = ctpl.ElectiveTotal,     // 选修总课时
                                    Status = contract.Status,
                                    CreateBy = contract.CreateBy,
                                    CreateTime = contract.CreateTime,
                                };
                                edb.Entry(contractLevel).State = EntityState.Added;
                                tempIndex++;
                                contractLevelListTemp.Add(contractLevel);
                            }

                            // 修改合同明细主先修课时总数
                            detail.MajorTotal = majorTotal;
                            detail.ElectiveTotal = electiveTotal;

                            edb.SaveChanges();

                            #region 将学员旧的bookRecord绑定为当前合同-特殊业务逻辑。
                            //3.0升级4.0时,存在部分学员的原CrmContracId为null的数据,当从Crm同步合同时,会认为是新合同,从而将原有学习记录冲掉的情况
                            //此情况只存在于3.0升级4.0时导入的学员数据,待该部分所有数据都正常后可以删除 by ian fang 2015-01-12
                            var originBookRecords = (from br in edb.BookRecord
                                                     join cl in edb.ContractLevel on br.ContractLevelId equals cl.Id
                                                     where updatingBookRecordIds.Contains(br.Id)
                                                     select new { BookRecord = br, ContractLevel = cl }).ToList();

                            #region 短期转常规,将短期班的上课课时绑定到常规合同级别下面
                            if (oldcontractNum.HasValue)
                            {
                                originBookRecords = (from br in edb.BookRecord
                                                     join cl in edb.ContractLevel on br.ContractLevelId equals cl.Id
                                                     join cd in edb.ContractDetail on cl.ContractDetailId equals cd.Id
                                                     join c in edb.Contract on cd.ContractId equals c.Id
                                                     where c.CrmContractId == oldcontractNum
                                                     select new { BookRecord = br, ContractLevel = cl }).ToList();
                            }
                            #endregion

                            foreach (var contractLevel in contractLevelListTemp)
                            {
                                if (updatingBookRecordIds != null)
                                {
                                    var originBookRecordsTemp = originBookRecords.Where(obr => obr.ContractLevel.ProductLevelId == contractLevel.ProductLevelId).ToList();
                                    bool levelUpdateFlag = false;
                                    foreach (var bookRecord in originBookRecordsTemp)
                                    {
                                        if (!levelUpdateFlag)
                                        {
                                            //复制原ContractLevel中的数据
                                            contractLevel.MajorOffline = bookRecord.ContractLevel.MajorOffline;
                                            contractLevel.MajorOnline = bookRecord.ContractLevel.MajorOnline;
                                            contractLevel.ElectiveOnline = bookRecord.ContractLevel.ElectiveOnline;
                                            contractLevel.ElectiveOffline = bookRecord.ContractLevel.ElectiveOffline;
                                            contractLevel.Repair = bookRecord.ContractLevel.Repair;
                                            contractLevel.Absence = bookRecord.ContractLevel.Absence;

                                            edb.Entry(contractLevel).State = EntityState.Modified;
                                            levelUpdateFlag = true;
                                        }

                                        //将原bookRecord中的ContractlevelId更新为新建的
                                        bookRecord.BookRecord.ContractLevelId = contractLevel.Id;
                                        edb.Entry(bookRecord.BookRecord).State = EntityState.Modified;
                                    }
                                }
                            }
                            edb.SaveChanges();

                            #endregion
                        }

                        #endregion

                        tran.Complete();
                        return true;
                    }
                    catch (Exception e)
                    {
                        // 异常日志消息队列
                        QueueManager.AddExceptionLog(new ExceptionLogs()
                        {
                            ExceptionType = CommonHelper.To<int>(ExceptionType.Function),
                            Message = string.Format("StudentBLL-CreateContract:{0};{1};{2}", e.Message, e.InnerException.Message, e.HelpLink),
                            IsTreat = false,
                            CreateBy = contract.CreateBy,
                            CreateTime = DateTime.Now
                        });
                        return false;
                    }
                }
            }
        }