/// <summary>
        /// Запуск публикации веб-ресурсов.
        /// Определяет ид веб-ресурсов
        /// 1. в файле привязок
        /// 2. по имени веб-ресурса
        /// 3. ручное связывание
        /// </summary>
        private async Task UpdateContentAndPublishEqualByText(List <SelectedFile> selectedFiles, ConnectionData connectionData)
        {
            if (connectionData == null)
            {
                this._iWriteToOutput.WriteToOutput(connectionData, Properties.OutputStrings.NoCurrentCRMConnection);
                return;
            }

            var compareResult = await CompareController.GetWebResourcesWithType(this._iWriteToOutput, selectedFiles, OpenFilesType.EqualByText, connectionData);

            var filesToPublish = compareResult.Item2.Where(f => f.Item2 != null);

            if (!filesToPublish.Any())
            {
                this._iWriteToOutput.WriteToOutput(connectionData, Properties.OutputStrings.NothingToPublish);
                return;
            }

            // Менеджер для публикации в CRM.
            PublishManager publishHelper = new PublishManager(this._iWriteToOutput, compareResult.Item1);

            foreach (var item in filesToPublish)
            {
                publishHelper.Add(new ElementForPublish(item.Item1, item.Item2));
            }

            publishHelper.UpdateContentAndPublish();
        }
        private async Task MultiDifferenceFiles(List <SelectedFile> selectedFiles, OpenFilesType openFilesType, ConnectionData connectionData, CommonConfiguration commonConfig)
        {
            if (connectionData == null)
            {
                this._iWriteToOutput.WriteToOutput(connectionData, Properties.OutputStrings.NoCurrentCRMConnection);
                return;
            }

            if (openFilesType == OpenFilesType.All)
            {
                this._iWriteToOutput.WriteToOutput(connectionData, Properties.OutputStrings.ShowingDifferenceIsNotAllowedForFormat1, openFilesType.ToString());
                return;
            }

            var compareResult = await CompareController.GetWebResourcesWithType(this._iWriteToOutput, selectedFiles, openFilesType, connectionData);

            var listFilesToDifference = compareResult.Item2.Where(f => f.Item2 != null);

            if (!listFilesToDifference.Any())
            {
                this._iWriteToOutput.WriteToOutput(connectionData, Properties.OutputStrings.NoFilesForDifference);
                return;
            }

            this._iWriteToOutput.WriteToOutput(connectionData, string.Empty);
            this._iWriteToOutput.WriteToOutput(connectionData, Properties.OutputStrings.StartingCompareProgramForCountFilesFormat1, listFilesToDifference.Count());

            foreach (var item in listFilesToDifference.OrderBy(file => file.Item1.FilePath))
            {
                var selectedFile = item.Item1;
                var webresource  = item.Item2;

                if (webresource != null)
                {
                    var contentWebResource = webresource.Content;

                    var webResourceName = webresource.Name;

                    var array = Convert.FromBase64String(contentWebResource);

                    string tempFilePath = FileOperations.GetNewTempFilePath(webResourceName, selectedFile.Extension);

                    File.WriteAllBytes(tempFilePath, array);

                    string file1      = selectedFile.FilePath;
                    string fileTitle1 = selectedFile.FileName;

                    string file2      = tempFilePath;
                    string fileTitle2 = connectionData.Name + "." + selectedFile.FileName + " - " + tempFilePath;

                    this._iWriteToOutput.ProcessStartProgramComparer(file1, file2, fileTitle1, fileTitle2);
                }
            }
        }
Пример #3
0
        private async Task OpenFiles(List <SelectedFile> selectedFiles, OpenFilesType openFilesType, bool inTextEditor, ConnectionData connectionData, CommonConfiguration commonConfig)
        {
            if (connectionData == null)
            {
                this._iWriteToOutput.WriteToOutput(connectionData, Properties.OutputStrings.NoCurrentCRMConnection);
                return;
            }

            var compareResult = await CompareController.GetWebResourcesWithType(this._iWriteToOutput, selectedFiles, openFilesType, connectionData);

            var filesToOpen = compareResult.Item2;

            if (filesToOpen.Any())
            {
                var orderEnumrator = filesToOpen.Select(s => s.Item1).OrderBy(s => s.FriendlyFilePath);

                if (inTextEditor)
                {
                    foreach (var item in orderEnumrator)
                    {
                        this._iWriteToOutput.WriteToOutputFilePathUri(connectionData, item.FilePath);
                        this._iWriteToOutput.OpenFileInTextEditor(connectionData, item.FilePath);
                    }
                }
                else
                {
                    foreach (var item in orderEnumrator)
                    {
                        this._iWriteToOutput.WriteToOutputFilePathUri(connectionData, item.FilePath);
                        this._iWriteToOutput.OpenFileInVisualStudio(connectionData, item.FilePath);
                    }
                }
            }
            else
            {
                this._iWriteToOutput.WriteToOutput(connectionData, "No files for open.");
                this._iWriteToOutput.ActivateOutputWindow(connectionData);
            }
        }
        public static async Task <Tuple <IOrganizationServiceExtented, TupleList <SelectedFile, WebResource> > > GetWebResourcesWithType(IWriteToOutput _iWriteToOutput, List <SelectedFile> selectedFiles, OpenFilesType openFilesType, ConnectionData connectionData)
        {
            IOrganizationServiceExtented service = null;

            TupleList <SelectedFile, WebResource> filesToOpen = new TupleList <SelectedFile, WebResource>();

            if (openFilesType == OpenFilesType.All)
            {
                foreach (var item in selectedFiles)
                {
                    filesToOpen.Add(item, null);
                }
            }
            else if (openFilesType == OpenFilesType.NotExistsInCrmWithoutLink ||
                     openFilesType == OpenFilesType.NotExistsInCrmWithLink
                     )
            {
                var compareResult = await FindFilesNotExistsInCrmAsync(_iWriteToOutput, selectedFiles, connectionData);

                service = compareResult.Item1;

                if (openFilesType == OpenFilesType.NotExistsInCrmWithoutLink)
                {
                    filesToOpen.AddRange(compareResult.Item2.Select(f => Tuple.Create(f, (WebResource)null)));
                }
                else if (openFilesType == OpenFilesType.NotExistsInCrmWithLink)
                {
                    filesToOpen.AddRange(compareResult.Item3.Select(f => Tuple.Create(f.Item1, f.Item2)));
                }
            }
            else if (openFilesType == OpenFilesType.EqualByText ||
                     openFilesType == OpenFilesType.NotEqualByText
                     )
            {
                var compareResult = await ComparingFilesAndWebResourcesAsync(_iWriteToOutput, selectedFiles, connectionData, false);

                service = compareResult.Item1;

                if (openFilesType == OpenFilesType.EqualByText)
                {
                    filesToOpen.AddRange(compareResult.Item2);
                }
                else if (openFilesType == OpenFilesType.NotEqualByText)
                {
                    filesToOpen.AddRange(compareResult.Item3.Select(f => Tuple.Create(f.Item1, f.Item2)));
                }
            }
            else if (openFilesType == OpenFilesType.WithInserts ||
                     openFilesType == OpenFilesType.WithDeletes ||
                     openFilesType == OpenFilesType.WithComplex ||
                     openFilesType == OpenFilesType.WithMirror ||
                     openFilesType == OpenFilesType.WithMirrorInserts ||
                     openFilesType == OpenFilesType.WithMirrorDeletes ||
                     openFilesType == OpenFilesType.WithMirrorComplex
                     )
            {
                var compareResult = await CompareController.ComparingFilesAndWebResourcesAsync(_iWriteToOutput, selectedFiles, connectionData, true);

                service = compareResult.Item1;

                if (openFilesType == OpenFilesType.WithInserts)
                {
                    filesToOpen.AddRange(compareResult.Item3.Where(s => s.Item3.IsOnlyInserts).Select(f => Tuple.Create(f.Item1, f.Item2)));
                }
                else if (openFilesType == OpenFilesType.WithDeletes)
                {
                    filesToOpen.AddRange(compareResult.Item3.Where(s => s.Item3.IsOnlyDeletes).Select(f => Tuple.Create(f.Item1, f.Item2)));
                }
                else if (openFilesType == OpenFilesType.WithComplex)
                {
                    filesToOpen.AddRange(compareResult.Item3.Where(s => s.Item3.IsComplexChanges).Select(f => Tuple.Create(f.Item1, f.Item2)));
                }
                else if (openFilesType == OpenFilesType.WithMirror)
                {
                    filesToOpen.AddRange(compareResult.Item3.Where(s => s.Item3.IsMirror).Select(f => Tuple.Create(f.Item1, f.Item2)));
                }
                else if (openFilesType == OpenFilesType.WithMirrorInserts)
                {
                    filesToOpen.AddRange(compareResult.Item3.Where(s => s.Item3.IsMirrorWithInserts).Select(f => Tuple.Create(f.Item1, f.Item2)));
                }
                else if (openFilesType == OpenFilesType.WithMirrorDeletes)
                {
                    filesToOpen.AddRange(compareResult.Item3.Where(s => s.Item3.IsMirrorWithDeletes).Select(f => Tuple.Create(f.Item1, f.Item2)));
                }
                else if (openFilesType == OpenFilesType.WithMirrorComplex)
                {
                    filesToOpen.AddRange(compareResult.Item3.Where(s => s.Item3.IsMirrorWithComplex).Select(f => Tuple.Create(f.Item1, f.Item2)));
                }
            }

            return(Tuple.Create(service, filesToOpen));
        }