コード例 #1
0
ファイル: DecodeOperationPlan.cs プロジェクト: unicloud/AFRP
 /// <summary>
 /// 更新计划
 /// </summary>
 /// <param name="NewPlanHistory"></param>
 private void UpdatePlan(PlanHistory NewPlanHistory)
 {
     if (NewPlanHistory.PlanID != null)
     {
         Plan OriginPlan = this._FE.Plans.Where(q => q.PlanID == NewPlanHistory.PlanID).FirstOrDefault();
         if (OriginPlan == null)
         {
             Plan NewPlan = new Plan();
             NewPlan.PlanID = NewPlanHistory.PlanID;
             NewPlan.AirlinesID = NewPlanHistory.AirlinesID;
             if (NewPlanHistory.Annual != null)
             {
                 NewPlan.AnnualID = NewPlanHistory.Annual.AnnualID;
             }
             else
             {
                 Annual annual = this._FE.Annuals.Where(p => p.Year == DateTime.Today.Year).FirstOrDefault();
                 NewPlan.AnnualID = annual.AnnualID;
             }
             //增加计划历史
             this._FE.Plans.Add(NewPlan);
         }
     }
 }
コード例 #2
0
ファイル: OperationHistorySync.cs プロジェクト: unicloud/AFRP
        /// <summary>
        ///同步下一年度计划 
        /// </summary>
        /// <param name="dbContext"></param>
        /// <param name="currentPlanHisotry"></param>
        /// <param name="currentOpenAnnual"></param>
        private static void SynOperationNextYearPlan(FleetEntities dbContext, PlanHistory currentPlanHisotry, Annual currentOpenAnnual)
        {
            //找到大于当前年度的计划,补上当前计划运营历史或者商业数据
            //大于当前有效计划的集合
            var exceedAnnual = dbContext.Annuals.Where(p => p.Year > currentOpenAnnual.Year);
            //需要同步的计划历史
            var searchNextPlanHistories = from t in dbContext.Plans
                                          from a in dbContext.PlanHistories
                                          from r in dbContext.PlanAircrafts
                                          from f in exceedAnnual
                                          where
                                              t.AnnualID == f.AnnualID &&
                                              t.PlanID == a.PlanID
                                              && r.PlanAircraftID == a.PlanAircraftID &&
                                              r.PlanAircraftID == currentPlanHisotry.PlanAircraftID
                                          select a;

            searchNextPlanHistories.ToList().ForEach
                (
                    f =>
                    {
                        if (currentPlanHisotry.GetType() == typeof(OperationPlan) && f.GetType() == typeof(OperationPlan) && (f as OperationPlan).OperationHistory == null)
                        {
                            var operationPlan = f as OperationPlan;
                            if (operationPlan != null)
                            {
                                var plan = currentPlanHisotry as OperationPlan;
                                if (plan != null)
                                    operationPlan.OperationHistoryID = plan.OperationHistoryID;
                            }
                        }
                        if (currentPlanHisotry.GetType() != typeof(ChangePlan) ||
                            f.GetType() != typeof(ChangePlan) || (f as ChangePlan).AircraftBusiness != null)
                            return;
                        var changePlan = f as ChangePlan;
                        if (changePlan != null)
                        {
                            var plan = currentPlanHisotry as ChangePlan;
                            if (plan != null)
                                changePlan.AircraftBusinessID = plan.AircraftBusinessID;
                        }
                    }
                );
        }
コード例 #3
0
ファイル: OperationHistorySync.cs プロジェクト: unicloud/AFRP
 /// <summary>
 /// 同步上一年度计划
 /// </summary>
 /// <param name="dbContext"></param>
 /// <param name="currentPlanHisotry"></param>
 /// <param name="StartDate"></param>
 /// <param name="currentOpenAnnual"></param>
 private static void SynOperationLastYearPlan(FleetEntities dbContext, PlanHistory currentPlanHisotry, DateTime StartDate, Annual currentOpenAnnual)
 {
     //找到上个年度的有效计划,补上当前计划运营历史或者商业数据
     //上个年度有效的打开的年度
     var lastOpenAnnual = dbContext.Annuals.FirstOrDefault(p => p.Year == currentOpenAnnual.Year - 1);
     //需要同步的计划历史
     var needSyncPlanHisotry = from t in dbContext.Plans
                               from a in dbContext.PlanHistories
                               from r in dbContext.PlanAircrafts
                               where
                                   t.IsValid == true && t.AnnualID == lastOpenAnnual.AnnualID &&
                                   t.PlanID == a.PlanID
                                   && r.PlanAircraftID == a.PlanAircraftID &&
                                   r.PlanAircraftID == currentPlanHisotry.PlanAircraftID
                               select a;
     var searchPlanHistory = needSyncPlanHisotry.FirstOrDefault();
     if (searchPlanHistory != null)
     {
         //如果运营日期在上一执行年度,则需要反向同步
         if (lastOpenAnnual != null && StartDate.Year <= lastOpenAnnual.Year)
         {
             if (currentPlanHisotry != null && (currentPlanHisotry.GetType() == typeof(OperationPlan) && searchPlanHistory.GetType() == typeof(OperationPlan) && (searchPlanHistory as OperationPlan).OperationHistory == null))
             {
                 var operationPlan = searchPlanHistory as OperationPlan;
                 if (operationPlan != null)
                     operationPlan.OperationHistoryID = (currentPlanHisotry as OperationPlan).OperationHistoryID;
             }
             if (currentPlanHisotry.GetType() == typeof(ChangePlan) && searchPlanHistory.GetType() == typeof(ChangePlan) && (searchPlanHistory as ChangePlan).AircraftBusiness == null)
             {
                 var changePlan = searchPlanHistory as ChangePlan;
                 if (changePlan != null)
                     changePlan.AircraftBusinessID = (currentPlanHisotry as ChangePlan).AircraftBusinessID;
             }
         }
         else //如果不需要反向同步的需要,要将可能由于运营时间得改动,有做过反向同步的给取消掉
         {
             if (currentPlanHisotry.GetType() == typeof(OperationPlan) && searchPlanHistory.GetType() == typeof(OperationPlan) && (searchPlanHistory as OperationPlan).OperationHistory != null)
             {
                 var operationPlan = searchPlanHistory as OperationPlan;
                 if (operationPlan != null)
                     operationPlan.OperationHistoryID = null;
             }
             if (currentPlanHisotry.GetType() == typeof(ChangePlan) && searchPlanHistory.GetType() == typeof(ChangePlan) && (searchPlanHistory as ChangePlan).AircraftBusiness != null)
             {
                 var changePlan = searchPlanHistory as ChangePlan;
                 if (changePlan != null)
                     changePlan.AircraftBusinessID = null;
             }
         }
     }
 }
コード例 #4
0
ファイル: FleetServiceHelper.cs プロジェクト: unicloud/AFRP
 /// <summary>
 /// 创建新的运营历史
 /// </summary>
 /// <param name="approvalHistory">批文明细</param>
 /// <param name="aircraft">飞机</param>
 /// <param name="service"></param>
 private static void CreateOperationHistory(PlanHistory planDetail, Aircraft aircraft, IFleetService service)
 {
     var operationHistory = new OperationHistory
         {
             ApprovalHistory = planDetail.ApprovalHistory,
             Airlines = service.CurrentAirlines,
             Aircraft = aircraft,
             ImportCategory = planDetail.ApprovalHistory.ImportCategory,
             Status = (int)OpStatus.Draft,
         };
     if (planDetail is OperationPlan) (planDetail as OperationPlan).OperationHistory = operationHistory;
     service.EntityContainer.GetEntitySet<OperationHistory>().Add(operationHistory);
     // 更改运营历史状态
     operationHistory.Status = (int)OpStatus.Draft;
 }
コード例 #5
0
ファイル: FleetServiceHelper.cs プロジェクト: unicloud/AFRP
        /// <summary>
        /// 创建新的商业数据历史
        /// </summary>
        /// <param name="aircraft">飞机</param>
        /// <param name="service"></param>
        private static void CreateAircraftBusiness(PlanHistory planDetail, Aircraft aircraft, IFleetService service)
        {
            var aircraftBusiness = new AircraftBusiness
                {
                    AircraftBusinessID = Guid.NewGuid(),
                    Aircraft = aircraft,
                    AircraftType = aircraft.AircraftType,
                    ImportCategory = aircraft.ImportCategory,
                    SeatingCapacity = aircraft.SeatingCapacity,
                    CarryingCapacity = aircraft.CarryingCapacity,
                    Status = (int)OpStatus.Draft,
                };

            if (planDetail is ChangePlan) (planDetail as ChangePlan).AircraftBusiness = aircraftBusiness;
            service.EntityContainer.GetEntitySet<AircraftBusiness>().Add(aircraftBusiness);
            // 更改商业数据历史状态
            aircraftBusiness.Status = (int)OpStatus.Draft;
        }
コード例 #6
0
ファイル: FleetServiceHelper.cs プロジェクト: unicloud/AFRP
 /// <summary>
 /// 创建新飞机
 /// </summary>
 /// <param name="planDetail">计划明细</param>
 /// <param name="service"></param>
 private static void CreateAircraft(PlanHistory planDetail, IFleetService service)
 {
     var aircraft = new Aircraft
         {
             AircraftID = Guid.NewGuid(),
             AircraftType = planDetail.PlanAircraft.AircraftType,
             Airlines = service.CurrentAirlines,
             CreateDate = DateTime.Now,
             IsOperation = true,
             SeatingCapacity = planDetail.SeatingCapacity,
             CarryingCapacity = planDetail.CarryingCapacity,
         };
     planDetail.PlanAircraft.Aircraft = aircraft;
     service.EntityContainer.GetEntitySet<Aircraft>().Add(aircraft);
     CreateOperationHistory(planDetail, aircraft, service);
     CreateAircraftBusiness(planDetail, aircraft, service);
 }
コード例 #7
0
ファイル: FleetServiceHelper.cs プロジェクト: unicloud/AFRP
        /// <summary>
        /// 移除计划明细项
        /// </summary>
        /// <param name="planDetail"></param>
        /// <param name="service"></param>
        internal void RemovePlanDetail(PlanHistory planDetail, IFleetService service)
        {
            if (planDetail != null)
            {
                // 获取计划飞机
                var planAircraft = planDetail.PlanAircraft;
                // 获取计划飞机的明细项集合
                var planAircraftHistories = planAircraft.PlanHistories;
                // 获取计划飞机在当前计划中的明细项集合
                var planDetails = planAircraft.PlanHistories.Where(ph => ph.Plan == service.CurrentPlan).ToList();

                // 1、已有飞机(只有变更与退出计划)
                if (planAircraft.Aircraft != null)
                {
                    // 1.1、计划飞机在当前计划中只有一条明细项
                    if (planDetails.Count == 1)
                        planAircraft.Status = (int)ManageStatus.Operation;
                    // 1.2、计划飞机在当前计划中超过一条明细项,即一条变更、一条退出
                    else
                    {
                        // 移除的是变更计划,计划飞机改为运营状态(可能之前也是运营状态)
                        if (planDetail.ActionType == "变更")
                            planAircraft.Status = (int)ManageStatus.Operation;
                        // 移除的是退出计划,不做任何改变
                    }
                }
                // 2、没有飞机(只有引进与退出计划)
                // 2.1、计划飞机相关的明细项数量为1
                // 删除相关计划飞机。
                else if (planAircraftHistories.Count == 1)
                {
                    service.EntityContainer.GetEntitySet<PlanAircraft>().Remove(planAircraft);
                }
                // 2.2、计划飞机相关的计划历史数量不为1(即超过1)
                // 2.2.1、计划飞机在当前计划中只有一条明细项
                // 计划飞机的管理状态改为预备
                else if (planDetails.Count == 1)
                {
                    planAircraft.Status = (int)ManageStatus.Prepare;
                }
                // 2.2.2、计划飞机在当前计划中超过一条明细项,即一条引进、一条退出
                // 不改变计划飞机状态

                service.EntityContainer.GetEntitySet<PlanHistory>().Remove(planDetail);
            }
        }
コード例 #8
0
ファイル: CommonMethod.cs プロジェクト: unicloud/AFRP
 /// <summary>
 /// 同步计划的运营历史操作
 /// </summary>
 /// <param name="planHistory">当前计划</param>
 /// <param name="tag"></param>
 public void SyncOperationHistroy(DateTime startDate, PlanHistory planHistory, OperationType tag)
 {
     switch (tag)
     {
         case OperationType.OperationLastYearPlan:
             //找到上个年度的计划,补上当前计划运营历史或者商业数据
             var searchPlanHistory = planHistory.PlanAircraft.PlanHistories
                  .Where(p => p.Plan.Annual.Year == planHistory.Plan.Annual.Year - 1 && p.PlanAircraft == planHistory.PlanAircraft).FirstOrDefault();
             if (searchPlanHistory != null)
             {
                 //如果运营日期在上一执行年度,则需要反向同步
                 if (startDate.Year <= planHistory.Plan.Annual.Year - 1)
                 {
                     if (planHistory.GetType() == typeof(OperationPlan) && searchPlanHistory.GetType() == typeof(OperationPlan) && (searchPlanHistory as OperationPlan).OperationHistory == null)
                     {
                         (searchPlanHistory as OperationPlan).OperationHistoryID = (planHistory as OperationPlan).OperationHistoryID;
                     }
                     if (planHistory.GetType() == typeof(ChangePlan) && searchPlanHistory.GetType() == typeof(ChangePlan) && (searchPlanHistory as ChangePlan).AircraftBusiness == null)
                     {
                         (searchPlanHistory as ChangePlan).AircraftBusinessID = (planHistory as ChangePlan).AircraftBusinessID;
                     }
                 }
                 else //如果不需要反向同步的需要,要将可能由于运营时间得改动,有做过反向同步的给取消掉
                 {
                     if (planHistory.GetType() == typeof(OperationPlan) && searchPlanHistory.GetType() == typeof(OperationPlan) && (searchPlanHistory as OperationPlan).OperationHistory != null)
                     {
                         (searchPlanHistory as OperationPlan).OperationHistoryID = null;
                     }
                     if (planHistory.GetType() == typeof(ChangePlan) && searchPlanHistory.GetType() == typeof(ChangePlan) && (searchPlanHistory as ChangePlan).AircraftBusiness != null)
                     {
                         (searchPlanHistory as ChangePlan).AircraftBusinessID = null;
                     }
                 }
             }
             break;
         case OperationType.OperationNextYearPlan:
             //找到大于当前年度的计划,补上当前计划运营历史或者商业数据
             var searchNextPlanHistories = planHistory.PlanAircraft.PlanHistories
                  .Where(p => p.Plan.Annual.Year > planHistory.Plan.Annual.Year && p.PlanAircraft == planHistory.PlanAircraft);
             if (searchNextPlanHistories.Any())
             {
                 searchNextPlanHistories.ToList().ForEach
                     (
                       f =>
                       {
                           if (planHistory.GetType() == typeof(OperationPlan) && f.GetType() == typeof(OperationPlan) && (f as OperationPlan).OperationHistory == null)
                           {
                               (f as OperationPlan).OperationHistoryID = (planHistory as OperationPlan).OperationHistoryID;
                           }
                           if (planHistory.GetType() == typeof(ChangePlan) && f.GetType() == typeof(ChangePlan) && (f as ChangePlan).AircraftBusiness == null)
                           {
                               (f as ChangePlan).AircraftBusinessID = (planHistory as ChangePlan).AircraftBusinessID;
                           }
                       }
                     );
             }
             break;
         default:
             break;
     }
 }
コード例 #9
0
ファイル: FleetServiceHelper.cs プロジェクト: unicloud/AFRP
        /// <summary>
        /// 创建新申请明细
        /// </summary>
        /// <param name="request"></param>
        /// <param name="planHistory"></param>
        /// <param name="service"></param>
        /// <returns></returns>
        internal ApprovalHistory CreateNewRequestDetail(Request request, PlanHistory planHistory, IFleetService service)
        {
            // 创建新的申请明细
            var requestDetail = new ApprovalHistory
                {
                    ApprovalHistoryID = Guid.NewGuid(),
                    Request = request,
                    PlanAircraft = planHistory.PlanAircraft,
                    ImportCategory = planHistory.TargetCategory,
                    Airlines = planHistory.Airlines,
                    Annual = planHistory.Annual,
                    RequestDeliverMonth = planHistory.PerformMonth,
                    SeatingCapacity = planHistory.SeatingCapacity,
                    CarryingCapacity = planHistory.CarryingCapacity,
                };
            // 把申请明细赋给关联的计划明细
            planHistory.ApprovalHistory = requestDetail;
            // 计划飞机管理状态修改为申请
            requestDetail.PlanAircraft.Status = (int)ManageStatus.Request;

            service.EntityContainer.GetEntitySet<ApprovalHistory>().Add(requestDetail);
            return requestDetail;
        }
コード例 #10
0
ファイル: AfrpPlanLayViewModel.cs プロジェクト: unicloud/AFRP
        private void ShowEditDialog(PlanHistory existDetail, PlanDetailCreateSource source)
        {
            switch (source)
            {
                case PlanDetailCreateSource.New:
                    this.IsPlanTypeVisible = Visibility.Collapsed;
                    this._operationPlan = this.service.CreateOperationPlan(this.CurrentPlan, this._planAircraft, "引进");
                    this.PlanDetail = this._operationPlan;
                    this.IsChangeable = true;
                    break;
                case PlanDetailCreateSource.PlanAircraft:
                    this.IsPlanTypeVisible = Visibility.Collapsed;
                    // 计划飞机已有的明细项肯定是引进计划,只能添加退出计划
                    this._operationPlan = this.service.CreateOperationPlan(this.CurrentPlan, this._planAircraft, existDetail != null ? "退出" : "引进");
                    this.PlanDetail = this._operationPlan;
                    //这时不能修改机型和座机
                    this.IsChangeable = false;
                    break;
                case PlanDetailCreateSource.Aircraft:
                    this.IsPlanTypeVisible = Visibility.Visible;
                    // 1、计划飞机已有明细项
                    if (existDetail != null)
                    {
                        // 已有的是变更计划,只能添加退出计划
                        if (existDetail.ActionType == "变更")
                        {
                            this.IsChangeEnabled = false;
                            this.IsOperation = true;
                            this.IsChange = false;
                            this.OnOperation();
                        }
                        // 已有的是退出计划,只能添加变更计划
                        else
                        {
                            this.IsOperationEnabled = false;
                            this.IsOperation = false;
                            this.IsChange = true;
                            this.OnOperation();//生成之后,不让用户编辑,起到保存原计划历史的机型的作用,在取消时,能够用来恢复计划飞机数据
                            this.OnChange();
                        }
                    }
                    // 2、计划飞机没有明细项
                    else
                    {
                        this.IsChangeEnabled = true;
                        this.IsOperationEnabled = true;
                        if (!this.IsOperation) this.IsOperation = true;
                        this.OnOperation();
                    }
                    break;
                default:
                    throw new ArgumentOutOfRangeException("source");
            }

            this.editDialog.ShowDialog();
        }
コード例 #11
0
ファイル: DecodePlan.cs プロジェクト: unicloud/AFRP
 private void UpdatePlanHistoryRelativeHistory(PlanHistory NewPlanHistory)
 {
     //处理批文历史
     UpdateApprovalHistoryForPlanHistory(NewPlanHistory);
     //处理运营计划历史
     UpdateOperationHistoryForPlanHistory(NewPlanHistory);
     //处理变更计划历史
     UpdateChangeHistoryForPlanHistory(NewPlanHistory);
 }
コード例 #12
0
ファイル: DecodePlan.cs プロジェクト: unicloud/AFRP
 private void UpdateOperationHistoryForPlanHistory(PlanHistory NewPlanHistory)
 {
     //处理运营计划历史
     if (NewPlanHistory is OperationPlan)
     {
         OperationPlan OperationPlan = NewPlanHistory as OperationPlan;
         if (OperationPlan.OperationHistoryID != null && !this._FE.OperationHistories.Any(p => p.OperationHistoryID == OperationPlan.OperationHistoryID))
         {
             OperationPlan.OperationHistoryID = null;
         }
         OperationPlan.OperationHistory = null;
     }
 }
コード例 #13
0
ファイル: DecodePlan.cs プロジェクト: unicloud/AFRP
 private void UpdateChangeHistoryForPlanHistory(PlanHistory NewPlanHistory)
 {
     //处理变更计划历史
     if (NewPlanHistory is ChangePlan)
     {
         ChangePlan ChangePlan = NewPlanHistory as ChangePlan;
         if (ChangePlan.AircraftBusinessID != null && !this._FE.AircraftBusinesses.Any(p => p.AircraftBusinessID == ChangePlan.AircraftBusinessID))
         {
             ChangePlan.AircraftBusinessID = null;
         }
         ChangePlan.AircraftBusiness = null;
     }
 }
コード例 #14
0
ファイル: DecodePlan.cs プロジェクト: unicloud/AFRP
 private void UpdateApprovalHistoryForPlanHistory(PlanHistory NewPlanHistory)
 {
     //处理批文历史
     if (NewPlanHistory.ApprovalHistoryID != null && !this._FE.ApprovalHistories.Any(p => p.ApprovalHistoryID == NewPlanHistory.ApprovalHistoryID))
     {
         NewPlanHistory.ApprovalHistoryID = null;
     }
     NewPlanHistory.ApprovalHistory = null;
 }
コード例 #15
0
ファイル: DecodePlan.cs プロジェクト: unicloud/AFRP
 private void DeletePlanHistoryRelation(PlanHistory OriginPlanHistory)
 {
     //if (OriginPlanHistory != null)
     //{
     //    //计划飞机处理
     //    if (OriginPlanHistory.PlanAircraftID != null)
     //    {
     //    }
     //}
 }
コード例 #16
0
ファイル: AfrpRequestViewModel.cs プロジェクト: unicloud/AFRP
 internal void AddNewRequestDetail(PlanHistory planHistory)
 {
     this.service.CreateNewRequestDetail(this.SelRequest, planHistory);
     this._needReFreshViewApprovalHistory = true;
     RaiseViewApprovalHistory();
     this._needReFreshViewPlanHistory = true;
     RaiseViewPlanHistory();
 }
コード例 #17
0
ファイル: FleetServiceHelper.cs プロジェクト: unicloud/AFRP
        /// <summary>
        /// 完成计划项
        /// </summary>
        /// <param name="planDetail"></param>
        /// <param name="service"></param>
        /// <returns></returns>
        internal Aircraft CompletePlan(PlanHistory planDetail, IFleetService service)
        {
            Aircraft aircraft;
            OperationHistory operationHistory;
            if (planDetail == null)
            {
                throw new ArgumentNullException("planDetail");
            }
            var actionName = planDetail.ActionCategory.ActionName;
            if (actionName == null)
            {
                return null;
            }
            // 根据引进方式调用不同的操作
            switch (actionName)
            {
                case "购买":
                    // 创建新飞机
                    CreateAircraft(planDetail, service);
                    break;
                case "融资租赁":
                    // 创建新飞机
                    CreateAircraft(planDetail, service);
                    break;
                case "经营租赁":
                    // 创建新飞机
                    CreateAircraft(planDetail, service);
                    break;
                case "湿租":
                    // 创建新飞机
                    CreateAircraft(planDetail, service);
                    break;
                case "经营租赁续租":
                    // 创建新运营历史
                    CreateOperationHistory(planDetail, planDetail.PlanAircraft.Aircraft, service);
                    break;
                case "湿租续租":
                    // 创建新运营历史
                    CreateOperationHistory(planDetail, planDetail.PlanAircraft.Aircraft, service);
                    break;
                case "出售":
                    // 更改运营历史状态
                    aircraft = planDetail.PlanAircraft.Aircraft;
                    operationHistory = aircraft.OperationHistories.LastOrDefault(oh => oh.EndDate == null);
                    if (operationHistory != null)
                    {
                        operationHistory.Status = (int)OpStatus.Draft;
                        operationHistory.ExportCategory =
                            service.AllActionCategories.FirstOrDefault(ac => ac.ActionName == "出售");

                        if (planDetail is OperationPlan) (planDetail as OperationPlan).OperationHistory = operationHistory;
                    }
                    break;
                case "出租":
                    // 更改运营历史状态
                    aircraft = planDetail.PlanAircraft.Aircraft;
                    operationHistory = aircraft.OperationHistories.LastOrDefault(oh => oh.EndDate == null);
                    if (operationHistory != null)
                    {
                        operationHistory.Status = (int)OpStatus.Draft;
                        operationHistory.ExportCategory =
                            service.AllActionCategories.FirstOrDefault(ac => ac.ActionName == "出租");

                        if (planDetail is OperationPlan) (planDetail as OperationPlan).OperationHistory = operationHistory;
                    }
                    break;
                case "退租":
                    // 更改运营历史状态
                    aircraft = planDetail.PlanAircraft.Aircraft;
                    operationHistory = aircraft.OperationHistories.LastOrDefault(oh => oh.EndDate == null);
                    if (operationHistory != null)
                    {
                        operationHistory.Status = (int)OpStatus.Draft;
                        operationHistory.ExportCategory =
                            service.AllActionCategories.FirstOrDefault(ac => ac.ActionName == "退租");

                        if (planDetail is OperationPlan) (planDetail as OperationPlan).OperationHistory = operationHistory;
                    }
                    break;
                case "退役":
                    // 更改运营历史状态
                    aircraft = planDetail.PlanAircraft.Aircraft;
                    operationHistory = aircraft.OperationHistories.LastOrDefault(oh => oh.EndDate == null);
                    if (operationHistory != null)
                    {
                        operationHistory.Status = (int)OpStatus.Draft;
                        operationHistory.ExportCategory =
                            service.AllActionCategories.FirstOrDefault(ac => ac.ActionName == "退役");

                        if (planDetail is OperationPlan) (planDetail as OperationPlan).OperationHistory = operationHistory;
                    }
                    break;
                case "货改客":
                    // 创建商业数据历史
                    CreateAircraftBusiness(planDetail, planDetail.PlanAircraft.Aircraft, service);
                    break;
                case "客改货":
                    // 创建商业数据历史
                    CreateAircraftBusiness(planDetail, planDetail.PlanAircraft.Aircraft, service);
                    break;
                case "售后经营租赁":
                    // 创建商业数据历史
                    CreateAircraftBusiness(planDetail, planDetail.PlanAircraft.Aircraft, service);
                    break;
                case "售后融资租赁":
                    // 创建商业数据历史
                    CreateAircraftBusiness(planDetail, planDetail.PlanAircraft.Aircraft, service);
                    break;
                case "一般改装":
                    // 创建商业数据历史
                    CreateAircraftBusiness(planDetail, planDetail.PlanAircraft.Aircraft, service);
                    break;
                case "租转购":
                    // 创建商业数据历史
                    CreateAircraftBusiness(planDetail, planDetail.PlanAircraft.Aircraft, service);
                    break;
            }
            // 更改计划飞机状态
            planDetail.PlanAircraft.Status = (int)ManageStatus.Operation;
            // 刷新计划完成状态
            RaisePropertyChanged(() => planDetail.CompleteStatus);

            return planDetail.PlanAircraft.Aircraft;
        }
コード例 #18
0
ファイル: AfrpDeliverViewModel.cs プロジェクト: unicloud/AFRP
 /// <summary>
 /// 打开子窗体之前先设置好子窗体中的编辑属性
 /// </summary>
 /// <param name="planHistory">计划明细</param>
 internal void OpenEditDialog(PlanHistory planHistory)
 {
     this.ShowEditDialog();
 }