/// <summary>
 /// Обработать экспорт реквизита.
 /// </summary>
 /// <param name="path">Путь к папке с моделью.</param>
 /// <param name="requisite">Обрабатываемый реквизит.</param>
 /// <param name="detailIndex">Индекс детального раздела.</param>
 protected override void ProcessRequisiteExport(string path, RequisiteModel requisite, int detailIndex)
 {
     if (TransformerEnvironment.IsRussianCodePage())
     {
         if (requisite.Code == "Текст")
         {
             this.ExportTextToFile(GetTextFileName(path), requisite.DecodedText);
         }
         if (requisite.Code == "Примечание")
         {
             this.ExportTextToFile(GetCommentFileName(path), requisite.DecodedText);
         }
     }
     if (TransformerEnvironment.IsEnglishCodePage())
     {
         if (requisite.Code == "Text")
         {
             this.ExportTextToFile(GetTextFileName(path), requisite.DecodedText);
         }
         if (requisite.Code == "Note")
         {
             this.ExportTextToFile(GetCommentFileName(path), requisite.DecodedText);
         }
     }
 }
Example #2
0
        /// <summary>
        /// Импортировать реквизиты, которые надо импортировать.
        /// </summary>
        /// <param name="path">Путь к папке с моделью.</param>
        /// <param name="requisites">Список реквизитов.</param>
        /// <param name="detailIndex">Индекс детального раздела.</param>
        protected override void ImportRequisites(string path, List <RequisiteModel> requisites, int detailIndex = 0)
        {
            var commentRequisite = RequisiteModel.CreateFromFile("ISBSearchCondition", Path.Combine(path, StructureFileName));

            commentRequisite.DecodedValue = DfmConverter.DeConvert(commentRequisite.DecodedValue);
            requisites.Add(commentRequisite);
        }
Example #3
0
 /// <summary>
 /// Обработать экспорт реквизита.
 /// </summary>
 /// <param name="path">Путь к папке с моделью</param>
 /// <param name="requisite">Обрабатываемый реквизит.</param>
 /// <param name="detailIndex">Индекс детального раздела.</param>
 protected override void ProcessRequisiteExport(string path, RequisiteModel requisite, int detailIndex)
 {
     if ((requisite.Name == "ISBSearchCondition") && !(string.IsNullOrWhiteSpace(requisite.DecodedValue)))
     {
         var decodedText = DfmConverter.Convert(requisite.DecodedValue);
         ExportTextToFile(Path.Combine(path, StructureFileName), decodedText);
     }
 }
Example #4
0
 /// <summary>
 /// Импортировать реквизиты, которые надо импортировать.
 /// </summary>
 /// <param name="path">Путь к папке с моделью.</param>
 /// <param name="requisites">Список реквизитов.</param>
 /// <param name="detailIndex">Индекс детального раздела.</param>
 protected override void ImportRequisites(string path, List <RequisiteModel> requisites, int detailIndex = 0)
 {
     if (detailIndex == 0)
     {
         var commentRequisiteCode = TransformerEnvironment.IsRussianCodePage() ? "Примечание" : "Note";
         var commentRequisite     = RequisiteModel.CreateFromFile(commentRequisiteCode, GetCommentFileName(path));
         requisites.Add(commentRequisite);
     }
 }
 /// <summary>
 /// Обработать экспорт реквизита.
 /// </summary>
 /// <param name="path">Путь к папке с моделью</param>
 /// <param name="requisite">Обрабатываемый реквизит.</param>
 /// <param name="detailIndex">Индекс детального раздела.</param>
 protected override void ProcessRequisiteExport(string path, RequisiteModel requisite, int detailIndex)
 {
     if ((requisite.Name == "ISBEvent") && !(string.IsNullOrWhiteSpace(requisite.Value)))
     {
         var encodedText = File.ReadAllText(Path.Combine(Path.GetDirectoryName(InputFile), requisite.Value));
         var encoding    = TransformerEnvironment.CurrentEncoding;
         var decodedText = encoding.GetString(Convert.FromBase64String(encodedText));
         this.ExportTextToFile(Path.Combine(path, CalculationFileName), decodedText);
     }
 }
        /// <summary>
        /// Импортировать текстовый реквизит из папки.
        /// </summary>
        /// <param name="requisites">Список реквизитов.</param>
        /// <param name="codeRequisiteCode">Код реквизита с кодом.</param>
        /// <param name="textRequisiteCode">Код импортируемого реквизита с текстом.</param>
        /// <param name="inputFolderName">Папка, из которой выполняется импорт.</param>
        protected void ImportTextRequisiteFromFolder(List <RequisiteModel> requisites, String codeRequisiteCode, String textRequisiteCode,
                                                     String inputFolderName)
        {
            var codeRequisite = requisites.FirstOrDefault(r => r.Code == codeRequisiteCode);
            var fileName      = string.Format("{0}.isbl", codeRequisite.DecodedText);
            var filePath      = Path.Combine(inputFolderName, fileName);
            var textRequisite = RequisiteModel.CreateFromFile(textRequisiteCode, filePath);

            requisites.Add(textRequisite);
        }
        /// <summary>
        /// Импортировать реквизиты, которые надо импортировать.
        /// </summary>
        /// <param name="path">Путь к папке с моделью.</param>
        /// <param name="requisites">Список реквизитов.</param>
        /// <param name="detailIndex">Индекс детального раздела.</param>
        protected override void ImportRequisites(string path, List <RequisiteModel> requisites, int detailIndex = 0)
        {
            if (detailIndex == 0)
            {
                var funcTextRequisite = RequisiteModel.CreateFromFile("ISBFuncText", GetTextFileName(path));
                requisites.Add(funcTextRequisite);

                var funcHelpRequisite = RequisiteModel.CreateFromFile("ISBFuncHelp", GetHelpFileName(path));
                requisites.Add(funcHelpRequisite);
            }
        }
Example #8
0
        /// <summary>
        /// Обработать экспорт реквизита.
        /// </summary>
        /// <param name="path">Путь к папке с моделью</param>
        /// <param name="requisite">Обрабатываемый реквизит.</param>
        /// <param name="detailIndex">Индекс детального раздела.</param>
        protected override void ProcessRequisiteExport(string path, RequisiteModel requisite, int detailIndex)
        {
            if (requisite.Code != "Properties")
            {
                return;
            }
            var workFlowBlockProperties = new XmlDocument();

            workFlowBlockProperties.LoadXml(requisite.DecodedText);
            this.ExportSettingsNode(path, workFlowBlockProperties);
            this.ExportTextToFile(GetPropertiesFileName(path), GetFormattedXml(workFlowBlockProperties));
        }
Example #9
0
        /// <summary>
        /// Импортировать XML-описание блока.
        /// </summary>
        /// <param name="path">Путь к папке с моделью</param>
        /// <param name="requisites">Список реквизитов.</param>
        private void ImportProperties(string path, List <RequisiteModel> requisites)
        {
            var workflowBlockPropertiesFileName = GetPropertiesFileName(path);
            var workflowBlockProperties         = new XmlDocument();

            workflowBlockProperties.Load(workflowBlockPropertiesFileName);
            this.ImportSettingsNode(path, workflowBlockProperties);
            var workflowBlockPropertiesText      = GetIsBuilderFormattedXml(workflowBlockProperties);
            var workflowBlockPropertiesRequisite = RequisiteModel.CreateFromText("Properties", workflowBlockPropertiesText);

            requisites.Add(workflowBlockPropertiesRequisite);
        }
        /// <summary>
        /// Обработать экспорт реквизита.
        /// </summary>
        /// <param name="path">Путь к папке с моделью</param>
        /// <param name="requisite">Обрабатываемый реквизит.</param>
        /// <param name="detailIndex">Индекс детального раздела.</param>
        protected override void ProcessRequisiteExport(string path, RequisiteModel requisite, int detailIndex)
        {
            if (requisite.Code == "ISBFuncText")
            {
                this.ExportTextToFile(GetTextFileName(path), requisite.DecodedText);
            }

            if (requisite.Code == "ISBFuncHelp")
            {
                this.ExportTextToFile(GetHelpFileName(path), requisite.DecodedText);
            }
        }
        /// <summary>
        /// Импортировать реквизиты, которые надо импортировать.
        /// </summary>
        /// <param name="path">Путь к папке с моделью.</param>
        /// <param name="requisites">Список реквизитов.</param>
        /// <param name="detailIndex">Индекс детального раздела.</param>
        protected override void ImportRequisites(string path, List <RequisiteModel> requisites, int detailIndex = 0)
        {
            var commentRequisite = RequisiteModel.CreateFromFile("ISBEvent", Path.Combine(path, CalculationFileName));

            if (commentRequisite.Data != null)
            {
                string fileName = string.Format(CalculationFileNameTemplate, Path.GetFileName(path));
                this.ExportTextToFile(Path.Combine(Path.GetDirectoryName(InputFile), fileName), commentRequisite.Data.InnerText);
                commentRequisite.Value = fileName;
                commentRequisite.Data  = null;
                requisites.Add(commentRequisite);
            }
        }
        /// <summary>
        /// Импортировать детальный раздел представлений.
        /// </summary>
        /// <param name="path">Путь к файлам модели.</param>
        /// <param name="requisites">Список реквизитов.</param>
        private void ImportViews(string path, List <RequisiteModel> requisites)
        {
            var viewCodeRequisite = requisites.FirstOrDefault(r => r.Code == "ISBEDocTypeViewCode");
            var viewPath          = GetViewPath(path, viewCodeRequisite.DecodedText);

            var cardFormFilePath  = GetCardFormFileName(viewPath);
            var cardFormRequisite = RequisiteModel.CreateFromFile("ISBEDocTypeViewCardForm", cardFormFilePath);

            requisites.Add(cardFormRequisite);

            var viewCommentFilePath  = GetViewCommentFileName(viewPath);
            var viewCommentRequisite = RequisiteModel.CreateFromFile("ISBEDocTypeViewComment", viewCommentFilePath);

            requisites.Add(viewCommentRequisite);
        }
        /// <summary>
        /// Импортировать реквизиты карточки.
        /// </summary>
        /// <param name="path">Путь к файлам модели.</param>
        /// <param name="requisites">Список реквизитов.</param>
        private void ImportCardRequisites(string path, List <RequisiteModel> requisites)
        {
            var formRequisite = RequisiteModel.CreateFromFile("ISBDialogForm", GetCardFormFileName(path));

            requisites.Add(formRequisite);
            var commentRequisite = RequisiteModel.CreateFromFile("ISBDialogComment", GetCommentFileName(path));

            requisites.Add(commentRequisite);

            var eventsPath         = GetEventsPath(path);
            var eventTextValue     = this.LoadEventsFromFolder(eventsPath);
            var eventTextRequisite = RequisiteModel.CreateFromText("ISBDialogEventText", eventTextValue);

            requisites.Add(eventTextRequisite);
        }
        /// <summary>
        /// Импортировать реквизиты карточки.
        /// </summary>
        /// <param name="path">Путь к файлам модели.</param>
        /// <param name="requisites">Список реквизитов.</param>
        private void ImportCardRequisites(string path, List <RequisiteModel> requisites)
        {
            var commentRequisite = RequisiteModel.CreateFromFile("ISBEDocTypeComment", GetCommentFileName(path));

            requisites.Add(commentRequisite);
            var paramsRequisite = RequisiteModel.CreateFromFile("ISBEDocTypeAddParams", GetParamsFileName(path));

            requisites.Add(paramsRequisite);

            var eventsPath         = GetEventsPath(path);
            var eventTextValue     = this.LoadEventsFromFolder(eventsPath);
            var eventTextRequisite = RequisiteModel.CreateFromText("ISBEDocTypeEventText", eventTextValue);

            requisites.Add(eventTextRequisite);
        }
        /// <summary>
        /// Импортировать детальный раздел событий реквизитов.
        /// </summary>
        /// <param name="path">Путь к файлам модели.</param>
        /// <param name="requisites">Список реквизитов.</param>
        private void ImportRequisiteEvents(string path, List <RequisiteModel> requisites)
        {
            var requisiteCodeRequisite = requisites.FirstOrDefault(r => r.Code == "ISBEDocTypeReqCode");
            var requisiteCode          = requisiteCodeRequisite.DecodedText;
            var requisitePath          = GetRequisitePath(path, requisiteCode);

            var changeEventRequisite = RequisiteModel.CreateFromFile("ISBEDocTypeReqOnChange", GetRequisiteChangeEventFileName(requisitePath));

            requisites.Add(changeEventRequisite);

            var selectEventRequisiteValue = this.LoadEventsFromFolder(requisitePath);
            var selectEventRequisite      = RequisiteModel.CreateFromText("ISBEDocTypeReqOnSelect", selectEventRequisiteValue);

            requisites.Add(selectEventRequisite);
        }
        /// <summary>
        /// Импортировать реквизиты, которые надо импортировать.
        /// </summary>
        /// <param name="path">Путь к папке с моделью.</param>
        /// <param name="requisites">Список реквизитов.</param>
        /// <param name="detailIndex">Индекс детального раздела.</param>
        protected override void ImportRequisites(string path, List <RequisiteModel> requisites, int detailIndex = 0)
        {
            if (detailIndex == 0)
            {
                var textRequisiteCode = TransformerEnvironment.IsRussianCodePage() ? "Текст" : "Text";
                var textRequisite     = RequisiteModel.CreateFromFile(textRequisiteCode, GetTextFileName(path));
                requisites.Add(textRequisite);

                var commentRequisiteCode = TransformerEnvironment.IsRussianCodePage() ? "Примечание" : "Note";
                var commentRequisite     = RequisiteModel.CreateFromFile(commentRequisiteCode, GetCommentFileName(path));
                requisites.Add(commentRequisite);

                var unitIdRequisiteCode = TransformerEnvironment.IsRussianCodePage() ? "ИДМодуля" : "UnitID";
                var unitIdRequisite     = new RequisiteModel();
                unitIdRequisite.Code = unitIdRequisiteCode;
                requisites.Add(unitIdRequisite);
            }
        }
Example #17
0
        /// <summary>
        /// Обработать экспорт реквизита.
        /// </summary>
        /// <param name="path">Путь к папке с моделью</param>
        /// <param name="requisite">Обрабатываемый реквизит.</param>
        /// <param name="detailIndex">Индекс детального раздела.</param>
        protected override void ProcessRequisiteExport(string path, RequisiteModel requisite, int detailIndex)
        {
            if (CheckNesting(requisite))
            {
                var encodedText = File.ReadAllText(Path.Combine(Path.GetDirectoryName(this.inputFile), requisite.Value));
                requisite.Value = string.Empty;
                var encoding    = TransformerEnvironment.CurrentEncoding;
                var decodedText = encoding.GetString(Convert.FromBase64String(encodedText));

                var model = TryDesirializeText(decodedText);

                if (model != null)
                {
                    PropertiesExport(path, model);
                    this.ExportTextToFile(Path.Combine(path, CalculationFileName), GetFormattedXml(model, encoding));
                    return;
                }

                this.ExportTextToFile(Path.Combine(path, CalculationFileName), decodedText);
            }
        }
Example #18
0
        /// <summary>
        /// Импортировать реквизиты, которые надо импортировать.
        /// </summary>
        /// <param name="path">Путь к папке с моделью.</param>
        /// <param name="requisites">Список реквизитов.</param>
        /// <param name="detailIndex">Индекс детального раздела.</param>
        protected override void ImportRequisites(string path, List <RequisiteModel> requisites, int detailIndex = 0)
        {
            var commentRequisite = RequisiteModel.CreateFromFile("ISBSearchCondition", Path.Combine(path, CalculationFileName));

            if (commentRequisite.Data != null)
            {
                string fileName = string.Format(CalculationFileNameTemplate, Path.GetFileName(path));
                commentRequisite.Value = fileName;

                var model = TryDesirializeText(commentRequisite.DecodedValue);

                if (model != null)
                {
                    PropertiesImport(path, model);
                }
                string encodedXML = Convert.ToBase64String(Encoding.Default.GetBytes(GetFormattedXml(model, Encoding.Default)));
                this.ExportTextToFile(Path.Combine(Path.GetDirectoryName(this.inputFile), fileName), encodedXML);

                commentRequisite.Data = null;
                requisites.Add(commentRequisite);
            }
        }
        /// <summary>
        /// Импортировать реквизиты, которые надо импортировать.
        /// </summary>
        /// <param name="path">Путь к папке с моделью.</param>
        /// <param name="requisites">Список реквизитов.</param>
        /// <param name="detailIndex">Индекс детального раздела.</param>
        protected override void ImportRequisites(string path, List <RequisiteModel> requisites, int detailIndex = 0)
        {
            if (detailIndex == 0)
            {
                var calculationRequisiteCode = TransformerEnvironment.IsRussianCodePage() ? "Расчет" : "Script";
                var calculationRequisite     = RequisiteModel.CreateFromFile(calculationRequisiteCode, GetCalculationPath(path));
                requisites.Add(calculationRequisite);

                var commentRequisiteCode = TransformerEnvironment.IsRussianCodePage() ? "Примечание" : "Note";
                var commentRequisite     = RequisiteModel.CreateFromFile(commentRequisiteCode, GetCommentPath(path));
                requisites.Add(commentRequisite);

                var templateRequisiteCode = TransformerEnvironment.IsRussianCodePage() ? "Шаблон" : "Template";
                var templateRequisite     = RequisiteModel.CreateFromFile(templateRequisiteCode, GetTemplatePath(path));
                requisites.Add(templateRequisite);

                var unitIdRequisiteCode = TransformerEnvironment.IsRussianCodePage() ? "ИДМодуля" : "UnitID";
                var unitIdRequisite     = new RequisiteModel();
                unitIdRequisite.Code = unitIdRequisiteCode;
                requisites.Add(unitIdRequisite);
            }
        }
        /// <summary>
        /// Обработать экспорт реквизита.
        /// </summary>
        /// <param name="path">Путь к папке с моделью</param>
        /// <param name="requisite">Обрабатываемый реквизит.</param>
        /// <param name="detailIndex">Индекс детального раздела.</param>
        protected override void ProcessRequisiteExport(string path, RequisiteModel requisite, int detailIndex)
        {
            if (TransformerEnvironment.IsRussianCodePage())
            {
                if (requisite.Code == "Расчет")
                {
                    this.ExportTextToFile(GetCalculationPath(path), requisite.DecodedText);
                }

                if (requisite.Code == "Примечание")
                {
                    this.ExportTextToFile(GetCommentPath(path), requisite.DecodedText);
                }

                if (requisite.Code == "Шаблон")
                {
                    this.ExportTextToFile(GetTemplatePath(path), requisite.DecodedText);
                }
            }

            if (TransformerEnvironment.IsEnglishCodePage())
            {
                if (requisite.Code == "Script")
                {
                    this.ExportTextToFile(GetCalculationPath(path), requisite.DecodedText);
                }

                if (requisite.Code == "Note")
                {
                    this.ExportTextToFile(GetCommentPath(path), requisite.DecodedText);
                }

                if (requisite.Code == "Template")
                {
                    this.ExportTextToFile(GetTemplatePath(path), requisite.DecodedText);
                }
            }
        }
 /// <summary>
 /// Обработать экспорт реквизита.
 /// </summary>
 /// <param name="path">Путь к папке с моделью</param>
 /// <param name="requisite">Обрабатываемый реквизит.</param>
 /// <param name="detailIndex">Индекс детального раздела.</param>
 protected virtual void ProcessRequisiteExport(string path, RequisiteModel requisite, int detailIndex)
 {
     // Пустой метод.
 }
Example #22
0
 /// <summary>
 /// Проверить вложенность.
 /// </summary>
 /// <param name="requisite">Обрабатываемый реквизит.</param>
 private static bool CheckNesting(RequisiteModel requisite) =>
 ((requisite.Name == "ISBEvent") || (requisite.Name == "ISBSearchCondition")) &&
 !string.IsNullOrWhiteSpace(requisite.Value);