/// <summary>
        /// Method check if there are master solutions available by solutions id and if present returns true.
        /// </summary>
        /// <param name="service">Organization service</param>
        /// <param name="solutionId">CRM Solution Id</param>
        /// <param name="tracingService">Tracing Service to trace error</param>
        /// <returns>returns boolean value</returns>
        public static bool IsDeletable(IOrganizationService service, string solutionId, ITracingService tracingService)
        {
            bool             isDeletable  = true;
            Guid             solutionGuid = new Guid(solutionId);
            EntityCollection solutionlist = SolutionHelper.RetrieveSolutionById(service, solutionGuid, tracingService);

            if (solutionlist.Entities.Count == 0)
            {
                isDeletable = false;
            }

            return(isDeletable);
        }
        /// <summary>
        /// Method check if there are CRM Solutions is available by Master Solution Id, if available then returns true.
        /// </summary>
        /// <param name="service">Organization service</param>
        /// <param name="solutionId"> CRM Solutions Guid</param>
        /// <param name="tracingService">Tracing Service to trace error</param>
        /// <returns>returns boolean value</returns>
        public static bool IsSolutionAvaialable(IOrganizationService service, Guid solutionId, ITracingService tracingService)
        {
            bool isAvailable = false;

            EntityCollection masterRecords = SolutionHelper.RetrieveMasterSolutionById(service, solutionId.ToString(), tracingService);

            if (masterRecords.Entities.Count > 0)
            {
                isAvailable = true;
            }

            return(isAvailable);
        }
        /// <summary>
        /// To delete Merge Solution records.
        /// </summary>
        /// <param name="service">Organization service</param>
        /// <param name="sourceControlQueue">Dynamic Source Control entity GUID</param>
        /// <param name="tracingService">Tracing Service to trace error</param>
        public static void CreateSolutionDetail(IOrganizationService service, syed_sourcecontrolqueue sourceControlQueue, ITracingService tracingService)
        {
            //Copy feilds from Template Record.
            EntityCollection copyDynamicsTemplate = SolutionHelper.RetrieveDynamicsSourceControlTemplate(service, tracingService);

            foreach (syed_sourcecontrolqueue syed_Sourcecontrolqueue in copyDynamicsTemplate.Entities)
            {
                syed_sourcecontrolqueue _sourcecontrolqueue = new syed_sourcecontrolqueue();
                _sourcecontrolqueue.syed_Branch        = syed_Sourcecontrolqueue.syed_Branch;
                _sourcecontrolqueue.syed_RemoteName    = syed_Sourcecontrolqueue.syed_RemoteName;
                _sourcecontrolqueue.syed_RepositoryUrl = syed_Sourcecontrolqueue.syed_RepositoryUrl;
                _sourcecontrolqueue.syed_SourceControl = syed_Sourcecontrolqueue.syed_SourceControl;
                _sourcecontrolqueue.Id = sourceControlQueue.Id;
                _sourcecontrolqueue.syed_IsShedulled           = syed_Sourcecontrolqueue.syed_IsShedulled;
                _sourcecontrolqueue.syed_overwritesolutionstxt = syed_Sourcecontrolqueue.syed_overwritesolutionstxt;
                service.Update(_sourcecontrolqueue);
                break;
            }

            //Copy Master Solution Record from Template.
            EntityCollection copyTemplate = SolutionHelper.RetrieveMasterSolutionTemplate(service, tracingService);

            foreach (syed_solutiondetail solutionDetail in copyTemplate.Entities)
            {
                ExecuteOperations.CreateSolutionDetail(service, solutionDetail, sourceControlQueue);
                break;
            }

            EntityCollection crmSolution = SolutionHelper.RetrieveMasterSolutionById(service, sourceControlQueue.syed_CheckInBySolutionId, tracingService);

            if (crmSolution.Entities.Count > 0)
            {
                foreach (syed_mastersolutions mastersolutions in crmSolution.Entities)
                {
                    ExecuteOperations.CreateSolutionDetail(service, mastersolutions, sourceControlQueue);
                    break;
                }
            }
            else
            {
                EntityCollection solutionCollection = SolutionHelper.RetrieveSolutionById(service, new Guid(sourceControlQueue.syed_CheckInBySolutionId), tracingService);
                foreach (Solution sol in solutionCollection.Entities)
                {
                    Guid id = ExecuteOperations.CreateMasterSolution(service, sol);
                    syed_mastersolutions syed_Mastersolutions = service.Retrieve(syed_mastersolutions.EntityLogicalName.ToString(), id, new ColumnSet(true)).ToEntity <syed_mastersolutions>();
                    ExecuteOperations.CreateSolutionDetail(service, syed_Mastersolutions, sourceControlQueue);
                    break;
                }
            }
        }
        /// <summary>
        /// To sync Master Solution and CRM Solutions.
        /// </summary>
        /// <param name="service">Organization service</param>
        /// <param name="tracingService">Tracing Service to trace error</param>
        public static void SyncMasterSolutiontoCRMSolution(IOrganizationService service, ITracingService tracingService)
        {
            EntityCollection solutionlist = SolutionHelper.FetchCrmSolutions(service, tracingService);

            if (solutionlist.Entities.Count > 0)
            {
                foreach (Solution solution in solutionlist.Entities)
                {
                    CreateSolutionRecords(service, solution, tracingService);
                }
            }

            DeleteSolution(service, tracingService);
        }
Example #5
0
        /// <summary>
        /// To update comma separated solution list in Dynamic Source Control entity.
        /// </summary>
        /// <param name="service">Organization service</param>
        /// <param name="sourceControlId">Dynamic Source Control entity GUID</param>
        /// <param name="tracingService">Tracing Service to trace error</param>
        private static void UpdateListToSourceControl(IOrganizationService service, Guid sourceControlId, ITracingService tracingService)
        {
            EntityCollection associatedRecordList = null;
            string           listOfSolution       = string.Empty;
            string           solutionName         = string.Empty;

            associatedRecordList = SolutionHelper.RetrieveSolutionDetailsToBeMergedByListOfSolutionId(service, sourceControlId, tracingService);
            listOfSolution       = ExecuteOperations.GetCommaSeparatedListofSolution(service, associatedRecordList, tracingService);
            associatedRecordList = SolutionHelper.RetrieveMasterSolutionDetailsByListOfSolutionId(service, sourceControlId, tracingService);
            solutionName         = ExecuteOperations.GetCommaSeparatedListofMaster(service, associatedRecordList, tracingService);
            syed_sourcecontrolqueue sourceControlQueue = new syed_sourcecontrolqueue();

            sourceControlQueue.syed_sourcecontrolqueueId = sourceControlId;
            sourceControlQueue.syed_SourcenSolutions     = listOfSolution;
            sourceControlQueue.syed_SolutionName         = solutionName;
            service.Update(sourceControlQueue);
        }
        /// <summary>
        /// To Delete Master Solution.
        /// </summary>
        /// <param name="service">Organization service</param>
        /// <param name="tracingService">Tracing Service to trace error</param>
        public static void DeleteSolution(IOrganizationService service, ITracingService tracingService)
        {
            EntityCollection masterSolution = SolutionHelper.RetrieveMasterSolutions(service, tracingService);

            if (masterSolution.Entities.Count > 0)
            {
                foreach (syed_mastersolutions mastersolutions in masterSolution.Entities)
                {
                    if (mastersolutions.syed_SolutionId != null)
                    {
                        string solutionID  = mastersolutions.syed_SolutionId.ToString();
                        bool   isdeletable = IsDeletable(service, solutionID, tracingService);

                        if (isdeletable == false)
                        {
                            service.Delete(mastersolutions.LogicalName, mastersolutions.syed_mastersolutionsId.Value);
                        }
                    }
                }
            }
        }