/// <summary>
 ///     Synchronizes the reports from source to destination.
 /// </summary>
 /// <param name="context">The context.</param>
 public override void ExecuteProcess(XrmActivityContext context)
 {
     AddComponentsToSolution(context,
         EntityName.connectionrole,
         SolutionPackageType.Entity,
         ComponentType.ConnectionRole);
 }
 /// <summary>
 ///     Synchronizes the contract templates from source to destination.
 /// </summary>
 /// <param name="context">The context.</param>]
 public override void ExecuteProcess(XrmActivityContext context)
 {
     AddComponentsToSolution(context,
         EntityName.contracttemplate,
         SolutionPackageType.Entity,
         ComponentType.ContractTemplate);
 }
Beispiel #3
0
        public bool Execute(XrmConfiguration configuration)
        {
            try
            {
                "initializing connections.".Trace();
                var context = new XrmActivityContext()
                {
                    Configuration = configuration,
                    Source = new XrmConnectionManager().GetConnection(configuration.DataSources["source"]),
                    Destination = new XrmConnectionManager().GetConnection(configuration.DataSources["destination"])
                };

                foreach (var component in Components.OrderBy(c => c.Metadata.Index))
                {
                    "processing {0}".Trace(component.Metadata.Description);
                    component.Value.ExecuteProcess(context);
                }

                return true;
            }
            catch (FaultException<OrganizationServiceFault> orgex)
            {
                orgex.Message.TraceError(orgex);
            }
            catch (Exception ex)
            {
                ex.Message.TraceError(ex);
            }

            return false;
        }
Beispiel #4
0
        /// <summary>
        ///     Adds the components to solution.
        /// </summary>
        /// <param name="sourceService">The source service.</param>
        /// <param name="destinationService">The destination service.</param>
        /// <param name="entityName">Name of the entity.</param>
        /// <param name="solutionComponentType">Type of the solution component.</param>
        /// <param name="componentType">Type of the component.</param>
        /// <param name="destinationDataSourceElement">The destination data source element.</param>
        /// <param name="context">The xrm activity context</param>
        /// <param name="noOfThreads">The no of threads.</param>
        /// <param name="checkManaged">
        ///     if set to <c>true</c> [check if component is managed and exclude from adding to the
        ///     solution].
        /// </param>
        public static void AddComponentsToSolution(string entityName,
            SolutionPackageType solutionComponentType,
            ComponentType componentType,
            XrmActivityContext context,
            bool checkManaged = true)
        {
            var columns = XrmMetadataHelperFunctions.GetNonSystemColumns(context.Source, entityName);

            var sourceEntities = XrmHelperFunctions.RetrieveMultipleByEntityName(
                context.Source, 
                entityName, 
                true,
                columns);

            var destinationEntities = XrmHelperFunctions.RetrieveMultipleByEntityName(
                context.Destination, 
                entityName,
                true,
                columns);

            AddComponentsToSolution(
                sourceEntities,
                destinationEntities,
                solutionComponentType,
                componentType,
                context,
                checkManaged);
        }
Beispiel #5
0
 /// <summary>
 /// Executes the process.
 /// </summary>
 /// <param name="context">The context.</param>
 public override void ExecuteProcess(XrmActivityContext context)
 {
     XrmMetadataHelperFunctions.AddToSolutions(
         context.Source,
         context.Configuration.Solutions,
         ComponentType.DisplayString, 
         Guid.Empty, true);
 }
        /// <summary>
        ///     Synchronizes the entities from source to destination.
        /// </summary>
        /// <param name="context">The context.</param>
        public override void ExecuteProcess(XrmActivityContext context)
        {
            var sourceOptionSetMetadataBase = XrmMetadataHelperFunctions.GetAllOptionSetMetadata(context.Source);
            var destinationOptionSetMetadataBase = XrmMetadataHelperFunctions.GetAllOptionSetMetadata(context.Destination);

            XrmMetadataHelperFunctions.ProcessTask
            (
                sourceOptionSetMetadataBase,
                 () =>
                 {
                     return new[] { context.Source, context.Destination };
                 },
                (sourceOptionSet, proxyCollection) =>
                {
                    if (!sourceOptionSet.IsCustomizable.Value) return;

                    if (sourceOptionSet.MetadataId != null &&
                        XrmHelperFunctions.IsExcemptedFromProcessing(sourceOptionSet.Name,
                            sourceOptionSet.MetadataId.Value,
                            context.Configuration.Exceptions))
                        return;

                    "cheking {0}".TraceVerbose(sourceOptionSet.Name);

                    if (sourceOptionSet.IsManaged != null && sourceOptionSet.IsManaged.Value) return;


                    var destinationOptionSet = destinationOptionSetMetadataBase.ContainsKey(sourceOptionSet.Name)
                        ? destinationOptionSetMetadataBase[sourceOptionSet.Name]
                        : null;

                    var isDifferent =
                        XrmMetadataHelperFunctions.FindDifferenceBetweenObjects
                        (
                            sourceOptionSet,
                            destinationOptionSet,
                            sourceOptionSet.Name,
                            ComponentType.OptionSet,
                            context
                        );


                    if (!isDifferent) return;

                    if (sourceOptionSet.MetadataId != null)
                    {
                        XrmMetadataHelperFunctions.AddToSolutions
                        (
                            proxyCollection[0],
                            context.Configuration.Solutions,
                            ComponentType.OptionSet,
                            sourceOptionSet.MetadataId.Value
                        );
                    }
                },
                null,
                context.Configuration.Threads);
        }
 public void AddComponentsToSolution(XrmActivityContext context, string entityName,
     SolutionPackageType packageType,
     ComponentType componentType)
 {
     XrmMetadataDiff.AddComponentsToSolution(
         EntityName.kbarticletemplate,
         SolutionPackageType.Entity,
         ComponentType.KbArticleTemplate,
         context);
 }
Beispiel #8
0
 /// <summary>
 /// Adds the ribbon definition to solution.
 /// </summary>
 /// <param name="context">The context.</param>
 public override void ExecuteProcess(XrmActivityContext context)
 {
     AddComponentsToSolution
     (
        context,
        EntityName.ribboncustomization,
        SolutionPackageType.Entity,
        ComponentType.RibbonCustomization
     );
 }
Beispiel #9
0
 /// <summary>
 /// Synchronizes the workflows from source to destination.
 /// </summary>
 /// <param name="context">The context.</param>
 public override void ExecuteProcess(XrmActivityContext context)
 {
     AddComponentsToSolution
     (
         context,
         EntityName.workflow,
         SolutionPackageType.Entity,
         ComponentType.Workflow
     );
 }
 /// <summary>
 ///     Synchronizes the field security roles from source to destination.
 /// </summary>
 /// <param name="context">The context.</param>
 public override void ExecuteProcess(XrmActivityContext context)
 {
     AddComponentsToSolution
     (
         context,
         EntityName.fieldsecurityprofile, 
         SolutionPackageType.SecurityRoles, 
         ComponentType.FieldSecurityProfile
     );
 }
Beispiel #11
0
        /// <summary>
        /// Adds the site map to solution.
        /// </summary>
        /// <param name="context">The context.</param>
        public override void ExecuteProcess(XrmActivityContext context)
        {
            AddComponentsToSolution
            (  
                context,
               EntityName.sitemap,
               SolutionPackageType.Entity,
               ComponentType.SiteMap
            );

        }
Beispiel #12
0
  /// <summary>
  ///     Synchronizes the security roles from source to destination.
  /// </summary>
  /// <param name="context">The context.</param>
 
  public override void ExecuteProcess(XrmActivityContext context)
  {
      var sourceDashboards = XrmMetadataHelperFunctions.GetDashboards(context.Source);
      var destinationDashboards = XrmMetadataHelperFunctions.GetDashboards(context.Destination);
     
      AddComponentsToSolution(context,
          sourceDashboards,
          destinationDashboards,
          SolutionPackageType.Entity,
          ComponentType.SystemForm);
  }
Beispiel #13
0
        public void AddComponentsToSolution(XrmActivityContext context,
                Dictionary<Guid ,Entity> sourceItems,
                Dictionary<Guid, Entity> destinationItems,
                SolutionPackageType solutionPackageType,
                ComponentType componentType)
        {

            XrmMetadataDiff.AddComponentsToSolution(
               sourceItems,
               destinationItems,
               SolutionPackageType.Entity,
               ComponentType.SystemForm,
               context);
        }
Beispiel #14
0
        /// <summary>
        ///     Synchronizes the entities from source to destination.
        /// </summary>
        /// <param name="context">The context.</param>

        public override void ExecuteProcess(XrmActivityContext context)
        {

            "loading metadata from source.".Trace();
            var sourceEntitities = XrmMetadataHelperFunctions.GetAllEntityMetadataDictionary(context.Source,
                EntityFilters.All);

            "loading metadata from destination.".Trace();
            var destinationEntities = XrmMetadataHelperFunctions.GetAllEntityMetadataDictionary(context.Destination,
                EntityFilters.All);

            XrmMetadataHelperFunctions.ProcessTask(sourceEntitities,
                () => new[] { context.Source, context.Destination },
                (sourceEntity, proxyCollection) =>
                {
                    if (!sourceEntity.IsCustomizable.Value) return;
                    if (sourceEntity.IsImportable != null && !sourceEntity.IsImportable.Value) return;

                    if (sourceEntity.MetadataId != null &&
                        XrmHelperFunctions.IsExcemptedFromProcessing(sourceEntity.LogicalName,
                            sourceEntity.MetadataId.Value,
                            context.Configuration.Exceptions))
                        return;

                    "cheking {0}".TraceVerbose(sourceEntity.LogicalName);

                    var destinationEntity = destinationEntities.ContainsKey(sourceEntity.LogicalName)
                        ? destinationEntities[sourceEntity.LogicalName]
                        : null;

                    var isDifferent =
                        XrmMetadataHelperFunctions.FindDifferenceBetweenObjects
                        (
                            sourceEntity,
                            destinationEntity,
                            sourceEntity.LogicalName,
                            ComponentType.Entity,
                            context
                        );

                    if (!isDifferent)
                    {
                        isDifferent |= XrmMetadataHelperFunctions.FindDifferenceBetweenObjects(
                            XrmMetadataHelperFunctions.GetSystemForm(proxyCollection[0], sourceEntity),
                            XrmMetadataHelperFunctions.GetSystemForm(proxyCollection[1], destinationEntity),
                            sourceEntity.LogicalName + " - Forms",
                            ComponentType.Entity,
                            context);
                    }

                    if (!isDifferent) return;

                    if (sourceEntity.MetadataId != null)
                    {
                        XrmMetadataHelperFunctions.AddToSolutions
                        (
                            proxyCollection[0],
                            context.Configuration.Solutions,
                            ComponentType.Entity,
                            sourceEntity.MetadataId.Value
                        );
                    }
                },
                null,
                context.Configuration.Threads);
        }
Beispiel #15
0
        /// <summary>
        /// Exports the XRM solution.
        /// </summary>
        /// <param name="context">The context.</param>
        
        public override void ExecuteProcess(XrmActivityContext context)
        {
            foreach (SolutionElement solution in context.Configuration.Solutions)
            {
                if (!solution.IsEnabled) continue;
                var uniqueName = solution.Name.ToUniqueName();
                
                var exportSolutionRequest = new ExportSolutionRequest
                {
                    Managed = solution.IsManaged,
                    ExportAutoNumberingSettings = true,
                    ExportCalendarSettings = true,
                    ExportCustomizationSettings = true,
                    ExportEmailTrackingSettings = true,
                    ExportGeneralSettings = true,
                    ExportIsvConfig = true,
                    ExportMarketingSettings = true,
                    ExportOutlookSynchronizationSettings = true,
                    SolutionName = uniqueName
                };


                var exportSolutionResponse = (ExportSolutionResponse)context.Source.Execute(exportSolutionRequest);

                "export of the solution {0} completed.".Trace(uniqueName);
                var exportedXmlFromSource = exportSolutionResponse.ExportSolutionFile;

                if (!string.IsNullOrEmpty(solution.ExportDirectory))
                {
                    try
                    {
                        if (!Directory.Exists(solution.ExportDirectory))
                            Directory.CreateDirectory(solution.ExportDirectory);

                        var fileName = uniqueName + "_" +
                            (Convert.ToDouble(solution.Version)).ToString(CultureInfo.InvariantCulture).ToUniqueName() +
                            ((solution.IsManaged) ? "_managed.zip" : "_unmanaged.zip");

                        using (
                            var fileStream =
                                new FileStream(Path.Combine(solution.ExportDirectory, fileName),
                                    FileMode.Create))
                        {
                            fileStream.Write(exportedXmlFromSource, 0, exportedXmlFromSource.Length);
                            "{0} exported succesfully to path {1}".Trace(uniqueName,
                                solution.ExportDirectory);
                        }

                    }
                    catch (IOException ioex)
                    {
                        ioex.Message.TraceError(ioex);
                    }
                }

                try
                {

                    if (!solution.Publish) continue;
                    var impSolReq = new ImportSolutionRequest()
                    {
                        CustomizationFile = exportedXmlFromSource,
                        OverwriteUnmanagedCustomizations = true,
                        PublishWorkflows = false
                    };

                    "import solution {0} to destination".Trace(uniqueName);
                    context.Destination.Execute(impSolReq);
                    "solution import completed without issue.".Trace();

                    "publishing solution {0}".Trace(uniqueName);
                    if (!solution.IsManaged)
                        context.Destination.Execute(new PublishAllXmlRequest());

                    "the solution {0} has been published successfully.".Trace(uniqueName);
                }
                catch (FaultException<OrganizationServiceFault> orgException)
                {
                    orgException.Message.TraceError(orgException);
                }
            }
        }
Beispiel #16
0
 public abstract void ExecuteProcess(XrmActivityContext context);
Beispiel #17
0
        /// <summary>
        /// Synchronizes the entities from source to destination.
        /// </summary>
        /// <param name="context">The context.</param>
        public override void ExecuteProcess(XrmActivityContext context)
        {
            if (string.IsNullOrEmpty(context.Configuration.ReportDirectory)) return;

            var changeNo = string.Format("{0:yyyyMMdd}", DateTime.Now);

            var fileName = string.Format("{0}\\{1}.html", context.Configuration.ReportDirectory, changeNo);
            if (!Directory.Exists(context.Configuration.ReportDirectory)) 
                Directory.CreateDirectory(context.Configuration.ReportDirectory);

            if (File.Exists(fileName)) File.Delete(fileName);

            using (var htmlWriter = new StreamWriter(new FileStream(fileName, FileMode.Create)))
            {
                htmlWriter.WriteLine("<html>");
                htmlWriter.WriteLine("<style> body { margin:10px } </style>");
                htmlWriter.WriteLine("<body>");

                htmlWriter.WriteLine("<h1>Change Report</h1>");

                foreach (DataSourceElement element in context.Configuration.DataSources)
                    htmlWriter.WriteLine("<h4>>>" + element.UniqueName + " [" + element.Url +  "]</h4>");

                htmlWriter.WriteLine("<h3>" + DateTime.Now.ToLongDateString() + "</h3>");
                htmlWriter.WriteLine("<hr />");

                foreach (var change in context.ChangeList)
                {
                    if (change.Value.Count == 0) continue;
                    htmlWriter.WriteLine("<h3>" + change.Key.Key + "</h3>");
                    htmlWriter.WriteLine("<hr/>");

                    var diffList = change.Value.OrderBy(c => c.DiffType);

                    htmlWriter.WriteLine("<table>");
                    foreach (var diff in diffList)
                    {
                        htmlWriter.WriteLine("<tr>");
                        var schemaName = diff.Key.Replace("Metadata", "");
                        schemaName = schemaName.Replace("Attributes", "");
                        schemaName = schemaName.Replace("OneToManyRelationships", "");
                        schemaName = schemaName.Replace("ManyToManyRelationships", "");
                        schemaName = schemaName.Replace("ManyToOneRelationships", "");
                        schemaName = schemaName.Replace("ArrayOfEntity", "");
                        schemaName = schemaName.Trim();

                        htmlWriter.Write("<td><b>[" + diff.DiffType + "]\t</b></td>");
                        htmlWriter.Write("<td><i>" + schemaName + "</i>\t</td>");
                        htmlWriter.Write("<td><b>" + diff.Value + "</b></td>");

                        htmlWriter.WriteLine("</tr>");
                    }

                    htmlWriter.WriteLine("</table>");
                    htmlWriter.WriteLine("<hr/>");
                }

                htmlWriter.WriteLine("</html>");
                htmlWriter.WriteLine("</body>");
            }

            Process.Start(fileName);
        }
Beispiel #18
0
        /// <summary>
        /// Adds the components to solution.
        /// </summary>
        /// <param name="sourceService">The source service.</param>
        /// <param name="destinationService">The destination service.</param>
        /// <param name="sourceEntities">The source entities.</param>
        /// <param name="destinationEntities">The destination entities.</param>
        /// <param name="destinationDataSourceElement">The destination data source element.</param>
        /// <param name="solutionComponentType">Type of the solution component.</param>
        /// <param name="componentType">Type of the component.</param>
        /// <param name="context">The context.</param>
        /// <param name="noOfThreads">The no of threads.</param>
        /// <param name="checkManaged">if set to <c>true</c> [check managed].</param>
        /// <param name="checkDifference">if set to <c>true</c> [check difference].</param>
        public static void AddComponentsToSolution(
            Dictionary<Guid, Entity> sourceEntities,
            Dictionary<Guid, Entity> destinationEntities,
            SolutionPackageType solutionComponentType,
            ComponentType componentType,
            XrmActivityContext context,
            bool checkManaged = true,
            bool checkDifference = true)
        {
            
            if (sourceEntities.Count == 0) return;

            var primaryAttributes = XrmMetadataHelperFunctions.GetEntityPrimaryColumns(context.Source,
                sourceEntities.FirstOrDefault().Value.LogicalName);

            XrmMetadataHelperFunctions.ProcessTask(sourceEntities,
                () => context.Source,
                (sourceEntity, sourceProxy) =>
                {
                    var description = (primaryAttributes.Value != null)
                        ?  (string) sourceEntity[primaryAttributes.Value]
                        : sourceEntity.LogicalName + "[" + sourceEntity.Id + "]";

                    if (XrmHelperFunctions.IsExcemptedFromProcessing(sourceEntity.LogicalName,
                       sourceEntity.Id,
                       context.Configuration.Exceptions)) return;

                    if (primaryAttributes.Value != null)
                        ">> {0}".TraceVerbose(description);

                    if (checkManaged &&
                        sourceEntity.Contains(systementity.ismanaged) &&
                        (bool) sourceEntity[systementity.ismanaged])
                        return;


                    var destinationEntity = destinationEntities.ContainsKey(sourceEntity.Id)
                        ? destinationEntities[sourceEntity.Id]
                        : null;


                    if (checkDifference)
                    {
                        var isDifferent =
                            XrmMetadataHelperFunctions.FindDifferenceBetweenObjects
                            (
                                sourceEntity,
                                destinationEntity, 
                                description, 
                                componentType,
                                context
                            );

                        if (!isDifferent) return;
                    }

                    XrmMetadataHelperFunctions.AddToSolutions(sourceProxy,
                        context.Configuration.Solutions,
                        componentType,
                        sourceEntity.Id);
                },
                null,
                context.Configuration.Threads);
        }