Пример #1
0
        public int getStartTimerStatus()
        {
            try
            {
                StatusManager        modelStatus = listModel.Find(item => item.StatusId == statusManagerDetailsIdMain);
                SoapEntityRepository repo        = SoapEntityRepository.GetService();

                mzk_statusmanagerdetails statusmanagerdetails = null;

                statusmanagerdetails = (mzk_statusmanagerdetails)repo.GetEntity(mzk_statusmanagerdetails.EntityLogicalName, new Guid(modelStatus.ParentStatusId), new Microsoft.Xrm.Sdk.Query.ColumnSet(true));

                if (statusmanagerdetails != null)
                {
                    while (statusmanagerdetails.mzk_statusmanagerdetailsId.HasValue)
                    {
                        if (statusmanagerdetails.mzk_ShowStartTime.HasValue && !statusmanagerdetails.mzk_ShowStartTime.Value)
                        {
                            statusmanagerdetails = (mzk_statusmanagerdetails)repo.GetEntity(mzk_statusmanagerdetails.EntityLogicalName, statusmanagerdetails.mzk_ParentStatusId.Id, new Microsoft.Xrm.Sdk.Query.ColumnSet(true));
                        }
                        else
                        {
                            break;
                        }
                    }

                    return(statusmanagerdetails.mzk_OrderStatus.Value);
                }
                else
                {
                    return(0);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        /*   public async Task<bool> saveStatusManager(StatusManagerHeader statusManagerHeader)
         * {
         *     try
         *     {
         *         SoapEntityRepository repo = SoapEntityRepository.GetService();
         *
         *         mzk_statusmanager statusManager = new mzk_statusmanager();
         *
         *         statusManager.mzk_CaseType = new OptionSetValue(statusManagerHeader.caseType);
         *         statusManager.mzk_EntityType = new OptionSetValue(statusManagerHeader.entityType);
         *         statusManager.mzk_EffectiveFrom = statusManagerHeader.effectiveFrom;
         *         statusManager.mzk_EffectiveTo = statusManagerHeader.effectiveTo;
         *         statusManager.mzk_name = statusManagerHeader.name;
         *
         *         //Guid statusManagerGUID = repo.CreateEntity(statusManager);
         *
         *
         *         //if (statusManagerGUID != null && statusManagerGUID != Guid.Empty)
         *         {
         *             List<StatusManager> details = statusManagerHeader.details;
         *             Dictionary<string, EntityCollection> detailsDict = new Dictionary<string, EntityCollection>();
         *             Dictionary<string, mzk_statusmanagerdetails> detailsObjDict = new Dictionary<string, mzk_statusmanagerdetails>();
         *             EntityCollection entityCollection = new EntityCollection();
         *             Microsoft.Xrm.Sdk.Relationship relationship = null;
         *
         *             foreach (StatusManager modelDetails in details)
         *             {
         *                 mzk_statusmanagerdetails statusmanagerdetails = new mzk_statusmanagerdetails();
         *
         *                 //statusmanagerdetails.mzk_name = modelSection.Name;
         *
         *                 //statusmanagerdetails.mzk_StatusManagerId = new EntityReference(mzk_statusmanager.EntityLogicalName, statusManagerGUID);
         *
         *                 statusmanagerdetails.mzk_SendORM = modelDetails.sendOrm;
         *                 statusmanagerdetails.mzk_ShowEndTime = modelDetails.showEndTime;
         *                 statusmanagerdetails.mzk_showflip = modelDetails.isFlip;
         *                 statusmanagerdetails.mzk_ShowStartTime = modelDetails.showStartTime;
         *                 statusmanagerdetails.mzk_ShowTimer = modelDetails.showTimer;
         *                 statusmanagerdetails.mzk_AllowEdit = modelDetails.allowEdit;
         *                 statusmanagerdetails.mzk_ActionManagerId = new EntityReference(mzk_actionmanager.EntityLogicalName, new Guid(modelDetails.ActionManagerId));
         *                 statusmanagerdetails.mzk_CreateCharge = modelDetails.createCharge;
         *                 statusmanagerdetails.mzk_FlipType = new OptionSetValue(modelDetails.FlipType);
         *                 statusmanagerdetails.mzk_FulfillmentAction = modelDetails.fulfillmentAction;
         *                 statusmanagerdetails.mzk_Undo = modelDetails.Undo;
         *                 statusmanagerdetails.mzk_OrderStatus = new OptionSetValue(modelDetails.status);
         *
         *                 EntityCollection parentDetail = null;
         *
         *                 if (!string.IsNullOrEmpty(modelDetails.ParentStatusId) && detailsDict.TryGetValue(modelDetails.ParentStatusId, out parentDetail))
         *                 {
         *                     //statusmanagerdetails.mzk_ParentStatusId = new EntityReference(mzk_statusmanagerdetails.EntityLogicalName, parentDetailGUID);
         *
         *                     if (parentDetail == null)
         *                     {
         *                         parentDetail = new EntityCollection();
         *                     }
         *
         *                     parentDetail.Entities.Add(statusmanagerdetails);
         *
         *                     detailsDict[modelDetails.ParentStatusId] = parentDetail;
         *                 }
         *
         *                 //Guid detailGUID = repo.CreateEntity(statusmanagerdetails);
         *
         *                 detailsDict.Add(modelDetails.StatusId, null);
         *                 detailsObjDict.Add(modelDetails.StatusId, statusmanagerdetails);
         *
         *                 entityCollection.Entities.Add(statusmanagerdetails);
         *             }
         *
         *             foreach (KeyValuePair<string, EntityCollection> dict in detailsDict)
         *             {
         *                 if (dict.Value != null && dict.Value.Entities.Count > 0)
         *                 {
         *                     mzk_statusmanagerdetails statusmanagerdetailsObj = null;
         *
         *                     if (detailsObjDict.TryGetValue(dict.Key, out statusmanagerdetailsObj))
         *                     {
         *                         relationship = new Microsoft.Xrm.Sdk.Relationship("mzk_mzk_statusmanagerdetails_mzk_statusmanage");
         *
         *                         relationship.PrimaryEntityRole = EntityRole.Referenced;
         *
         *                         statusmanagerdetailsObj.RelatedEntities.Add(relationship, dict.Value);
         *                     }
         *                 }
         *             }
         *
         *             relationship = new Microsoft.Xrm.Sdk.Relationship("mzk_mzk_statusmanager_mzk_statusmanagerdetail");
         *
         *             statusManager.RelatedEntities.Add(relationship, entityCollection);
         *
         *             repo.CreateEntity(statusManager);
         *         }
         *     }
         *     catch (Exception ex)
         *     {
         *         throw ex;
         *     }
         *
         *     return true;
         * }*/

        public async Task <bool> saveStatusManager(StatusManagerHeader statusManagerHeader)
        {
            Guid statusManagerGUID    = Guid.Empty;
            SoapEntityRepository repo = SoapEntityRepository.GetService();

            try
            {
                mzk_statusmanager statusManager = new mzk_statusmanager();

                if (string.IsNullOrEmpty(statusManagerHeader.name))
                {
                    throw new ValidationException("Name must be filled in");
                }

                if (statusManagerHeader.caseType == 0)
                {
                    throw new ValidationException("Case type must be filled in");
                }

                if (statusManagerHeader.entityType == 0)
                {
                    throw new ValidationException("Entity type must be filled in");
                }

                if (statusManagerHeader.effectiveFrom.Date < DateTime.Now.Date)
                {
                    throw new ValidationException("Effective from must be greater or equal than today's date");
                }

                if (statusManagerHeader.effectiveTo.Date < DateTime.Now.Date)
                {
                    throw new ValidationException("Effective to must be greater or equal than today's date");
                }

                if (statusManagerHeader.effectiveTo.Date < statusManagerHeader.effectiveFrom.Date)
                {
                    throw new ValidationException("Effective to must be greater or equal than Effective from");
                }

                if (this.checkExists(statusManagerHeader))
                {
                    throw new ValidationException("Status manager for the selected entity and case type already exist for the selected date range");
                }

                statusManager.mzk_CaseType      = new OptionSetValue(statusManagerHeader.caseType);
                statusManager.mzk_EntityType    = new OptionSetValue(statusManagerHeader.entityType);
                statusManager.mzk_EffectiveFrom = statusManagerHeader.effectiveFrom;
                statusManager.mzk_EffectiveTo   = statusManagerHeader.effectiveTo;
                statusManager.mzk_name          = statusManagerHeader.name;

                statusManagerGUID = repo.CreateEntity(statusManager);

                if (statusManagerGUID != null && statusManagerGUID != Guid.Empty)
                {
                    List <StatusManager>      details     = statusManagerHeader.details;
                    Dictionary <string, Guid> detailsDict = new Dictionary <string, Guid>();

                    foreach (StatusManager modelDetails in details)
                    {
                        mzk_statusmanagerdetails statusmanagerdetails = new mzk_statusmanagerdetails();

                        if (string.IsNullOrEmpty(modelDetails.ActionManagerId))
                        {
                            throw new ValidationException("Action manager must be filled in");
                        }

                        //statusmanagerdetails.mzk_name = modelSection.Name;

                        statusmanagerdetails.mzk_StatusManagerId = new EntityReference(mzk_statusmanager.EntityLogicalName, statusManagerGUID);

                        Guid parentDetailGUID = Guid.Empty;

                        if (!string.IsNullOrEmpty(modelDetails.ParentStatusId) && detailsDict.TryGetValue(modelDetails.ParentStatusId, out parentDetailGUID))
                        {
                            statusmanagerdetails.mzk_ParentStatusId = new EntityReference(mzk_statusmanagerdetails.EntityLogicalName, parentDetailGUID);
                        }

                        statusmanagerdetails.mzk_SendORM         = modelDetails.sendOrm;
                        statusmanagerdetails.mzk_ShowEndTime     = modelDetails.showEndTime;
                        statusmanagerdetails.mzk_showflip        = modelDetails.isFlip;
                        statusmanagerdetails.mzk_ShowStartTime   = modelDetails.showStartTime;
                        statusmanagerdetails.mzk_ShowTimer       = modelDetails.showTimer;
                        statusmanagerdetails.mzk_AllowEdit       = modelDetails.allowEdit;
                        statusmanagerdetails.mzk_ActionManagerId = new EntityReference(mzk_actionmanager.EntityLogicalName, new Guid(modelDetails.ActionManagerId));
                        statusmanagerdetails.mzk_CreateCharge    = modelDetails.createCharge;

                        if (modelDetails.isFlip)
                        {
                            statusmanagerdetails.mzk_FlipType = new OptionSetValue(modelDetails.FlipType);
                        }

                        statusmanagerdetails.mzk_FulfillmentAction = modelDetails.fulfillmentAction;
                        statusmanagerdetails.mzk_Undo        = modelDetails.Undo;
                        statusmanagerdetails.mzk_OrderStatus = new OptionSetValue(modelDetails.status);

                        Guid detailGUID = repo.CreateEntity(statusmanagerdetails);

                        detailsDict.Add(modelDetails.StatusId, detailGUID);
                    }
                }
            }
            catch (Exception ex)
            {
                if (statusManagerGUID != null && statusManagerGUID != Guid.Empty)
                {
                    repo.DeleteEntity(mzk_statusmanager.EntityLogicalName, statusManagerGUID);
                }

                throw ex;
            }

            return(true);
        }