├── .github └── workflows │ ├── qa.yml │ ├── release.yml │ └── testing.yml ├── .gitignore ├── .vscode └── settings.json ├── LICENSE ├── images ├── 1524488778341.png ├── 1524488819954.png ├── 1524488838193.png ├── 1524488992130.png ├── 1524489034146.png ├── 1524489100435.png ├── 1524489155282.png └── 1524489774491.png ├── packagedef ├── readme.md ├── sonar-project.properties ├── src ├── cmd │ ├── gitrules.os │ ├── Классы │ │ ├── КомандаAssembly.os │ │ ├── КомандаExport.os │ │ ├── КомандаInstall.os │ │ ├── КомандаPrecommit.os │ │ └── КомандаRemove.os │ ├── Модули │ │ └── ПараметрыПриложения.os │ └── Утилиты │ │ ├── pre-commit │ │ └── v8-exchrules1s.os └── core │ ├── Классы │ └── ОбработкаПравил.os │ └── Модули │ ├── ОбщийФункционал.os │ ├── РазобратьПравилаОбмена.os │ └── СобратьПравилаОбмена.os ├── tasks ├── coverage.os └── test.os └── tests ├── fixtures └── fake-rules.xml ├── РазобратьсяПравилаОбмена_test.os ├── Тест_ПроверитьCLI.os └── Тест_СобратьПравилаОбмена.os /.github/workflows/qa.yml: -------------------------------------------------------------------------------- 1 | name: Контроль качества 2 | # Любой пуш и pr в проекте но с фильтром по основному проекту 3 | on: [push, pull_request] 4 | jobs: 5 | build: 6 | if: github.repository == 'otymko/gitrules' 7 | runs-on: ${{ matrix.os }} 8 | strategy: 9 | fail-fast: false 10 | matrix: 11 | os: [ubuntu-latest] 12 | oscript_version: ['1.4.0'] 13 | 14 | steps: 15 | # Загрузка проекта 16 | - name: Актуализация 17 | uses: actions/checkout@v2 18 | 19 | # https://stackoverflow.com/questions/58033366/how-to-get-current-branch-within-github-actions 20 | - name: Извлечение имени текущей ветки 21 | shell: bash 22 | run: echo "##[set-output name=branch;]$(echo ${GITHUB_REF#refs/heads/})" 23 | id: extract_branch 24 | 25 | # Установка OneScript конкретной версии 26 | - name: Установка OneScript 27 | uses: otymko/setup-onescript@v1.1 28 | with: 29 | version: ${{ matrix.oscript_version }} 30 | 31 | # Установка зависимостей пакета 32 | - name: Установка зависимостей 33 | run: | 34 | opm install opm 35 | opm install --dev 36 | 37 | # Запуск тестов и сбор покрытия кода 38 | - name: Покрытие кода 39 | run: oscript ./tasks/coverage.os 40 | 41 | - name: Извлечение версии пакета 42 | shell: bash 43 | run: echo "##[set-output name=version;]`cat packagedef | grep ".Версия(" | sed 's|[^"]*"||' | sed -r 's/".+//'`" 44 | id: extract_version 45 | 46 | - name: Установка Sonar-scanner 47 | uses: warchant/setup-sonar-scanner@v3 48 | 49 | # Анализ проекта в SonarQube (ветка) 50 | - name: Анализ в SonarQube (branch) 51 | if: github.event_name == 'push' 52 | run: sonar-scanner 53 | -Dsonar.login=${{ secrets.SONARQUBE_TOKEN }} 54 | -Dsonar.host.url=${{ secrets.SONARQUBE_HOST }} 55 | -Dsonar.branch.name=${{ steps.extract_branch.outputs.branch }} 56 | -Dsonar.projectVersion=${{ steps.extract_version.outputs.version }} 57 | 58 | # Анализ проекта в SonarQube (PR) 59 | - name: Анализ в SonarQube (pull-request) 60 | if: github.event_name == 'pull_request' 61 | run: sonar-scanner 62 | -Dsonar.login=${{ secrets.SONARQUBE_TOKEN }} 63 | -Dsonar.host.url=${{ secrets.SONARQUBE_HOST }} 64 | -Dsonar.branch.name=${{ steps.extract_branch.outputs.branch }} 65 | -Dsonar.pullrequest.key=${{ github.event.pull_request.number }} 66 | -Dsonar.pullrequest.branch=${{ github.event.pull_request.head.ref }} 67 | -Dsonar.pullrequest.base=${{ github.event.pull_request.base.ref }} 68 | -Dsonar.scm.revision=${{ github.event.pull_request.head.sha }} 69 | -------------------------------------------------------------------------------- /.github/workflows/release.yml: -------------------------------------------------------------------------------- 1 | # MIT License 2 | # Copyright (C) 2020 Tymko Oleg and contributors 3 | # All rights reserved. 4 | 5 | name: Подготовка релиза и публикация в хабе 6 | # Только события создания и изменения релиза 7 | on: 8 | release: 9 | types: [published, edited] 10 | 11 | env: 12 | PACKAGE_MASK: gitrules-*.ospx 13 | 14 | jobs: 15 | build: 16 | runs-on: ${{ matrix.os }} 17 | strategy: 18 | fail-fast: false 19 | matrix: 20 | os: [ubuntu-latest] 21 | oscript_version: ['1.4.0'] 22 | 23 | steps: 24 | # Загрузка проекта 25 | - name: Актуализация 26 | uses: actions/checkout@v2 27 | 28 | # Установка OneScript конкретной версии 29 | - name: Установка OneScript 30 | uses: otymko/setup-onescript@v1.1 31 | with: 32 | version: ${{ matrix.oscript_version }} 33 | 34 | # Установка зависимостей пакета 35 | - name: Установка зависимостей 36 | run: | 37 | opm install opm 38 | opm install 39 | 40 | - name: Сборка пакета 41 | run: opm build 42 | 43 | - name: Заливка артефактов 44 | uses: actions/upload-artifact@v2 45 | with: 46 | name: package.zip 47 | path: ./${{ env.PACKAGE_MASK }} 48 | 49 | - name: Заливка в релиз 50 | uses: AButler/upload-release-assets@v1.0 51 | with: 52 | files: ./${{ env.PACKAGE_MASK }} 53 | repo-token: ${{ secrets.GITHUB_TOKEN }} 54 | 55 | - name: Публикация в hub.oscript.io 56 | shell: bash 57 | run: opm push -f ./${{ env.PACKAGE_MASK }} --token ${{ env.TOKEN }} -c stable 58 | env: 59 | TOKEN: ${{ secrets.OSHUB_TOKEN }} -------------------------------------------------------------------------------- /.github/workflows/testing.yml: -------------------------------------------------------------------------------- 1 | name: Тестирование 2 | # Любой пуш и pr в проекте 3 | on: [push, pull_request] 4 | 5 | jobs: 6 | build: 7 | runs-on: ${{ matrix.os }} 8 | strategy: 9 | fail-fast: false 10 | matrix: 11 | os: [ubuntu-latest] 12 | oscript_version: ['1.4.0'] 13 | 14 | steps: 15 | # Загрузка проекта 16 | - name: Актуализация 17 | uses: actions/checkout@v2 18 | 19 | # Установка OneScript конкретной версии 20 | - name: Установка OneScript 21 | uses: otymko/setup-onescript@v1.1 22 | with: 23 | version: ${{ matrix.oscript_version }} 24 | 25 | # Установка зависимостей пакета 26 | - name: Установка зависимостей 27 | run: | 28 | opm install opm 29 | opm install --dev 30 | 31 | # Задача тестирования, в результате ожидается успешное выполнение 32 | - name: Тестирование 33 | run: oscript ./tasks/test.os -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | bin/*.exe 2 | tests*.xml 3 | 4 | exec*.log 5 | 6 | bdd-*.xml 7 | 8 | .enabled-plugins 9 | coverage/* 10 | 11 | *.ospx 12 | oscript_modules/ 13 | src/cmd/oscript.cfg -------------------------------------------------------------------------------- /.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "coverage-gutters.xmlname": "coverage/coverage.xml" 3 | } -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2018 Oleg Tymko 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /images/1524488778341.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/otymko/gitrules/4fccfc833ac44a7046d425825f1b725f9c4eb3b6/images/1524488778341.png -------------------------------------------------------------------------------- /images/1524488819954.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/otymko/gitrules/4fccfc833ac44a7046d425825f1b725f9c4eb3b6/images/1524488819954.png -------------------------------------------------------------------------------- /images/1524488838193.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/otymko/gitrules/4fccfc833ac44a7046d425825f1b725f9c4eb3b6/images/1524488838193.png -------------------------------------------------------------------------------- /images/1524488992130.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/otymko/gitrules/4fccfc833ac44a7046d425825f1b725f9c4eb3b6/images/1524488992130.png -------------------------------------------------------------------------------- /images/1524489034146.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/otymko/gitrules/4fccfc833ac44a7046d425825f1b725f9c4eb3b6/images/1524489034146.png -------------------------------------------------------------------------------- /images/1524489100435.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/otymko/gitrules/4fccfc833ac44a7046d425825f1b725f9c4eb3b6/images/1524489100435.png -------------------------------------------------------------------------------- /images/1524489155282.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/otymko/gitrules/4fccfc833ac44a7046d425825f1b725f9c4eb3b6/images/1524489155282.png -------------------------------------------------------------------------------- /images/1524489774491.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/otymko/gitrules/4fccfc833ac44a7046d425825f1b725f9c4eb3b6/images/1524489774491.png -------------------------------------------------------------------------------- /packagedef: -------------------------------------------------------------------------------- 1 | ПутьКСценариюПараметров = ОбъединитьПути(ТекущийСценарий().Каталог, "src/cmd", "Модули", "ПараметрыПриложения.os"); 2 | ПараметрыСистемы_ЛокальнаяВерсия = ЗагрузитьСценарий(ПутьКСценариюПараметров); 3 | ИмяПродукта = НРег(ПараметрыСистемы_ЛокальнаяВерсия.ИмяПродукта()); 4 | ВерсияПродукта = ПараметрыСистемы_ЛокальнаяВерсия.ВерсияПродукта(); 5 | Описание.Имя("gitrules") 6 | .Версия("1.1.2") 7 | .Автор("otymko") 8 | .АдресАвтора("olegtymko@yandex.ru") 9 | .Описание("Версионирование правил обмена 1С с помощью git") 10 | .ВерсияСреды("1.0.21") 11 | .ВключитьФайл("src") 12 | .ВключитьФайл("docs") 13 | .ВключитьФайл("tests") 14 | .ВключитьФайл("readme.md") 15 | .ВключитьФайл("images") 16 | .ЗависитОт("cli", "0.9.8") 17 | .ЗависитОт("gitrunner", "1.5.2") 18 | .ЗависитОт("1commands", "0.8") 19 | .ЗависитОт("logos", "0.5") 20 | .РазработкаЗависитОт("1bdd") 21 | .РазработкаЗависитОт("1testrunner") 22 | .РазработкаЗависитОт("coverage") 23 | .РазработкаЗависитОт("fs") 24 | .ОпределяетКласс("ОбработкаПравил", "src/core/Классы/ОбработкаПравил.os") 25 | .ОпределяетМодуль("РазобратьПравилаОбмена", "src/core/Модули/РазобратьПравилаОбмена.os") 26 | .ОпределяетМодуль("СобратьПравилаОбмена", "src/core/Модули/СобратьПравилаОбмена.os") 27 | .ОпределяетМодуль("ОбщийФункционал", "src/core/Модули/ОбщийФункционал.os") 28 | .ИсполняемыйФайл("src/cmd/gitrules.os", ИмяПродукта) 29 | ; 30 | -------------------------------------------------------------------------------- /readme.md: -------------------------------------------------------------------------------- 1 | ## GitRules - версионирование правил обмена 1С с помощью git ## 2 | 3 | ### Описание 4 | ---- 5 | С помощью этого проекта можно версионировать изменения правил обмена 1С и выгружать на git. 6 | Реализованы следующие возможности: 7 | * Распаковка (разборка) правил на файлы и папки. 8 | + Поддержка разбора правил обмена. 9 | + Поддержка разбора правил регистрации. 10 | * Сборка правил из файлов и папок. 11 | + Поддержка сборки правил обмена. 12 | * Возможность запуска из консоли. 13 | 14 | **Пример использования Gitrules можно почтитать в статье на Infostart 15 | [Повышаем эффективность разработки правил обмена](https://infostart.ru/public/845576/).** 16 | 17 | ### Системные требования 18 | ---- 19 | * 1C: Предприятие 8.2.19 и новее 20 | * Git (https://git-scm.com/) 21 | * OneScript 1.0.11 и новее (http://oscript.io/) 22 | * Библиотеки OneScript (https://github.com/oscript-library) 23 | + 1commands 0.8 и новее (https://github.com/oscript-library/1commands) 24 | + logos 0.5 и новее (https://github.com/oscript-library/logos) 25 | + cli 0.9.8 и новее (https://github.com/oscript-library/cli) 26 | 27 | ### Установка gitrules 28 | ---- 29 | Первый способ - установить через opm: 30 | 31 | ``` 32 | $ opm install gitrules 33 | ``` 34 | 35 | Второй способ - скачать нужный релиз (https://github.com/otymko/gitrules/releases) и установить вручную: 36 | 37 | ``` 38 | $ opm install -f "path/to/file.ospx" 39 | ``` 40 | 41 | где path/to/file.ospx - путь к файлу реализа пакета для onescript. 42 | 43 | ### Подключение проекта с правилами обмена к GitRules 44 | ---- 45 | Для установки в проект git нужно выполнить команду: 46 | 47 | ``` 48 | $ gitrules install 49 | ``` 50 | 51 | Для удаления в репозитории проекта нужно выполнить команду: 52 | 53 | ``` 54 | $ gitrules remove 55 | ``` 56 | 57 | ### Консольное приложение gitrules ### 58 | ---- 59 | Список команд: 60 | * --help - справка по командам 61 | * --version (аналог -v) - версия приложения 62 | * install (аналог i) - установить hook gitrules в git проект 63 | * remove (аналог r) - удалить hook gitrules в git проекте 64 | * export (аналог e) - распаковка правил обмена 65 | * assembly (аналог a) - сборка правил обмена 66 | 67 | ### --help - справка по командам ### 68 | ---- 69 | Выводит справка по команде консольного приложения. 70 | 71 | ``` 72 | gitrules КОМАНДА --help 73 | ``` 74 | Параметры: 75 | * КОМАНДА - команда, по которой нужно получить справку. 76 | 77 | Пример: 78 | ``` 79 | $ gitrules export --help 80 | ``` 81 | или 82 | ``` 83 | $ gitrules --help 84 | ``` 85 | 86 | ### --version - версия приложения ### 87 | ---- 88 | Выводит версию консольного приложения. 89 | 90 | ``` 91 | $ gitrules --version 92 | ``` 93 | 94 | ### install - установить hook gitrules в git проект ### 95 | ---- 96 | Установка библиотеки gitrules в проект git. Установка ведется в каталог ./.git/hooks. 97 | 98 | ``` 99 | gitrules install [PATH] 100 | ``` 101 | 102 | Параметры: 103 | * [PATH] - Путь к каталогу установки git-hook разбора правил (По умолчанию текущий каталог). 104 | 105 | Пример: 106 | ``` 107 | $ gitrules install /path/to/git/repo/ 108 | ``` 109 | 110 | ### remove - удалить hook gitrules в git проекте ### 111 | ---- 112 | Удаление библиотеки gitrules из проекта git. Поиск ведется в каталоге ./.git/hooks. 113 | ``` 114 | gitrules remove [PATH] 115 | ``` 116 | Параметры: 117 | * [PATH] - Путь к каталогу удаления git-hook разбора правил (По умолчанию текущий каталог). 118 | 119 | Пример 120 | ``` 121 | $ gitrules remove /path/to/git/repo/ 122 | ``` 123 | 124 | ### precommit - распаковка правил обмена git репозитория ### 125 | ---- 126 | Выполняет распаковку (разборку) правил обмена в каталоге git репозитория. 127 | ``` 128 | gitrules precommit [ОПЦИИ] PATH 129 | ``` 130 | Параметры: 131 | * [PATH] - каталог git репозиторация с правилами обмена. 132 | * ОПЦИИ 133 | + --idx / --index - флаг индексации изменений в git репозитории. 134 | 135 | Пример 136 | ``` 137 | $ gitrules precommit --index ./git-test-rules 138 | ``` 139 | 140 | ### export - распаковка правил обмена ### 141 | ---- 142 | Выполняет распаковку (разборку) правил обмена. 143 | 144 | ``` 145 | gitrules export FILE PATH 146 | ``` 147 | Параметры: 148 | * [FILE] - путь до файла правил обмена. 149 | * [PATH] - каталог для распаковки (разборка) правил обмена. 150 | 151 | Пример: 152 | ``` 153 | $ gitrules export ExchangeRules.xml ./src 154 | ``` 155 | 156 | ### assembly - сборка правил обмена ### 157 | ---- 158 | Сборка правил обмена из каталогов и файлов 159 | ``` 160 | gitrules assembly SRC WORKPATH 161 | ``` 162 | Параметры: 163 | * [SRC] - Путь к каталогу распакованных правил обмена 164 | * [WORKPATH] - путь к каталогу сборки правил обмена. 165 | 166 | Пример: 167 | ``` 168 | $ gitrules assembly ./src/ExchangeRules.xml ./src2 169 | ``` 170 | -------------------------------------------------------------------------------- /sonar-project.properties: -------------------------------------------------------------------------------- 1 | sonar.projectKey=gitrules 2 | sonar.projectName=gitrules 3 | sonar.sources=./src 4 | sonar.sourceEncoding=UTF-8 5 | sonar.coverageReportPaths=coverage/genericCoverage.xml 6 | -------------------------------------------------------------------------------- /src/cmd/gitrules.os: -------------------------------------------------------------------------------- 1 | #Использовать cli 2 | #Использовать "." 3 | #Использовать "../core" 4 | 5 | // Обработчик выполнения команды 6 | // 7 | // Параметры: 8 | // КомандаПриложения - КомандаПриложения - Выполняемая команда 9 | // 10 | Процедура ВыполнитьКоманду(Знач КомандаПриложения) Экспорт 11 | 12 | КомандаПриложения.ВывестиСправку(); 13 | 14 | КонецПроцедуры 15 | 16 | 17 | /////////////////////////////////////////////////////////////////////////////// 18 | 19 | Процедура ВыполнитьПриложение() 20 | 21 | ИмяПродукта = ПараметрыПриложения.ИмяПродукта(); 22 | 23 | Приложение = Новый КонсольноеПриложение(ИмяПродукта, "Версионирование правил обмена 1С с помощью git"); 24 | Приложение.Версия("v version", ПараметрыПриложения.ВерсияПродукта()); 25 | 26 | Приложение.ДобавитьКоманду( 27 | "i install", 28 | СтрШаблон("Установить %1 в текущий репозиторий", ИмяПродукта), 29 | Новый КомандаInstall); 30 | 31 | Приложение.ДобавитьКоманду( 32 | "r remove", 33 | СтрШаблон("Удалить %1 в текущем репозитории", ИмяПродукта), 34 | Новый КомандаRemove); 35 | 36 | Приложение.ДобавитьКоманду( 37 | "e export", 38 | "Распаковка правил обмена xml на файлы и каталоги", 39 | Новый КомандаExport); 40 | 41 | Приложение.ДобавитьКоманду( 42 | "a assembly", 43 | "Сборка из каталогов и файлов правил xml", 44 | Новый КомандаAssembly); 45 | 46 | Приложение.ДобавитьКоманду( 47 | "p precommit", 48 | "Разборка правил обмена xml без git commit", 49 | Новый КомандаPrecommit); 50 | 51 | Приложение.УстановитьОсновноеДействие(ЭтотОбъект); 52 | 53 | Приложение.Запустить(АргументыКоманднойСтроки); 54 | 55 | КонецПроцедуры // ВыполнениеКоманды() 56 | 57 | /////////////////////////////////////////////////////// 58 | 59 | Попытка 60 | 61 | ВыполнитьПриложение(); 62 | 63 | Исключение 64 | 65 | Сообщить(ОписаниеОшибки()); 66 | 67 | КонецПопытки; -------------------------------------------------------------------------------- /src/cmd/Классы/КомандаAssembly.os: -------------------------------------------------------------------------------- 1 | #Использовать fs 2 | 3 | /////////////////////////////////////////////////////////////////////////////// 4 | // 5 | // Служебный модуль с реализацией работы команды 6 | // 7 | /////////////////////////////////////////////////////////////////////////////// 8 | 9 | Процедура ОписаниеКоманды(Команда) Экспорт 10 | 11 | Команда.Аргумент("SRC", "" ,"Путь к каталогу распакованных правил конвертации") 12 | .ТСтрока(); // тип опции Строка 13 | 14 | Команда.Аргумент("WORKPATH", "" ,"Путь к каталогу сборки правил конвертации") 15 | .ТСтрока(); // тип опции Строка 16 | 17 | КонецПроцедуры 18 | 19 | Процедура ВыполнитьКоманду(Знач Команда) Экспорт 20 | 21 | КаталогИсходников = Команда.ЗначениеАргумента("SRC"); 22 | КаталогСборки = Команда.ЗначениеАргумента("WORKPATH"); 23 | 24 | ФайлКаталог = Новый Файл(КаталогИсходников); 25 | Если Не ФайлКаталог.Существует() Или ФайлКаталог.ЭтоФайл() Тогда 26 | 27 | СтрокаОшибки = СтрШаблон("Каталог исходников правил конвертации <%1> не существует", КаталогИсходников); 28 | ВызватьИсключение СтрокаОшибки; 29 | 30 | КонецЕсли; 31 | 32 | ФС.ОбеспечитьКаталог(КаталогСборки); 33 | 34 | МенеджерПравил = Новый ОбработкаПравил(); 35 | МенеджерПравил.СобратьПравилаКонвертации(КаталогИсходников, КаталогСборки); 36 | 37 | КонецПроцедуры -------------------------------------------------------------------------------- /src/cmd/Классы/КомандаExport.os: -------------------------------------------------------------------------------- 1 | #Использовать fs 2 | 3 | /////////////////////////////////////////////////////////////////////////////// 4 | // 5 | // Служебный модуль с реализацией работы команды 6 | // 7 | /////////////////////////////////////////////////////////////////////////////// 8 | 9 | Процедура ОписаниеКоманды(Команда) Экспорт 10 | 11 | Команда.Аргумент("FILE", "" ,"Путь к файлу правилу xml. Например /path/to/file/ExchangeRules.xml") 12 | .ТСтрока(); // тип опции Строка 13 | 14 | Команда.Аргумент("PATH", "" ,"Путь к каталогу распаковки правил") 15 | .ТСтрока(); // тип опции Строка 16 | 17 | Команда.Опция("h here", Ложь, "Выгружать правило в выбранный каталог") 18 | .ТБулево() 19 | .Обязательный(Ложь); 20 | 21 | КонецПроцедуры 22 | 23 | Процедура ВыполнитьКоманду(Знач Команда) Экспорт 24 | 25 | ПутьКФайлуПравила = Команда.ЗначениеАргумента("FILE"); 26 | КаталогРаспаковки = Команда.ЗначениеАргумента("PATH"); 27 | ВыгружатьВВыбранныйКаталог = Команда.ЗначениеОпции("here"); 28 | 29 | ФайлСПравилами = Новый Файл(ПутьКФайлуПравила); 30 | Если Не ФайлСПравилами.Существует() Или ФайлСПравилами.ЭтоКаталог() Тогда 31 | 32 | СтрокаОшибки = СтрШаблон("Файл с правилами обмена <%1> не существует", ПутьКФайлуПравила); 33 | ВызватьИсключение СтрокаОшибки; 34 | 35 | КонецЕсли; 36 | 37 | Если Не ФайлСПравилами.Расширение = ".xml" Тогда 38 | СтрокаОшибки = СтрШаблон("Расширение файла <%1> не xml", ПутьКФайлуПравила); 39 | ВызватьИсключение СтрокаОшибки; 40 | КонецЕсли; 41 | 42 | ФС.ОбеспечитьКаталог(КаталогРаспаковки); 43 | 44 | МенеджерПравил = Новый ОбработкаПравил(); 45 | МенеджерПравил.УстановитьЗначениеВыгружатьВВыбранныйКаталог(ВыгружатьВВыбранныйКаталог); 46 | МенеджерПравил.РазложитьПравилаКонвертации(ПутьКФайлуПравила, КаталогРаспаковки); 47 | 48 | КонецПроцедуры 49 | -------------------------------------------------------------------------------- /src/cmd/Классы/КомандаInstall.os: -------------------------------------------------------------------------------- 1 | #Использовать fs 2 | 3 | /////////////////////////////////////////////////////////////////////////////// 4 | // 5 | // Служебный модуль с реализацией работы команды 6 | // 7 | /////////////////////////////////////////////////////////////////////////////// 8 | 9 | Процедура ОписаниеКоманды(Команда) Экспорт 10 | 11 | Команда.Аргумент("PATH", "" ,"Путь к каталогу установки git-hook разбора правил (По умолчанию текущий каталог)") 12 | .ТСтрока() 13 | .ПоУмолчанию(ТекущийКаталог()) 14 | .Обязательный(Ложь); // тип опции Строка 15 | 16 | КонецПроцедуры 17 | 18 | Процедура ВыполнитьКоманду(Знач Команда) Экспорт 19 | 20 | ПутьКУстановки = Команда.ЗначениеАргумента("PATH"); 21 | 22 | КаталогПроекта = Новый Файл(ОбъединитьПути(ПутьКУстановки, ".git")); 23 | Если Не КаталогПроекта.Существует() Тогда 24 | СообщениеОшибки = СтрШаблон("Каталог <%1> не является репозиторием GIT", ПутьКУстановки); 25 | ВызватьИсключение Новый ИнформацияОбОшибке(СообщениеОшибки, "Завершение работы"); 26 | КонецЕсли; 27 | 28 | Попытка 29 | МассивФайлов = НайтиФайлы(ПараметрыПриложения.ПолучитьКаталогУтилитДляУстановки() + ПолучитьРазделительПути(), "*"); 30 | Для Каждого Файл Из МассивФайлов Цикл 31 | КопироватьФайл(Файл.ПолноеИмя, ОбъединитьПути(КаталогПроекта.ПолноеИмя, "hooks", Файл.Имя)); 32 | КонецЦикла; 33 | Сообщить("Установка завершена"); 34 | Исключение 35 | ВызватьИсключение ("Не удалось установить gitrules по причине: " + ОписаниеОшибки()); 36 | КонецПопытки; 37 | 38 | КонецПроцедуры // ВыполнитьКоманду 39 | -------------------------------------------------------------------------------- /src/cmd/Классы/КомандаPrecommit.os: -------------------------------------------------------------------------------- 1 | #Использовать fs 2 | #Использовать "../../core" 3 | // #Использовать gitrules 4 | 5 | /////////////////////////////////////////////////////////////////////////////// 6 | // 7 | // Служебный модуль с реализацией работы команды 8 | // 9 | /////////////////////////////////////////////////////////////////////////////// 10 | 11 | Процедура ОписаниеКоманды(Команда) Экспорт 12 | 13 | Команда.Аргумент("PATH", ТекущийКаталог(), "Путь к каталогу с правилами обмена") 14 | .ТСтрока() 15 | .Обязательный(Ложь); 16 | 17 | Команда.Опция("idx index", Ложь,"Индексировать изменения") 18 | .ТБулево() 19 | .Обязательный(Ложь); 20 | 21 | 22 | КонецПроцедуры 23 | 24 | Процедура ВыполнитьКоманду(Знач Команда) Экспорт 25 | 26 | КаталогPATH = Команда.ЗначениеАргумента("PATH"); 27 | ИндексироватьИзменения = Команда.ЗначениеОпции("index"); 28 | 29 | КаталогИзПараметров = ОбщийФункционал.ПолучитьПолныйПутьККаталогу(КаталогPATH); 30 | Сообщить("CAT: " + КаталогИзПараметров); 31 | Файл = Новый Файл(КаталогИзПараметров); 32 | Если Не Файл.Существует() Или Не Файл.ЭтоКаталог() Тогда 33 | 34 | СтрокаОшибки = СтрШаблон("Каталог с правилами обмена <%1> не существует", КаталогИзПараметров); 35 | ВызватьИсключение СтрокаОшибки; 36 | 37 | КонецЕсли; 38 | 39 | //Проверим на GIT репозиторий 40 | Если Не ОбщийФункционал.ЭтоGitРепозиторий(КаталогИзПараметров) Тогда 41 | СообщениеОшибки = СтрШаблон("Каталог <%1> не является репозиторием GIT", КаталогИзПараметров); 42 | ВызватьИсключение Новый ИнформацияОбОшибке(СообщениеОшибки, "Завершение работы"); 43 | КонецЕсли; 44 | 45 | КаталогSRC = ОбъединитьПути(КаталогИзПараметров, "src"); 46 | 47 | МенеджерПравил = Новый ОбработкаПравил(); 48 | МенеджерПравил.ИнициализироватьКаталогИсходников(КаталогSRC); 49 | МенеджерПравил.ЗапуститьВыгрузкуПравилВФайлы(КаталогИзПараметров, КаталогSRC, ИндексироватьИзменения); 50 | 51 | КонецПроцедуры -------------------------------------------------------------------------------- /src/cmd/Классы/КомандаRemove.os: -------------------------------------------------------------------------------- 1 | #Использовать fs 2 | 3 | /////////////////////////////////////////////////////////////////////////////// 4 | // 5 | // Служебный модуль с реализацией работы команды 6 | // 7 | /////////////////////////////////////////////////////////////////////////////// 8 | 9 | Процедура ОписаниеКоманды(Команда) Экспорт 10 | 11 | Команда.Аргумент("PATH", "" ,"Путь к каталогу удаления git-hook разбора правил (По умолчанию текущий каталог)") 12 | .ТСтрока() 13 | .ПоУмолчанию(ТекущийКаталог()) 14 | .Обязательный(Ложь); // тип опции Строка 15 | 16 | КонецПроцедуры 17 | 18 | Процедура ВыполнитьКоманду(Знач Команда) Экспорт 19 | 20 | ПутьКОчистки = Команда.ЗначениеАргумента("PATH"); 21 | 22 | КаталогПроекта = Новый Файл(ОбъединитьПути(ПутьКОчистки, ".git")); 23 | Если Не КаталогПроекта.Существует() Тогда 24 | ВызватьИсключение "Этот каталог не является репозиторием GIT"; 25 | КонецЕсли; 26 | 27 | МассивИменФайлов = Новый Массив; 28 | МассивИменФайлов.Добавить("pre-commit"); 29 | МассивИменФайлов.Добавить("v8-exchrules1s.os"); 30 | 31 | КаталогHooks = ОбъединитьПути(КаталогПроекта.ПолноеИмя, "hooks"); 32 | 33 | ЕстьОшибки = Ложь; 34 | Для Каждого ИмяФайла Из МассивИменФайлов Цикл 35 | Попытка 36 | УдалитьФайлы(ОбъединитьПути(КаталогHooks, ИмяФайла)); 37 | Исключение 38 | ЕстьОшибки = Истина; 39 | Сообщить("При удалении файла " + ИмяФайла + " произошла ошибка. Причина: " + ОписаниеОшибки()); 40 | КонецПопытки; 41 | КонецЦикла; 42 | 43 | Если ЕстьОшибки Тогда 44 | ВызватьИсключение "Операция прервана - ость ошибки"; 45 | Иначе 46 | Сообщить("Gitrules успешно удален из репозитория"); 47 | КонецЕсли; 48 | 49 | КонецПроцедуры // ВыполнитьКоманду 50 | -------------------------------------------------------------------------------- /src/cmd/Модули/ПараметрыПриложения.os: -------------------------------------------------------------------------------- 1 | /////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // Служебный модуль с набором служебных параметров приложения 4 | // 5 | // При создании нового приложения обязательно внести изменение 6 | // в ф-ии ИмяПродукта, указав имя вашего приложения. 7 | // 8 | // При выпуске новой версии обязательно изменить ее значение 9 | // в ф-ии ВерсияПродукта 10 | // 11 | /////////////////////////////////////////////////////////////////////////////// 12 | 13 | /////////////////////////////////////////////////////////////////////////////// 14 | // СВОЙСТВА ПРОДУКТА 15 | 16 | // ВерсияПродукта 17 | // Возвращает текущую версию продукта 18 | // 19 | // Возвращаемое значение: 20 | // Строка - Значение текущей версии продукта 21 | // 22 | Функция ВерсияПродукта() Экспорт 23 | 24 | Возврат "1.1.2"; 25 | 26 | КонецФункции // ВерсияПродукта 27 | 28 | // ИмяПродукта 29 | // Возвращает имя продукта 30 | // 31 | // Возвращаемое значение: 32 | // Строка - Значение имени продукта 33 | // 34 | Функция ИмяПродукта() Экспорт 35 | 36 | Возврат "gitrules"; 37 | 38 | КонецФункции // ИмяПродукта 39 | 40 | /////////////////////////////////////////////////////////////////////////////// 41 | // ЛОГИРОВАНИЕ 42 | 43 | // Форматирование логов 44 | // См. описание метода "УстановитьРаскладку" библиотеки logos 45 | // 46 | Функция Форматировать(Знач Уровень, Знач Сообщение) Экспорт 47 | 48 | Возврат СтрШаблон("%1: %2 - %3", ТекущаяДата(), УровниЛога.НаименованиеУровня(Уровень), Сообщение); 49 | 50 | КонецФункции 51 | 52 | // ИмяЛогаСистемы 53 | // Возвращает идентификатор лога приложения 54 | // 55 | // Возвращаемое значение: 56 | // Строка - Значение идентификатора лога приложения 57 | // 58 | Функция ИмяЛогаСистемы() Экспорт 59 | 60 | Возврат "oscript.app." + ИмяПродукта(); 61 | 62 | КонецФункции // ИмяЛогаСистемы 63 | 64 | // Получить каталог модуля 65 | Функция ПолучитьКаталогУтилитДляУстановки() Экспорт 66 | Возврат ОбъединитьПути(СтартовыйСценарий().Каталог, "Утилиты"); 67 | КонецФункции 68 | -------------------------------------------------------------------------------- /src/cmd/Утилиты/pre-commit: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | oscript -encoding=utf-8 .git/hooks/v8-exchrules1s.os 3 | -------------------------------------------------------------------------------- /src/cmd/Утилиты/v8-exchrules1s.os: -------------------------------------------------------------------------------- 1 | #Использовать gitrules 2 | 3 | Перем КаталогИзПараметров; 4 | Перем МенеджерПравил; 5 | 6 | Процедура Инит() 7 | 8 | Сообщить("Start"); 9 | 10 | КаталогПроекта = ОбъединитьПути(КаталогИзПараметров, "src"); 11 | 12 | МенеджерПравил = Новый ОбработкаПравил(); 13 | МенеджерПравил.ИнициализироватьКаталогИсходников(КаталогПроекта); 14 | МенеджерПравил.ЗапуститьВыгрузкуПравилВФайлы(КаталогИзПараметров, КаталогПроекта); 15 | МенеджерПравил = Неопределено; 16 | 17 | Сообщить("End"); 18 | 19 | КонецПроцедуры 20 | 21 | Разделитель = ПолучитьРазделительПути(); 22 | КаталогИзПараметров = СтрЗаменить(ТекущийСценарий().Каталог, Разделитель + ".git" + Разделитель + "hooks", ""); 23 | Инит(); -------------------------------------------------------------------------------- /src/core/Классы/ОбработкаПравил.os: -------------------------------------------------------------------------------- 1 | #Использовать 1commands 2 | #Использовать gitrunner 3 | 4 | Перем ОсновнойКаталогПравил; 5 | Перем ВыгружатьВВыбранныйКаталог; 6 | 7 | Процедура Инициализация() 8 | 9 | Сообщить("Запущен менеджер правил"); 10 | 11 | КонецПроцедуры 12 | 13 | Процедура ЗапуститьВыгрузкуПравилВФайлы(КаталогИзПараметров, КаталогПроекта, ИндексироватьИзменения = Истина) Экспорт 14 | 15 | Сообщить("START precommit gitrules"); 16 | УстановитьОсновнойКаталог(КаталогИзПараметров); 17 | СписокФайлов = ПолучитьСписокПравил(); 18 | УстановитьОсновнойКаталог(КаталогПроекта); 19 | Для Каждого ПутьКФайлу Из СписокФайлов Цикл 20 | Сообщить("FILE: " + ПутьКФайлу); 21 | КаталогПравил = СоздатьКаталогиДляПравил(КаталогИзПараметров, КаталогПроекта, ПутьКФайлу); 22 | УстановитьОсновнойКаталог(КаталогПравил); 23 | РазложитьФайлПравила(ПутьКФайлу); 24 | РазобратьПравилаОбмена.ВыполнитьРазбор(КаталогПравил, ПутьКФайлу); 25 | КонецЦикла; 26 | 27 | Если ИндексироватьИзменения Тогда 28 | Сообщить("Add to index git"); 29 | ГитРепозиторий = Новый ГитРепозиторий(); 30 | ГитРепозиторий.УстановитьРабочийКаталог(КаталогИзПараметров); 31 | ГитРепозиторий.ДобавитьФайлВИндекс("."); 32 | КонецЕсли; 33 | Сообщить("END"); 34 | 35 | КонецПроцедуры 36 | 37 | Процедура РазложитьПравилаКонвертации(Знач ПутьКПравилам, Знач КаталогРаспаковки) Экспорт 38 | 39 | Сообщить("START Export"); 40 | РазобратьПравилаОбмена.ВыполнитьРазбор(КаталогРаспаковки, ПутьКПравилам, ВыгружатьВВыбранныйКаталог); 41 | Сообщить("END"); 42 | 43 | КонецПроцедуры 44 | 45 | Процедура СобратьПравилаКонвертации(Знач КаталогИсходников, Знач КаталогСборки) Экспорт 46 | Сообщить("START Assembly"); 47 | СобратьПравилаОбмена.ВыполнитьСборку(КаталогИсходников, КаталогСборки); 48 | Сообщить("END"); 49 | КонецПроцедуры 50 | 51 | Процедура ИнициализироватьКаталогИсходников(КаталогПроекта) Экспорт 52 | 53 | Файл = Новый Файл(КаталогПроекта); 54 | Если Файл.Существует() Тогда 55 | ОбщийФункционал.ОчиститьИсходныйКаталог(КаталогПроекта); 56 | Попытка 57 | УдалитьФайлы(КаталогПроекта); 58 | Исключение 59 | Сообщить("Не удалось удалить каталог " + КаталогПроекта); 60 | КонецПопытки; 61 | КонецЕсли; 62 | СоздатьКаталог(КаталогПроекта); 63 | 64 | КонецПроцедуры 65 | 66 | Процедура УстановитьЗначениеВыгружатьВВыбранныйКаталог(Знач Значение) Экспорт 67 | ВыгружатьВВыбранныйКаталог = Значение; 68 | КонецПроцедуры 69 | 70 | Процедура УстановитьОсновнойКаталог(Знач Значение) Экспорт 71 | ОсновнойКаталогПравил = Значение; 72 | КонецПроцедуры 73 | 74 | Функция ПолучитьОсновнойКаталог() Экспорт 75 | Возврат ОсновнойКаталогПравил; 76 | КонецФункции 77 | 78 | Функция ПолучитьСписокПравил() Экспорт 79 | Массив = Новый Массив; 80 | МассивФайлов = НайтиФайлы(ОсновнойКаталогПравил, "*.xml", Истина); 81 | Для Каждого Файл Из МассивФайлов Цикл 82 | Массив.Добавить(Файл.ПолноеИмя); 83 | КонецЦикла; 84 | Возврат Массив; 85 | КонецФункции 86 | 87 | Процедура РазложитьФайлПравила(ПутьКФайлу) Экспорт 88 | РазобратьПравилаОбмена.ВыполнитьРазбор(ОсновнойКаталогПравил, ПутьКФайлу); 89 | КонецПроцедуры 90 | 91 | Процедура ДобавитьПравилаВИндексGIT() Экспорт 92 | Команда = Новый Команда; 93 | Команда.УстановитьРабочийКаталог(ОсновнойКаталогПравил); 94 | Команда.УстановитьКоманду("git add *"); 95 | КодВозврата = Команда.Исполнить(); 96 | КонецПроцедуры 97 | 98 | Функция СоздатьКаталогиДляПравил(КаталогИсходников, КаталогПроекта, ПутьКПравилам) Экспорт 99 | 100 | Файл = Новый Файл(ПутьКПравилам); 101 | Каталог = ОбщийФункционал.ПолучитьПутьВРабочемКаталоге(Файл.Путь, КаталогИсходников); 102 | Файл = Неопределено; 103 | МассивКаталогов = ОбщийФункционал.РазложитьСтрокуВМассивПодстрок(Каталог, ПолучитьРазделительПути()); 104 | Если МассивКаталогов.Количество() = 0 Тогда 105 | Возврат КаталогИсходников; 106 | КонецЕсли; 107 | 108 | ТекущийКаталог = КаталогПроекта; 109 | Для Каждого ЭлементМассива Из МассивКаталогов Цикл 110 | ТекущийКаталог = ОбъединитьПути(ТекущийКаталог, ЭлементМассива); 111 | Если Не ОбщийФункционал.ЭтотКаталогСуществует(ТекущийКаталог) Тогда 112 | СоздатьКаталог(ТекущийКаталог); 113 | КонецЕсли; 114 | КонецЦикла; 115 | 116 | Возврат ТекущийКаталог; 117 | 118 | КонецФункции 119 | 120 | ОсновнойКаталогПравил = ""; 121 | ВыгружатьВВыбранныйКаталог = Ложь; 122 | 123 | Инициализация(); -------------------------------------------------------------------------------- /src/core/Модули/ОбщийФункционал.os: -------------------------------------------------------------------------------- 1 | Функция УбратьРасширениеИзИмени(Имя, Расширение = ".xml") Экспорт 2 | Возврат СтрЗаменить(Имя, Расширение, ""); 3 | КонецФункции 4 | 5 | Функция ПроверитьНаличиеПредкаВДереве(ТекущийУзел, ИмяРодителя, ИмяПоля = "Имя") Экспорт 6 | 7 | Если ЗначениеЗаполнено(ТекущийУзел.Родитель) Тогда 8 | Если ТекущийУзел.Родитель[ИмяПоля] = ИмяРодителя Тогда 9 | Возврат Истина; 10 | КонецЕсли; 11 | Возврат ПроверитьНаличиеПредкаВДереве(ТекущийУзел.Родитель, ИмяРодителя); 12 | КонецЕсли; 13 | 14 | Возврат Ложь; 15 | 16 | КонецФункции 17 | 18 | Функция ПолучитьИмяФайла(ПутьКФайлу) Экспорт 19 | Файл = Новый Файл(ПутьКФайлу); 20 | Возврат Файл.Имя; 21 | КонецФункции 22 | 23 | Функция ПолучитьСтруктуруДереваПравил() Экспорт 24 | 25 | Дерево = Новый ДеревоЗначений; 26 | Дерево.Колонки.Добавить("Имя"); 27 | Дерево.Колонки.Добавить("Идентификатор"); 28 | Дерево.Колонки.Добавить("Значение"); 29 | Дерево.Колонки.Добавить("Порядок"); 30 | Дерево.Колонки.Добавить("ТипСтроки"); 31 | Дерево.Колонки.Добавить("Каталог"); 32 | Возврат Дерево; 33 | 34 | КонецФункции 35 | 36 | Функция ЭтоXMLФайл(Имя) Экспорт 37 | 38 | Возврат СтрЧислоВхождений(Имя, ".xml") > 0; 39 | 40 | КонецФункции 41 | 42 | Функция ПолучитьПараметрыПравил() Экспорт 43 | 44 | СтруктураНастроек = Новый Структура; 45 | 46 | ИменаРеквизитовКонвертации = Новый Массив; 47 | 48 | // Реквизиты конвертации 49 | ИменаРеквизитовКонвертации.Добавить("ВерсияФормата"); 50 | ИменаРеквизитовКонвертации.Добавить("Ид"); 51 | ИменаРеквизитовКонвертации.Добавить("Наименование"); 52 | ИменаРеквизитовКонвертации.Добавить("ДатаВремяСоздания"); 53 | ИменаРеквизитовКонвертации.Добавить("Источник"); 54 | ИменаРеквизитовКонвертации.Добавить("Приемник"); 55 | 56 | СтруктураНастроек.Вставить("ИменаРеквизитовКонвертации", ИменаРеквизитовКонвертации); 57 | 58 | ИменаСвойствКонвертации = Новый Массив; 59 | ИменаСвойствКонвертации.Добавить("Параметры"); 60 | ИменаСвойствКонвертации.Добавить("Обработки"); 61 | 62 | СтруктураНастроек.Вставить("ИменаСвойствКонвертации", ИменаСвойствКонвертации); 63 | 64 | ИменаСвойствГрупп = Новый Массив; 65 | ИменаСвойствГрупп.Добавить("Группа"); 66 | ИменаСвойствГрупп.Добавить("Параметры"); 67 | ИменаСвойствГрупп.Добавить("Обработки"); 68 | ИменаСвойствГрупп.Добавить("Свойства"); 69 | ИменаСвойствГрупп.Добавить("Алгоритмы"); 70 | ИменаСвойствГрупп.Добавить("Запросы"); 71 | 72 | СтруктураНастроек.Вставить("ИменаСвойствГрупп", ИменаСвойствГрупп); 73 | 74 | МассивОбработчиков = Новый Массив; 75 | 76 | // Конвертация 77 | МассивОбработчиков.Добавить("ПослеЗагрузкиПравилОбмена"); 78 | МассивОбработчиков.Добавить("ПередВыгрузкойДанных"); 79 | МассивОбработчиков.Добавить("ПередПолучениемИзмененныхОбъектов"); 80 | МассивОбработчиков.Добавить("ПослеВыгрузкиДанных"); 81 | МассивОбработчиков.Добавить("ПередВыгрузкойОбъекта"); 82 | МассивОбработчиков.Добавить("ПослеВыгрузкиОбъекта"); 83 | МассивОбработчиков.Добавить("ПередКонвертациейОбъекта"); 84 | МассивОбработчиков.Добавить("ПередОтправкойИнформацииОбУдалении"); 85 | МассивОбработчиков.Добавить("ПередЗагрузкойДанных"); 86 | МассивОбработчиков.Добавить("ПослеЗагрузкиДанных"); 87 | МассивОбработчиков.Добавить("ПередЗагрузкойОбъекта"); 88 | МассивОбработчиков.Добавить("ПослеЗагрузкиОбъекта"); 89 | МассивОбработчиков.Добавить("ПриПолученииИнформацииОбУдалении"); 90 | МассивОбработчиков.Добавить("ПослеЗагрузкиПараметров"); 91 | МассивОбработчиков.Добавить("ПослеПолученияИнформацииОбУзлахОбмена"); 92 | 93 | // ГруппаСвойств 94 | МассивОбработчиков.Добавить("ПередОбработкойВыгрузки"); 95 | МассивОбработчиков.Добавить("ПередВыгрузкойСвойства"); 96 | МассивОбработчиков.Добавить("ПриВыгрузкеСвойства"); 97 | МассивОбработчиков.Добавить("ПослеВыгрузкиСвойства"); 98 | МассивОбработчиков.Добавить("ПослеОбработкиВыгрузки"); 99 | 100 | // Свойства 101 | МассивОбработчиков.Добавить("ПередВыгрузкойСвойства"); 102 | МассивОбработчиков.Добавить("ПриВыгрузкеСвойства"); 103 | МассивОбработчиков.Добавить("ПослеВыгрузкиСвойства"); 104 | 105 | // ПравилаВыгрузкиДанных 106 | МассивОбработчиков.Добавить("ПередОбработкойПравила"); 107 | МассивОбработчиков.Добавить("ПослеОбработкиПравила"); 108 | МассивОбработчиков.Добавить("ПередВыгрузкойОбъекта"); 109 | МассивОбработчиков.Добавить("ПослеВыгрузкиОбъекта"); 110 | 111 | // ПравилаКонвертацииОбъектов 112 | МассивОбработчиков.Добавить("ПередВыгрузкой"); 113 | МассивОбработчиков.Добавить("ПриВыгрузке"); 114 | МассивОбработчиков.Добавить("ПослеВыгрузки"); 115 | МассивОбработчиков.Добавить("ПослеВыгрузкиОбъектаВФайл"); 116 | МассивОбработчиков.Добавить("ПослеЗагрузки"); 117 | МассивОбработчиков.Добавить("ПослеВыгрузкиВФайл"); 118 | МассивОбработчиков.Добавить("ПередЗагрузкой"); 119 | МассивОбработчиков.Добавить("ПриЗагрузке"); 120 | 121 | МассивОбработчиков.Добавить("ПередЗагрузкойОбъекта"); 122 | МассивОбработчиков.Добавить("ПриЗагрузкеОбъекта"); 123 | МассивОбработчиков.Добавить("ПослеЗагрузкиОбъекта"); 124 | МассивОбработчиков.Добавить("ПоследовательностьПолейПоиска"); 125 | 126 | // ПравилаРегистрацииОбъектов 127 | МассивОбработчиков.Добавить("ПередОбработкой"); 128 | МассивОбработчиков.Добавить("ПриОбработке"); 129 | МассивОбработчиков.Добавить("ПриОбработкеДополнительный"); 130 | МассивОбработчиков.Добавить("ПослеОбработки"); 131 | 132 | // ПравилаОчисткиОбъектов 133 | МассивОбработчиков.Добавить("ПередОбработкойПравила"); 134 | МассивОбработчиков.Добавить("ПередУдалениемОбъекта"); 135 | МассивОбработчиков.Добавить("ПослеОбработкиПравила"); 136 | 137 | // Параметры 138 | МассивОбработчиков.Добавить("ПослеЗагрузкиПараметра"); 139 | 140 | СтруктураНастроек.Вставить("ИменаСобытийКонвертации", МассивОбработчиков); 141 | 142 | // Исключения для выгрузки в XML 143 | ИменаИсключений = Новый Массив; 144 | ИменаИсключений.Добавить("Правило"); 145 | ИменаИсключений.Добавить("Запрос"); 146 | ИменаИсключений.Добавить("Свойства"); 147 | ИменаИсключений.Добавить("Свойство"); 148 | ИменаИсключений.Добавить("Параметр"); 149 | ИменаИсключений.Добавить("Значения"); 150 | ИменаИсключений.Добавить("Значение"); 151 | ИменаИсключений.Добавить("Алгоритм"); 152 | ИменаИсключений.Добавить("Группа"); 153 | ИменаИсключений.Добавить("Текст"); 154 | 155 | СтруктураНастроек.Вставить("ИменаИсключений", ИменаИсключений); 156 | 157 | Возврат СтруктураНастроек; 158 | 159 | КонецФункции 160 | 161 | Процедура СоздатьКаталогРасширенный(ИмяКаталога) Экспорт 162 | 163 | Файл = Новый Файл(ИмяКаталога); 164 | Если Файл.Существует() И Файл.ЭтоКаталог() Тогда 165 | УдалитьФайлы(ИмяКаталога); 166 | КонецЕсли; 167 | СоздатьКаталог(ИмяКаталога); 168 | 169 | КонецПроцедуры 170 | 171 | Функция ЭтотКаталогСуществует(Путь) Экспорт 172 | Файл = Новый Файл(Путь); 173 | Возврат Файл.Существует() И Файл.ЭтоКаталог(); 174 | КонецФункции 175 | 176 | Процедура ЗаписатьЗначениеВТекстовыйДокумент(ИмяФайла, Содержимое) Экспорт 177 | 178 | ТекстовыйДокумент = Новый ТекстовыйДокумент; 179 | ТекстовыйДокумент.УстановитьТекст(Содержимое); 180 | ТекстовыйДокумент.Записать(ИмяФайла, КодировкаТекста.UTF8); 181 | 182 | КонецПроцедуры 183 | 184 | Процедура ОчиститьИсходныйКаталог(КаталогФайлов) Экспорт 185 | МассивФайлов = НайтиФайлы(КаталогФайлов, "*.*", Истина); 186 | ЧислоФайлов = МассивФайлов.ВГраница(); 187 | Для й = 1 По ЧислоФайлов Цикл 188 | УдалитьФайлы(МассивФайлов[ЧислоФайлов - й].ПолноеИмя); 189 | КонецЦикла; 190 | КонецПроцедуры 191 | 192 | Функция ПолучитьПутьВРабочемКаталоге(Путь, Каталог) Экспорт 193 | Возврат СтрЗаменить(Путь, Каталог, ""); 194 | КонецФункции 195 | 196 | Функция ПолучитьПолныйПутьККаталогу(Путь) Экспорт 197 | 198 | Файл = Новый Файл(Путь); 199 | ПолноеИмяКаталога = Файл.ПолноеИмя; 200 | Если Прав(ПолноеИмяКаталога, 1) = ПолучитьРазделительПути() Тогда 201 | ПолноеИмяКаталога = Лев(ПолноеИмяКаталога, СтрДлина(ПолноеИмяКаталога) - 1); 202 | КонецЕсли; 203 | Возврат ПолноеИмяКаталога; 204 | 205 | КонецФункции 206 | 207 | Функция ЭтоGitРепозиторий(ТекущийКаталог) Экспорт 208 | 209 | КаталогПроекта = Новый Файл(ОбъединитьПути(ТекущийКаталог, ".git")); 210 | Если Не КаталогПроекта.Существует() Тогда 211 | Возврат Ложь; 212 | КонецЕсли; 213 | Возврат Истина; 214 | 215 | КонецФункции 216 | 217 | Процедура ЗаменитьВСтрокеЗапрещенныеСимволы(ВходящееЗначение) Экспорт 218 | 219 | ЗапрещенныеСимволы = ЗапрещенныеСимволыВПути(); 220 | Для Каждого ЗапрещенныйСимвол Из ЗапрещенныеСимволы Цикл 221 | ВходящееЗначение = СтрЗаменить(ВходящееЗначение, ЗапрещенныйСимвол, ""); 222 | КонецЦикла; 223 | 224 | КонецПроцедуры 225 | 226 | Функция ЗапрещенныеСимволыВПути() 227 | 228 | // \ — разделитель подкаталогов 229 | // / — разделитель ключей командного интерпретатора 230 | // : — отделяет букву диска или имя альтернативного потока данных 231 | // * — заменяющий символ (маска «любое количество любых символов») 232 | // ? — заменяющий символ (маска «один любой символ») 233 | // " — используется для указания путей, содержащих пробелы 234 | // < — перенаправление ввода 235 | // > — перенаправление вывода 236 | // | — обозначает конвейер 237 | // + — (в различных версиях) конкатенация 238 | 239 | ЗапрещенныеСимволы = Новый Массив(); 240 | ЗапрещенныеСимволы.Добавить("\"); 241 | ЗапрещенныеСимволы.Добавить("/"); 242 | ЗапрещенныеСимволы.Добавить(":"); 243 | ЗапрещенныеСимволы.Добавить("*"); 244 | ЗапрещенныеСимволы.Добавить("?"); 245 | ЗапрещенныеСимволы.Добавить(""""); 246 | ЗапрещенныеСимволы.Добавить(">"); 247 | ЗапрещенныеСимволы.Добавить("<"); 248 | ЗапрещенныеСимволы.Добавить("|"); 249 | ЗапрещенныеСимволы.Добавить("+"); 250 | Возврат ЗапрещенныеСимволы; 251 | 252 | КонецФункции 253 | 254 | Функция РазложитьСтрокуВМассивПодстрок(Знач Строка, Знач Разделитель = ",", Знач ПропускатьПустыеСтроки = Неопределено) Экспорт 255 | 256 | Результат = Новый Массив; 257 | 258 | // для обеспечения обратной совместимости 259 | Если ПропускатьПустыеСтроки = Неопределено Тогда 260 | ПропускатьПустыеСтроки = ?(Разделитель = " ", Истина, Ложь); 261 | Если ПустаяСтрока(Строка) Тогда 262 | Если Разделитель = " " Тогда 263 | Результат.Добавить(""); 264 | КонецЕсли; 265 | Возврат Результат; 266 | КонецЕсли; 267 | КонецЕсли; 268 | // 269 | 270 | Позиция = Найти(Строка, Разделитель); 271 | Пока Позиция > 0 Цикл 272 | Подстрока = Лев(Строка, Позиция - 1); 273 | Если Не ПропускатьПустыеСтроки Или Не ПустаяСтрока(Подстрока) Тогда 274 | Результат.Добавить(Подстрока); 275 | КонецЕсли; 276 | Строка = Сред(Строка, Позиция + СтрДлина(Разделитель)); 277 | Позиция = Найти(Строка, Разделитель); 278 | КонецЦикла; 279 | 280 | Если Не ПропускатьПустыеСтроки Или Не ПустаяСтрока(Строка) Тогда 281 | Результат.Добавить(Строка); 282 | КонецЕсли; 283 | 284 | Возврат Результат; 285 | 286 | КонецФункции -------------------------------------------------------------------------------- /src/core/Модули/РазобратьПравилаОбмена.os: -------------------------------------------------------------------------------- 1 | #Использовать fs 2 | 3 | Перем КаталогИсходныхПравил; 4 | Перем ИменаРеквизитовКонвертации; 5 | Перем ИменаСобытийКонвертации; 6 | Перем ИменаСвойствКонвертации; 7 | Перем ИменаСвойствГрупп; 8 | Перем ИменаИсключений; 9 | Перем ТекущийПорядок; 10 | Перем ЭтоПравилаРегистрации; 11 | Перем НаименованиеКаталогаСобытий; 12 | Перем ДопустимыеИмяУзловРодителей; 13 | 14 | Процедура ИнициализироватьНачальныеПараметры() 15 | 16 | СтруктураПараметров = ОбщийФункционал.ПолучитьПараметрыПравил(); 17 | ИменаСобытийКонвертации = СтруктураПараметров.ИменаСобытийКонвертации; 18 | ИменаРеквизитовКонвертации = СтруктураПараметров.ИменаРеквизитовКонвертации; 19 | ИменаСвойствКонвертации = СтруктураПараметров.ИменаСвойствКонвертации; 20 | ИменаСвойствГрупп = СтруктураПараметров.ИменаСвойствГрупп; 21 | ИменаСобытийКонвертации = СтруктураПараметров.ИменаСобытийКонвертации; 22 | ИменаИсключений = СтруктураПараметров.ИменаИсключений; 23 | 24 | КонецПроцедуры 25 | 26 | Процедура ВыполнитьРазбор( 27 | Знач ОсновнойКаталогПравил, 28 | Знач ПутьКФайлуПравилОбмена, 29 | Знач ВыгружатьВВыбранныйКаталог = Ложь) Экспорт 30 | 31 | ФайлПравил = Новый Файл(ПутьКФайлуПравилОбмена); 32 | Если ВыгружатьВВыбранныйКаталог Тогда 33 | КаталогИсходныхПравил = ОсновнойКаталогПравил; 34 | Иначе 35 | КаталогИсходныхПравил = ОбъединитьПути(ОсновнойКаталогПравил, ФайлПравил.Имя); 36 | ОбщийФункционал.СоздатьКаталогРасширенный(КаталогИсходныхПравил); 37 | КонецЕсли; 38 | ИнициализироватьНачальныеПараметры(); 39 | РазобратьПравила(ПутьКФайлуПравилОбмена); 40 | 41 | КонецПроцедуры 42 | 43 | Процедура РазобратьПравила(ПутьКПравилам) 44 | 45 | Дерево = ПрочитатьXMLВДеревоЗначений(ПутьКПравилам); 46 | ИмяКорневогоУзла = Неопределено; 47 | КорневойУзел = Неопределено; 48 | Если Дерево.Строки.Количество() > 0 Тогда 49 | КорневойУзел = Дерево.Строки[0]; 50 | ИмяКорневогоУзла = КорневойУзел.Имя; 51 | КонецЕсли; 52 | 53 | Если НЕ (ИмяКорневогоУзла = "ПравилаОбмена" Или ИмяКорневогоУзла = "ПравилаРегистрации") Тогда 54 | Сообщить("Стоп. Ошибка выгрузки правил. Не распознан вид правил: " + ИмяКорневогоУзла); 55 | УдалитьФайлы(КаталогИсходныхПравил); 56 | Возврат; 57 | КонецЕсли; 58 | 59 | КорневойУзел.Каталог = КаталогИсходныхПравил; 60 | МассивРеквизитовУзла = Новый Массив; 61 | РекурсивноРазобратьДеревоПравил(КорневойУзел, ИмяКорневогоУзла, КаталогИсходныхПравил, МассивРеквизитовУзла); 62 | ЗаписатьРеквизитыВФайл(МассивРеквизитовУзла, КорневойУзел, ИмяКорневогоУзла, КаталогИсходныхПравил); 63 | 64 | КонецПроцедуры 65 | 66 | Процедура РекурсивноРазобратьДеревоПравил(Элемент, ИмяЭлемента, ТекущийКаталог, МассивРеквизитовУзла = Неопределено) 67 | 68 | Для Каждого ТекущаяСтрока Из Элемент.Строки Цикл 69 | 70 | Если ТекущаяСтрока.ТипСтроки = "Атрибут" Тогда 71 | 72 | Если МассивРеквизитовУзла <> Неопределено 73 | И НЕ ТекущаяСтрока.Имя = "Текст" 74 | И МассивРеквизитовУзла.Найти(ТекущаяСтрока) = Неопределено Тогда 75 | 76 | МассивРеквизитовУзла.Добавить(ТекущаяСтрока); 77 | 78 | КонецЕсли; 79 | 80 | Иначе 81 | 82 | ИмяЭлементаСтроки = ТекущаяСтрока.Имя; 83 | 84 | Идентификатор = ?(Не ПустаяСтрока(ТекущаяСтрока.Идентификатор), ТекущаяСтрока.Идентификатор, ТекущаяСтрока.Имя); 85 | 86 | Если (ИмяЭлементаСтроки = "Параметры" И НЕ ТекущаяСтрока.Родитель.Имя = "Алгоритм") 87 | Или ИмяЭлементаСтроки = "Обработки" 88 | Или ИмяЭлементаСтроки = "ПравилаКонвертацииОбъектов" 89 | Или ИмяЭлементаСтроки = "ПравилаВыгрузкиДанных" 90 | Или ИмяЭлементаСтроки = "ПравилаОчисткиДанных" 91 | Или ИмяЭлементаСтроки = "Алгоритмы" 92 | Или ИмяЭлементаСтроки = "Запросы" 93 | Или ИмяЭлементаСтроки = "СоставПланаОбмена" 94 | Или ИмяЭлементаСтроки = "ПравилаРегистрацииОбъектов" 95 | Или ИмяЭлементаСтроки = "ОтборПоСвойствамПланаОбмена" 96 | Или ИмяЭлементаСтроки = "ОтборПоСвойствамОбъекта" 97 | Или ИмяЭлементаСтроки = "ТаблицаСвойствОбъекта" 98 | Или ИмяЭлементаСтроки = "ТаблицаСвойствПланаОбмена" Тогда 99 | 100 | ИмяКаталогаСтроки = ОбъединитьПути(ТекущийКаталог, ИмяЭлементаСтроки); 101 | СоздатьКаталог(ИмяКаталогаСтроки); 102 | ТекущаяСтрока.Каталог = ИмяКаталогаСтроки; 103 | РекурсивноРазобратьДеревоПравил(ТекущаяСтрока, ИмяЭлементаСтроки, ИмяКаталогаСтроки); 104 | 105 | ИначеЕсли ИменаСобытийКонвертации.Найти(ИмяЭлементаСтроки) <> Неопределено Тогда 106 | 107 | ИмяКаталогаСобытий = СоздатьКаталогСобытий(ТекущийКаталог); 108 | ЗаписатьСобытиеПравилВФайл(ТекущаяСтрока, ИмяЭлементаСтроки, ИмяКаталогаСобытий); 109 | 110 | ИначеЕсли ИмяЭлементаСтроки = "Текст" 111 | И (ТекущаяСтрока.Родитель.Имя = "Алгоритм" 112 | Или ТекущаяСтрока.Родитель.Имя = "Запрос") Тогда 113 | 114 | ИмяКаталогаСобытий = СоздатьКаталогСобытий(ТекущийКаталог); 115 | ЗаписатьСобытиеПравилВФайл(ТекущаяСтрока, ТекущаяСтрока.Имя, ИмяКаталогаСобытий); 116 | 117 | ИначеЕсли ИмяЭлементаСтроки = "Параметры" И ТекущаяСтрока.Родитель.Имя = "Алгоритм" Тогда 118 | 119 | ИмяКаталогаСобытий = СоздатьКаталогСобытий(ТекущийКаталог); 120 | ЗаписатьСобытиеПравилВФайл(ТекущаяСтрока, ТекущаяСтрока.Имя, ИмяКаталогаСобытий, Неопределено); 121 | 122 | ИначеЕсли ИмяЭлементаСтроки = "Группа" Или ИмяЭлементаСтроки = "Свойства" Или ИмяЭлементаСтроки = "Значения" Тогда 123 | 124 | МассивРеквизитовТекущегоУзла = Новый Массив; 125 | Идентификатор = ?(Не ПустаяСтрока(ТекущаяСтрока.Идентификатор), ТекущаяСтрока.Идентификатор, ТекущаяСтрока.Имя); 126 | ОбщийФункционал.ЗаменитьВСтрокеЗапрещенныеСимволы(Идентификатор); 127 | ИмяКаталогаСтроки = ОбъединитьПути(ТекущийКаталог, Идентификатор); 128 | СоздатьКаталог(ИмяКаталогаСтроки); 129 | ТекущаяСтрока.Каталог = ИмяКаталогаСтроки; 130 | 131 | РекурсивноРазобратьДеревоПравил(ТекущаяСтрока, ИмяЭлементаСтроки, ИмяКаталогаСтроки, МассивРеквизитовТекущегоУзла); 132 | 133 | Если ИмяЭлементаСтроки = "Группа" Тогда 134 | ЗаписатьРеквизитыВФайл(МассивРеквизитовТекущегоУзла, ТекущаяСтрока, ИмяЭлементаСтроки, ИмяКаталогаСтроки); 135 | КонецЕсли; 136 | 137 | ИначеЕсли ИмяЭлементаСтроки = "Правило" 138 | Или ИмяЭлементаСтроки = "Запрос" 139 | Или ИмяЭлементаСтроки = "Алгоритм" 140 | Или ИмяЭлементаСтроки = "Значение" 141 | Или ИмяЭлементаСтроки = "Свойство" 142 | Или ИмяЭлементаСтроки = "Параметр" 143 | Или ИмяЭлементаСтроки = "Обработка" 144 | Или ИмяЭлементаСтроки = "ЭлементОтбора" Или ИмяЭлементаСтроки = "Элемент" Тогда 145 | 146 | МассивРеквизитовТекущегоУзла = Новый Массив; 147 | 148 | Идентификатор = ?(Не ПустаяСтрока(ТекущаяСтрока.Идентификатор), ТекущаяСтрока.Идентификатор, ТекущаяСтрока.Имя); 149 | ОбщийФункционал.ЗаменитьВСтрокеЗапрещенныеСимволы(Идентификатор); 150 | ИмяКаталогаСтроки = ОбъединитьПути(ТекущийКаталог, Идентификатор); 151 | СоздатьКаталог(ИмяКаталогаСтроки); 152 | 153 | ТекущаяСтрока.Каталог = ИмяКаталогаСтроки; 154 | РекурсивноРазобратьДеревоПравил(ТекущаяСтрока, ИмяЭлементаСтроки, ИмяКаталогаСтроки, МассивРеквизитовТекущегоУзла); 155 | 156 | // пишем в файл 157 | ЗаписатьРеквизитыВФайл(МассивРеквизитовТекущегоУзла, ТекущаяСтрока, ИмяЭлементаСтроки, ИмяКаталогаСтроки); 158 | 159 | // Запишем двочные данные узла обработка 160 | Если ИмяЭлементаСтроки = "Обработка" Тогда 161 | ЗначениеУзла = ТекущаяСтрока.Значение; 162 | Если Не ПустаяСтрока(ЗначениеУзла) Тогда 163 | ЗаписатьСобытиеПравилВФайл(ТекущаяСтрока, "ДвоичныеДанные", ТекущаяСтрока.Каталог, Неопределено); 164 | КонецЕсли; 165 | КонецЕсли; 166 | Иначе 167 | 168 | Если МассивРеквизитовУзла = Неопределено Тогда 169 | МассивРеквизитовУзла = Новый Массив; 170 | КонецЕсли; 171 | 172 | КаталогРодителя = ТекущаяСтрока.Родитель.Каталог; 173 | Если ЗначениеЗаполнено(КаталогРодителя) Тогда 174 | МассивРеквизитовУзла.Добавить(ТекущаяСтрока); 175 | КонецЕсли; 176 | 177 | КонецЕсли; 178 | 179 | КонецЕсли; 180 | 181 | КонецЦикла; 182 | 183 | КонецПроцедуры 184 | 185 | Процедура ЗаписатьСобытиеПравилВФайл(ТекущаяСтрока, ИмяЭлементаСтроки, ИмяКаталогаСобытий, Расширение = "bsl") 186 | 187 | ОбщийФункционал.ЗаписатьЗначениеВТекстовыйДокумент( 188 | ОбъединитьПути(ИмяКаталогаСобытий, ИмяЭлементаСтроки + ?(Расширение = Неопределено, "", "." + Расширение)), 189 | ТекущаяСтрока.Значение); 190 | 191 | КонецПроцедуры 192 | 193 | Процедура ЗаписатьРеквизитыВФайл(МассивРеквизитовТекущегоУзла, ТекущаяСтрока, ИмяЭлементаСтроки, ИмяКаталогаСтроки) 194 | 195 | Если МассивРеквизитовТекущегоУзла.Количество() = 0 Тогда 196 | Возврат; 197 | КонецЕсли; 198 | 199 | КаталогРодителя = ТекущаяСтрока.Каталог; 200 | ИмяФайлаАтрибутов = ОбъединитьПути(КаталогРодителя, ТекущаяСтрока.Имя + ".xml"); 201 | 202 | ЗаписьXML = Новый ЗаписьXML; 203 | ЗаписьXML.УстановитьСтроку(); 204 | ЗаписьXML.ЗаписатьНачалоЭлемента(ТекущаяСтрока.Имя); 205 | Для Каждого СтрокаДерева Из МассивРеквизитовТекущегоУзла Цикл 206 | 207 | Если ЭтоТегИсключение(СтрокаДерева.Имя) Тогда 208 | Продолжить; 209 | КонецЕсли; 210 | 211 | Попытка 212 | ЗаписатьXMLЭлемента(ЗаписьXML, СтрокаДерева); 213 | Исключение 214 | Сообщить("Не удалось " + ОписаниеОшибки()); 215 | Прервать; 216 | КонецПопытки; 217 | КонецЦикла; 218 | 219 | ЗаписьXML.ЗаписатьКонецЭлемента(); 220 | ОбщийФункционал.ЗаписатьЗначениеВТекстовыйДокумент(ИмяФайлаАтрибутов, ЗаписьXML.Закрыть()); 221 | 222 | КонецПроцедуры 223 | 224 | Процедура ЗаписатьXMLЭлемента(ЗаписьXML, СтрокаУзла) 225 | 226 | Если СтрокаУзла.Имя = "Текст" Или ИменаСобытийКонвертации.Найти(СтрокаУзла.Имя) <> Неопределено Тогда 227 | Возврат; 228 | КонецЕсли; 229 | 230 | Если СтрокаУзла.ТипСтроки = "Атрибут" Тогда 231 | ЗаписьXML.ЗаписатьАтрибут(СтрокаУзла.Имя, СтрокаУзла.Значение); 232 | Возврат; 233 | КонецЕсли; 234 | 235 | МассивАтрибутов = Новый Массив; 236 | МассивСвойств = Новый Массив; 237 | 238 | Для Каждого Строка Из СтрокаУзла.Строки Цикл 239 | 240 | Если Строка.ТипСтроки = "Атрибут" Тогда 241 | МассивАтрибутов.Добавить(Строка); 242 | Иначе 243 | МассивСвойств.Добавить(Строка); 244 | КонецЕсли; 245 | 246 | КонецЦикла; 247 | 248 | ЗаписьXML.ЗаписатьНачалоЭлемента(СтрокаУзла.Имя); 249 | 250 | Для Каждого Строка Из МассивАтрибутов Цикл 251 | 252 | ЗаписьXML.ЗаписатьАтрибут(Строка.Имя, Строка.Значение); 253 | 254 | КонецЦикла; 255 | 256 | Для Каждого Строка Из МассивСвойств Цикл 257 | ЗаписатьXMLЭлемента(ЗаписьXML, Строка); 258 | КонецЦикла; 259 | 260 | Если ЗначениеЗаполнено(СтрокаУзла.Значение) Тогда 261 | ЗаписьXML.ЗаписатьТекст(СтрокаУзла.Значение); 262 | КонецЕсли; 263 | 264 | ЗаписьXML.ЗаписатьКонецЭлемента(); 265 | 266 | КонецПроцедуры 267 | 268 | Функция ПрочитатьXMLВДеревоЗначений(Путь) 269 | 270 | ЭтоПравилаРегистрации = Ложь; 271 | Дерево = ОбщийФункционал.ПолучитьСтруктуруДереваПравил(); 272 | ЧтениеXML = Новый ЧтениеXML; 273 | ЧтениеXML.ОткрытьФайл(Путь); 274 | ПрочитатьXMLРекурсивно(ЧтениеXML, Дерево.Строки); 275 | ЧтениеXML.Закрыть(); 276 | 277 | Возврат Дерево; 278 | 279 | КонецФункции 280 | 281 | Функция ЭтоТегИсключение(Значение) 282 | 283 | Возврат ИменаИсключений.Найти(Значение) <> Неопределено Или ИменаСобытийКонвертации.Найти(Значение) <> Неопределено; 284 | 285 | КонецФункции 286 | 287 | Процедура ПрочитатьXMLРекурсивно(ЧтениеXML, ТекущаяСтрокаДерева) 288 | 289 | Пока ЧтениеXML.Прочитать() Цикл 290 | Если ЧтениеXML.ТипУзла = ТипУзлаXML.НачалоЭлемента Тогда 291 | 292 | Если Не ЭтоПравилаРегистрации И ЧтениеXML.Имя = "ПравилаРегистрации" Тогда 293 | ЭтоПравилаРегистрации = Истина; 294 | КонецЕсли; 295 | 296 | НоваяСтрока = ТекущаяСтрокаДерева.Добавить(); 297 | НоваяСтрока.Имя = ЧтениеXML.Имя; 298 | НоваяСтрока.ТипСтроки = "Элемент"; 299 | 300 | Пока ЧтениеXML.ПрочитатьАтрибут() Цикл 301 | 302 | НоваяСтрокаАтрибут = НоваяСтрока.Строки.Добавить(); 303 | НоваяСтрокаАтрибут.Имя = ЧтениеXML.Имя; 304 | НоваяСтрокаАтрибут.Значение = ЧтениеXML.Значение; 305 | НоваяСтрокаАтрибут.ТипСтроки = "Атрибут"; 306 | 307 | Если ЧтениеXML.Имя = "Имя" Тогда 308 | НоваяСтрока.Идентификатор = НоваяСтрокаАтрибут.Значение; 309 | КонецЕсли; 310 | 311 | КонецЦикла; 312 | 313 | ПрочитатьXMLРекурсивно(ЧтениеXML, НоваяСтрока.Строки); 314 | 315 | ИначеЕсли ЧтениеXML.ТипУзла = ТипУзлаXML.Текст Тогда 316 | 317 | ТекущаяСтрокаДерева.Родитель.Значение = ЧтениеXML.Значение; 318 | 319 | ИмяУзлаРодителя = ТекущаяСтрокаДерева.Родитель.Имя; 320 | 321 | Если Не ЭтоПравилаРегистрации 322 | И ЭтоДопустимоеИмяРодителяПравила(ИмяУзлаРодителя, "ПравилаОбмена") Тогда 323 | 324 | ТекущаяСтрокаДерева.Родитель.Родитель.Идентификатор = СокрЛП(ЧтениеXML.Значение); 325 | 326 | КонецЕсли; 327 | 328 | Если ЭтоПравилаРегистрации 329 | И ЭтоДопустимоеИмяРодителяПравила(ИмяУзлаРодителя, "ПравилаРегистрации") Тогда 330 | 331 | ТекущаяСтрокаДерева.Родитель.Родитель.Идентификатор = СокрЛП(ЧтениеXML.Значение); 332 | 333 | КонецЕсли; 334 | 335 | Если ЭтоПравилаРегистрации 336 | И ИмяУзлаРодителя = "Тип" 337 | И ТекущаяСтрокаДерева.Родитель.Родитель.Имя = "Элемент" Тогда 338 | 339 | ТекущаяСтрокаДерева.Родитель.Родитель.Идентификатор = СокрЛП(ЧтениеXML.Значение); 340 | 341 | КонецЕсли; 342 | 343 | Если ИмяУзлаРодителя = "Порядок" Тогда 344 | 345 | ТекущаяСтрокаДерева.Родитель.Родитель.Порядок = Число(СокрЛП(ЧтениеXML.Значение)); 346 | 347 | КонецЕсли; 348 | 349 | ИначеЕсли ЧтениеXML.ТипУзла = ТипУзлаXML.КонецЭлемента Тогда 350 | 351 | Возврат; 352 | 353 | Иначе 354 | 355 | Продолжить; 356 | 357 | КонецЕсли; 358 | КонецЦикла; 359 | 360 | КонецПроцедуры 361 | 362 | Функция ЭтоДопустимоеИмяРодителяПравила(Имя, ВидПравил) 363 | 364 | КоллекцияИмена = ДопустимыеИмяУзловРодителей[ВидПравил]; 365 | Возврат КоллекцияИмена.Найти(Имя) <> Неопределено; 366 | 367 | КонецФункции 368 | 369 | Функция СоздатьКаталогСобытий(ТекущийКаталог) 370 | 371 | ИмяКаталога = ОбъединитьПути(ТекущийКаталог, НаименованиеКаталогаСобытий); 372 | Файл = Новый Файл(ИмяКаталога); 373 | Если Не Файл.Существует() Тогда 374 | СоздатьКаталог(ИмяКаталога); 375 | КонецЕсли; 376 | Файл = Неопределено; 377 | 378 | Возврат ИмяКаталога; 379 | 380 | КонецФункции 381 | 382 | // Инициализация модуля 383 | НаименованиеКаталогаСобытий = "Ext"; 384 | 385 | ДопустимыеИмяУзловРодителей = Новый Структура; 386 | ДопустимыеИмяУзловРодителей.Вставить("ПравилаРегистрации", Новый Массив); 387 | ДопустимыеИмяУзловРодителей.Вставить("ПравилаОбмена", Новый Массив); 388 | 389 | ДопустимыеИмяУзловРодителей.ПравилаРегистрации.Добавить("Номер"); 390 | ДопустимыеИмяУзловРодителей.ПравилаРегистрации.Добавить("Имя"); 391 | ДопустимыеИмяУзловРодителей.ПравилаРегистрации.Добавить("Наименование"); 392 | 393 | ДопустимыеИмяУзловРодителей.ПравилаОбмена.Добавить("Код"); 394 | ДопустимыеИмяУзловРодителей.ПравилаОбмена.Добавить("Номер"); 395 | ДопустимыеИмяУзловРодителей.ПравилаОбмена.Добавить("Имя"); 396 | -------------------------------------------------------------------------------- /src/core/Модули/СобратьПравилаОбмена.os: -------------------------------------------------------------------------------- 1 | #Использовать fs 2 | 3 | Перем ТекущийПорядок; 4 | Перем ИменаСобытийКонвертации; 5 | Перем ЕстьОшибки; // для остановки сборки, при возникновении ошибки 6 | 7 | Процедура ВыполнитьСборку(Знач КаталогИсходников, Знач КаталогСборки) Экспорт 8 | 9 | ЕстьОшибки = Ложь; 10 | ИнициализироватьИмена(); 11 | ДеревоФайлов = ПолучитьДеревоФайловПоКаталогу(Новый Файл(КаталогИсходников)); 12 | ДеревоПравил = ЗагрузитьКаталогиВДеревоПравил(ДеревоФайлов.Строки[0]); 13 | СортироватьДеревоПравил(ДеревоПравил); 14 | 15 | ИмяВременногоФайла = ПолучитьXMLПоУзлуДерева(ДеревоПравил.Строки[0]); 16 | ОбработатьОтступыВXML(ИмяВременногоФайла); 17 | ФайлКаталог = Новый Файл(КаталогИсходников); 18 | КопироватьФайл(ИмяВременногоФайла, ОбъединитьПути(КаталогСборки, ФайлКаталог.Имя)); 19 | УдалитьФайлы(ИмяВременногоФайла); 20 | 21 | Сообщить("Собран файл: " + ИмяВременногоФайла); 22 | 23 | КонецПроцедуры 24 | 25 | Функция ПолучитьДеревоФайловПоКаталогу(КорневойКаталог) 26 | 27 | Дерево = Новый ДеревоЗначений; 28 | Дерево.Колонки.Добавить("Имя"); 29 | Дерево.Колонки.Добавить("Путь"); 30 | Дерево.Колонки.Добавить("ЭтоКаталог"); 31 | 32 | ТекущаяСтрока = Дерево.Строки.Добавить(); 33 | ТекущаяСтрока.Имя = КорневойКаталог.Имя; 34 | ТекущаяСтрока.Путь = КорневойКаталог.ПолноеИмя; 35 | ТекущаяСтрока.ЭтоКаталог = КорневойКаталог.ЭтоКаталог(); 36 | 37 | РазложитьКаталогиВДерево(Дерево, ТекущаяСтрока, ТекущаяСтрока.Путь); 38 | 39 | Возврат Дерево; 40 | 41 | КонецФункции 42 | 43 | Процедура РазложитьКаталогиВДерево(Дерево, ТекущаяСтрокаДерева, ТекущийКаталог) 44 | 45 | Файлы = НайтиФайлы(ОбъединитьПути(ТекущийКаталог, ""), "*"); 46 | 47 | Для Каждого Файл Из Файлы Цикл 48 | 49 | НоваяСтрокаДерева = ТекущаяСтрокаДерева.Строки.Добавить(); 50 | НоваяСтрокаДерева.Имя = Файл.Имя; 51 | НоваяСтрокаДерева.Путь = Файл.ПолноеИмя; 52 | НоваяСтрокаДерева.ЭтоКаталог = Файл.ЭтоКаталог(); 53 | 54 | Если НоваяСтрокаДерева.ЭтоКаталог Тогда 55 | РазложитьКаталогиВДерево(Дерево, НоваяСтрокаДерева, НоваяСтрокаДерева.Путь); 56 | КонецЕсли; 57 | КонецЦикла; 58 | 59 | КонецПроцедуры 60 | 61 | Функция ЗагрузитьКаталогиВДеревоПравил(ДеревоКаталогов) 62 | 63 | ДеревоПравил = ОбщийФункционал.ПолучитьСтруктуруДереваПравил(); 64 | 65 | КорневойУзел = Неопределено; 66 | Для Каждого СтрокаДерева Из ДеревоКаталогов.Строки Цикл 67 | Если Не СтрокаДерева.ЭтоКаталог И СтрЧислоВхождений(СтрокаДерева.Имя, ".xml") > 0 Тогда 68 | КорневойУзел = СтрокаДерева; 69 | КонецЕсли; 70 | КонецЦикла; 71 | 72 | ИмяКорневогоУзла = СтрЗаменить(КорневойУзел.Имя, ".xml", ""); 73 | Если ИмяКорневогоУзла = "ПравилаОбмена" Тогда 74 | 75 | УзелПравил = ДобавитьНовуюСтрокуДереваПравил(ДеревоПравил, ИмяКорневогоУзла); 76 | Загрузить_РеквизитыКонвертации(КорневойУзел, УзелПравил); 77 | Загрузить_СобытияКонвертации(ДеревоКаталогов, УзелПравил); 78 | Для Каждого СтрокаДерева Из ДеревоКаталогов.Строки Цикл 79 | Если СтрокаДерева.Имя = "Параметры" Тогда 80 | Загрузить_Параметры(СтрокаДерева, УзелПравил); 81 | ИначеЕсли СтрокаДерева.Имя = "Обработки" Тогда 82 | Загрузить_Обработки(СтрокаДерева, УзелПравил); 83 | ИначеЕсли СтрокаДерева.Имя = "ПравилаКонвертацииОбъектов" Тогда 84 | Загрузить_ПравилаКонвертацииОбъектов(СтрокаДерева, УзелПравил); 85 | ИначеЕсли СтрокаДерева.Имя = "ПравилаВыгрузкиДанных" Тогда 86 | Загрузить_ПравилаВыгрузкиДанных(СтрокаДерева, УзелПравил); 87 | ИначеЕсли СтрокаДерева.Имя = "ПравилаОчисткиДанных" Тогда 88 | Загрузить_ПравилаОчисткиДанных(СтрокаДерева, УзелПравил); 89 | ИначеЕсли СтрокаДерева.Имя = "Алгоритмы" Тогда 90 | Загрузить_Алгоритмы(СтрокаДерева, УзелПравил); 91 | ИначеЕсли СтрокаДерева.Имя = "Запросы" Тогда 92 | Загрузить_Запросы(СтрокаДерева, УзелПравил); 93 | Иначе 94 | Сообщить("Имя узла не поддерживается: " + СтрокаДерева.Имя); 95 | КонецЕсли; 96 | КонецЦикла; 97 | 98 | Иначе 99 | Сообщить("Тип правил не определен: " + ИмяКорневогоУзла); 100 | КонецЕсли; 101 | СортироватьДеревоПоПорядку(ДеревоПравил); 102 | Возврат ДеревоПравил; 103 | 104 | КонецФункции 105 | 106 | Процедура СортироватьДеревоПравил(Дерево) 107 | 108 | Структура = Новый Структура; 109 | Структура.Вставить("ПравилаОбмена", Новый Массив); 110 | Структура.ПравилаОбмена.Добавить("ВерсияФормата"); 111 | Структура.ПравилаОбмена.Добавить("Ид"); 112 | Структура.ПравилаОбмена.Добавить("Наименование"); 113 | Структура.ПравилаОбмена.Добавить("ДатаВремяСоздания"); 114 | Структура.ПравилаОбмена.Добавить("Источник"); 115 | Структура.ПравилаОбмена.Добавить("Приемник"); 116 | Структура.ПравилаОбмена.Добавить("ПослеЗагрузкиПравилОбмена"); 117 | Структура.ПравилаОбмена.Добавить("ПередПолучениемИзмененныхОбъектов"); 118 | Структура.ПравилаОбмена.Добавить("ПослеПолученияИнформацииОбУзлахОбмена"); 119 | Структура.ПравилаОбмена.Добавить("ПередВыгрузкойДанных"); 120 | Структура.ПравилаОбмена.Добавить("ПослеВыгрузкиДанных"); 121 | Структура.ПравилаОбмена.Добавить("ПередЗагрузкойДанных"); 122 | Структура.ПравилаОбмена.Добавить("ПослеЗагрузкиДанных"); 123 | Структура.ПравилаОбмена.Добавить("ПередВыгрузкойОбъекта"); 124 | Структура.ПравилаОбмена.Добавить("ПередКонвертациейОбъекта"); 125 | Структура.ПравилаОбмена.Добавить("ПослеВыгрузкиОбъекта"); 126 | Структура.ПравилаОбмена.Добавить("ПередЗагрузкойОбъекта"); 127 | Структура.ПравилаОбмена.Добавить("ПослеЗагрузкиОбъекта"); 128 | Структура.ПравилаОбмена.Добавить("ПередОтправкойИнформацииОбУдалении"); 129 | Структура.ПравилаОбмена.Добавить("ПриПолученииИнформацииОбУдалении"); 130 | Структура.ПравилаОбмена.Добавить("ПослеЗагрузкиПараметров"); 131 | Структура.ПравилаОбмена.Добавить("Параметры"); 132 | Структура.ПравилаОбмена.Добавить("Обработки"); 133 | Структура.ПравилаОбмена.Добавить("ПравилаКонвертацииОбъектов"); 134 | Структура.ПравилаОбмена.Добавить("ПравилаВыгрузкиДанных"); 135 | Структура.ПравилаОбмена.Добавить("ПравилаОчисткиДанных"); 136 | Структура.ПравилаОбмена.Добавить("Алгоритмы"); 137 | Структура.ПравилаОбмена.Добавить("Запросы"); 138 | 139 | Структура.Вставить("ПравилоПКО", Новый Массив); 140 | Структура.ПравилоПКО.Добавить("Код"); 141 | Структура.ПравилоПКО.Добавить("Наименование"); 142 | Структура.ПравилоПКО.Добавить("Порядок"); 143 | Структура.ПравилоПКО.Добавить("Описание"); 144 | Структура.ПравилоПКО.Добавить("ПередВыгрузкой"); 145 | Структура.ПравилоПКО.Добавить("ПриВыгрузке"); 146 | Структура.ПравилоПКО.Добавить("ПослеВыгрузки"); 147 | Структура.ПравилоПКО.Добавить("ПослеВыгрузкиВФайл"); 148 | Структура.ПравилоПКО.Добавить("ПередЗагрузкой"); 149 | Структура.ПравилоПКО.Добавить("ПриЗагрузке"); 150 | Структура.ПравилоПКО.Добавить("ПослеЗагрузки"); 151 | Структура.ПравилоПКО.Добавить("ПоследовательностьПолейПоиска"); 152 | Структура.ПравилоПКО.Добавить("НеЗамещать"); 153 | Структура.ПравилоПКО.Добавить("НеЗапоминатьВыгруженные"); 154 | Структура.ПравилоПКО.Добавить("СинхронизироватьПоИдентификатору"); 155 | Структура.ПравилоПКО.Добавить("ПродолжитьПоискПоПолямПоискаЕслиПоИдентификаторуНеНашли"); 156 | Структура.ПравилоПКО.Добавить("НеВыгружатьОбъектыСвойствПоСсылкам"); 157 | Структура.ПравилоПКО.Добавить("НеСоздаватьЕслиНеНайден"); 158 | Структура.ПравилоПКО.Добавить("ИспользоватьБыстрыйПоискПриЗагрузке"); 159 | Структура.ПравилоПКО.Добавить("ГенерироватьНовыйНомерИлиКодЕслиНеУказан"); 160 | Структура.ПравилоПКО.Добавить("ВыгружатьОбъектТолькоПриНаличииНаНегоСсылки"); 161 | Структура.ПравилоПКО.Добавить("ПриПереносеОбъектаПоСсылкеУстанавливатьТолькоGIUD"); 162 | Структура.ПравилоПКО.Добавить("НеЗамещатьОбъектСозданныйВИнформационнойБазеПриемнике"); 163 | Структура.ПравилоПКО.Добавить("ПриоритетОбъектовОбмена"); 164 | Структура.ПравилоПКО.Добавить("Источник"); 165 | Структура.ПравилоПКО.Добавить("Приемник"); 166 | Структура.ПравилоПКО.Добавить("Свойства"); 167 | Структура.ПравилоПКО.Добавить("Значения"); 168 | 169 | Структура.Вставить("ПравилоПВД", Новый Массив); 170 | Структура.ПравилоПВД.Добавить("Код"); 171 | Структура.ПравилоПВД.Добавить("Наименование"); 172 | Структура.ПравилоПВД.Добавить("Порядок"); 173 | Структура.ПравилоПВД.Добавить("Описание"); 174 | Структура.ПравилоПВД.Добавить("Комментарий"); 175 | Структура.ПравилоПВД.Добавить("КодПравилаКонвертации"); 176 | Структура.ПравилоПВД.Добавить("СпособОтбораДанных"); 177 | Структура.ПравилоПВД.Добавить("ОбъектВыборки"); 178 | Структура.ПравилоПВД.Добавить("ВыбиратьДанныеДляВыгрузкиОднимЗапросом"); 179 | Структура.ПравилоПВД.Добавить("НеВыгружатьОбъектыСозданныеВБазеПриемнике"); 180 | Структура.ПравилоПВД.Добавить("ПередОбработкойПравила"); 181 | Структура.ПравилоПВД.Добавить("ПередВыгрузкойОбъекта"); 182 | Структура.ПравилоПВД.Добавить("ПослеВыгрузкиОбъекта"); 183 | Структура.ПравилоПВД.Добавить("ПослеОбработкиПравила"); 184 | 185 | Структура.Вставить("ГруппаПравило", Новый Массив); 186 | Структура.ГруппаПравило.Добавить("Код"); 187 | Структура.ГруппаПравило.Добавить("Наименование"); 188 | Структура.ГруппаПравило.Добавить("Порядок"); 189 | Структура.ГруппаПравило.Добавить("Описание"); 190 | Структура.ГруппаПравило.Добавить("Комментарий"); 191 | 192 | Структура.Вставить("ГруппаСвойство", Новый Массив); 193 | Структура.ГруппаСвойство.Добавить("Код"); 194 | Структура.ГруппаСвойство.Добавить("Наименование"); 195 | Структура.ГруппаСвойство.Добавить("Порядок"); 196 | Структура.ГруппаСвойство.Добавить("НеЗамещать"); 197 | Структура.ГруппаСвойство.Добавить("ПолучитьИзВходящихДанных"); 198 | Структура.ГруппаСвойство.Добавить("ВыгружатьГруппуЧерезФайл"); 199 | Структура.ГруппаСвойство.Добавить("Источник"); 200 | Структура.ГруппаСвойство.Добавить("Приемник"); 201 | Структура.ГруппаСвойство.Добавить("ПередОбработкойВыгрузки"); 202 | Структура.ГруппаСвойство.Добавить("ПередВыгрузкой"); 203 | Структура.ГруппаСвойство.Добавить("ПриВыгрузке"); 204 | Структура.ГруппаСвойство.Добавить("ПослеВыгрузки"); 205 | Структура.ГруппаСвойство.Добавить("ПослеОбработкиВыгрузки"); 206 | Структура.ГруппаСвойство.Добавить("Свойство"); 207 | 208 | 209 | КорневойУзел = Дерево.Строки[0]; 210 | ОбработатьСортировкуРекурсивно(КорневойУзел, Структура); 211 | КорневойУзел.Строки.Сортировать("Порядок Возвр", Истина); 212 | 213 | КонецПроцедуры 214 | 215 | Процедура Загрузить_РеквизитыКонвертации(ТекущийУзел, КорневойУзел) 216 | 217 | Дерево = ЧтениеXMLВДерево(ТекущийУзел.Путь); 218 | ТекущийПорядок = 1; 219 | РекурсивноДобавитьВДерево(Дерево.Строки[0], КорневойУзел); 220 | 221 | КонецПроцедуры 222 | 223 | Процедура Загрузить_СобытияКонвертации(ДеревоКаталогов, КорневойУзел) 224 | 225 | СтрокаУзлаСобытий = ДеревоКаталогов.Строки.Найти("Ext", "Имя"); 226 | Если СтрокаУзлаСобытий = Неопределено Тогда 227 | Возврат; 228 | КонецЕсли; 229 | 230 | Для Каждого СтрокаДерева Из СтрокаУзлаСобытий.Строки Цикл 231 | 232 | ИмяСобытия = СтрЗаменить(СтрокаДерева.Имя, ".bsl", ""); 233 | НоваяСтрокаДерева = ДобавитьНовуюСтрокуДереваПравил( 234 | КорневойУзел, 235 | СтрЗаменить(СтрокаДерева.Имя, ".bsl", ""),, 236 | ПрочитатьИзТекстовогоДокумента(СтрокаДерева.Путь),, 237 | ПолучитьПорядокПоИмени(ИмяСобытия)); 238 | 239 | КонецЦикла; 240 | 241 | КонецПроцедуры 242 | 243 | Процедура Загрузить_Параметры(ДеревоКаталогов, КорневойУзел) 244 | 245 | ТекущийУзелДереваПравил = ДобавитьНовуюСтрокуДереваПравил(КорневойУзел, "Параметры"); 246 | 247 | Для Каждого СтрокаДерева Из ДеревоКаталогов.Строки Цикл 248 | 249 | СтрокаПоиска = СтрокаДерева.Строки.Найти("Параметр.xml", "Имя"); 250 | Если СтрокаПоиска = Неопределено Тогда 251 | Сообщить("Не нашли: " + СтрокаДерева.Имя); 252 | Продолжить; 253 | КонецЕсли; 254 | 255 | ИмяУзла = ОбщийФункционал.УбратьРасширениеИзИмени(СтрокаПоиска.Имя); 256 | ТекущийУзел = ДобавитьНовуюСтрокуДереваПравил(ТекущийУзелДереваПравил, ИмяУзла); 257 | ЗаполнитьДанныеСвойствПриЗагрузке(ТекущийУзел, СтрокаПоиска.Путь); 258 | 259 | КонецЦикла; 260 | 261 | КонецПроцедуры 262 | 263 | Процедура Загрузить_Обработки(ДеревоКаталогов, КорневойУзел) 264 | 265 | ТекущийУзелДереваПравил = ДобавитьНовуюСтрокуДереваПравил(КорневойУзел, "Обработки"); 266 | Для Каждого СтрокаДерева Из ДеревоКаталогов.Строки Цикл 267 | 268 | СтрокаПоиска = СтрокаДерева.Строки.Найти("Обработка.xml", "Имя"); 269 | Если СтрокаПоиска = Неопределено Тогда 270 | Сообщить("Не нашли: " + СтрокаДерева.Имя); 271 | Продолжить; 272 | КонецЕсли; 273 | 274 | ИмяУзла = ОбщийФункционал.УбратьРасширениеИзИмени(СтрокаПоиска.Имя); 275 | 276 | ТекущийУзел = ДобавитьНовуюСтрокуДереваПравил(ТекущийУзелДереваПравил, ИмяУзла); 277 | ЗаполнитьДанныеСвойствПриЗагрузке(ТекущийУзел, СтрокаПоиска.Путь); 278 | СтрокаПоиска = СтрокаДерева.Строки.Найти("ДвоичныеДанные", "Имя"); 279 | Если СтрокаПоиска <> Неопределено Тогда 280 | 281 | ТекущийУзел.Значение = ПрочитатьИзТекстовогоДокумента(СтрокаПоиска.Путь); 282 | 283 | КонецЕсли; 284 | 285 | КонецЦикла; 286 | 287 | 288 | КонецПроцедуры 289 | 290 | Процедура Загрузить_ПравилаКонвертацииОбъектов(ДеревоКаталогов, КорневойУзел) 291 | 292 | ТекущийУзелДереваПравил = ДобавитьНовуюСтрокуДереваПравил(КорневойУзел, "ПравилаКонвертацииОбъектов"); 293 | 294 | Для Каждого СтрокаДерева Из ДеревоКаталогов.Строки Цикл 295 | РекурсивноПрочитатьКаталогиГруппИПравил(ТекущийУзелДереваПравил, СтрокаДерева); 296 | КонецЦикла; 297 | 298 | КонецПроцедуры 299 | 300 | Процедура Загрузить_ПравилаВыгрузкиДанных(ДеревоКаталогов, КорневойУзел) 301 | 302 | ТекущийУзелДереваПравил = ДобавитьНовуюСтрокуДереваПравил(КорневойУзел, "ПравилаВыгрузкиДанных"); 303 | 304 | Для Каждого СтрокаДерева Из ДеревоКаталогов.Строки Цикл 305 | РекурсивноПрочитатьКаталогиГруппИПравил(ТекущийУзелДереваПравил, СтрокаДерева); 306 | КонецЦикла; 307 | 308 | КонецПроцедуры 309 | 310 | Процедура Загрузить_ПравилаОчисткиДанных(ДеревоКаталогов, КорневойУзел) 311 | 312 | ТекущийУзелДереваПравил = ДобавитьНовуюСтрокуДереваПравил(КорневойУзел, "ПравилаОчисткиДанных"); 313 | 314 | Для Каждого СтрокаДерева Из ДеревоКаталогов.Строки Цикл 315 | РекурсивноПрочитатьКаталогиГруппИПравил(ТекущийУзелДереваПравил, СтрокаДерева); 316 | КонецЦикла; 317 | 318 | КонецПроцедуры 319 | 320 | Процедура Загрузить_Алгоритмы(ДеревоКаталогов, КорневойУзел) 321 | 322 | УзелАлгоритмы = ДобавитьНовуюСтрокуДереваПравил(КорневойУзел, "Алгоритмы"); 323 | Для Каждого СтрокаДерева Из ДеревоКаталогов.Строки Цикл 324 | РекурсивноПрочитатьГруппыИАлгоритмы(УзелАлгоритмы, СтрокаДерева); 325 | КонецЦикла; 326 | 327 | КонецПроцедуры 328 | 329 | Процедура Загрузить_Запросы(ДеревоКаталогов, КорневойУзел) 330 | 331 | УзелЗапросы = ДобавитьНовуюСтрокуДереваПравил(КорневойУзел, "Запросы"); 332 | Для Каждого СтрокаДерева Из ДеревоКаталогов.Строки Цикл 333 | РекурсивноПрочитатьГруппыИЗапросы(УзелЗапросы, СтрокаДерева); 334 | КонецЦикла; 335 | 336 | КонецПроцедуры 337 | 338 | Процедура СортироватьДеревоПоПорядку(ДеревоПравил) 339 | 340 | ДеревоПравил.Строки.Сортировать("Порядок Возр", Истина); 341 | 342 | КонецПроцедуры 343 | 344 | Процедура ОбработатьСортировкуРекурсивно(ТекущийУзел, СтруктураСортировки) 345 | 346 | ИмяПоиска = ТекущийУзел.Имя; 347 | Если ТекущийУзел.Имя = "Группа" Тогда 348 | Стоп = 1; 349 | КонецЕсли; 350 | 351 | Если ТекущийУзел.Имя = "Группа" И ТекущийУзел.Родитель.Имя = "Свойства" Тогда 352 | ИмяПоиска = "ГруппаСвойство"; 353 | ИначеЕсли ТекущийУзел.Имя = "Правило" И ОбщийФункционал.ПроверитьНаличиеПредкаВДереве(ТекущийУзел, "ПравилаКонвертацииОбъектов") Тогда 354 | ИмяПоиска = "ПравилоПКО"; 355 | ИначеЕсли ТекущийУзел.Имя = "Правило" И ОбщийФункционал.ПроверитьНаличиеПредкаВДереве(ТекущийУзел, "ПравилаВыгрузкиДанных") Тогда 356 | ИмяПоиска = "ПравилоПВД"; 357 | КонецЕсли; 358 | 359 | МожноСортировать = СтруктураСортировки.Свойство(ИмяПоиска); 360 | МассивПоиска = ?(МожноСортировать, СтруктураСортировки[ИмяПоиска], Новый Массив); 361 | Для Каждого СтрокаДерева Из ТекущийУзел.Строки Цикл 362 | 363 | Если МожноСортировать Тогда 364 | Индекс = МассивПоиска.Найти(СтрокаДерева.Имя); 365 | Если Индекс <> Неопределено Тогда 366 | СтрокаДерева.Порядок = Индекс + 1; 367 | КонецЕсли; 368 | КонецЕсли; 369 | 370 | Если (ТекущийУзел.Имя = "Свойство" Или (ТекущийУзел.Имя = "Группа" И ТекущийУзел.Родитель.Имя = "Свойства")) И СтрокаДерева.Имя = "Порядок" Тогда 371 | ТекущийУзел.Порядок = Число(СтрокаДерева.Значение); 372 | КонецЕсли; 373 | 374 | ОбработатьСортировкуРекурсивно(СтрокаДерева, СтруктураСортировки); 375 | 376 | КонецЦикла; 377 | 378 | КонецПроцедуры 379 | 380 | Процедура РекурсивноПрочитатьКаталогиГруппИПравил(КорневойУзел, ТекущаяСтрокаДерева) 381 | 382 | СтрокаПоиска = ТекущаяСтрокаДерева.Строки.Найти("Группа.xml", "Имя"); 383 | Если СтрокаПоиска = Неопределено Тогда 384 | СтрокаПоиска = ТекущаяСтрокаДерева.Строки.Найти("Правило.xml", "Имя"); 385 | КонецЕсли; 386 | 387 | Если СтрокаПоиска = Неопределено Тогда 388 | Сообщить("Не нашли: " + ТекущаяСтрокаДерева.Имя); 389 | Возврат; 390 | КонецЕсли; 391 | 392 | ИмяУзла = СтрЗаменить(СтрокаПоиска.Имя, ".xml", ""); 393 | ТекущийУзел = ДобавитьНовуюСтрокуДереваПравил(КорневойУзел, ИмяУзла); 394 | ЗаполнитьДанныеСвойствПриЗагрузке(ТекущийУзел, СтрокаПоиска.Путь); 395 | 396 | СтрокаУзлаСобытий = ТекущаяСтрокаДерева.Строки.Найти("Ext", "Имя"); 397 | Если Не СтрокаУзлаСобытий = Неопределено Тогда 398 | Для Каждого СтрокаДерева Из СтрокаУзлаСобытий.Строки Цикл 399 | 400 | ИмяСобытия = СтрЗаменить(СтрокаДерева.Имя, ".bsl", ""); 401 | НоваяСтрокаДерева = ДобавитьНовуюСтрокуДереваПравил( 402 | ТекущийУзел, 403 | ИмяСобытия,, 404 | ПрочитатьИзТекстовогоДокумента(СтрокаДерева.Путь),, 405 | ПолучитьПорядокПоИмени(ИмяСобытия)); 406 | 407 | КонецЦикла; 408 | КонецЕсли; 409 | 410 | Если ИмяУзла = "Группа" Тогда 411 | Для Каждого СтрокаДерева Из ТекущаяСтрокаДерева.Строки Цикл 412 | Если ОбщийФункционал.ЭтоXMLФайл(СтрокаДерева.Имя) Или СтрокаДерева.Имя = "Ext" Тогда 413 | Продолжить; 414 | КонецЕсли; 415 | РекурсивноПрочитатьКаталогиГруппИПравил(ТекущийУзел, СтрокаДерева); 416 | КонецЦикла; 417 | КонецЕсли; 418 | 419 | Если ИмяУзла = "Правило" И Не ОбщийФункционал.ПроверитьНаличиеПредкаВДереве(ТекущийУзел, "ПравилаВыгрузкиДанных") И Не ОбщийФункционал.ПроверитьНаличиеПредкаВДереве(ТекущийУзел, "ПравилаОчисткиДанных") Тогда 420 | 421 | СтрокаДереваСвойства = ДобавитьНовуюСтрокуДереваПравил(ТекущийУзел, "Свойства",,,,50); 422 | КаталогСвойства = ТекущаяСтрокаДерева.Строки.Найти("Свойства", "Имя"); 423 | Если КаталогСвойства <> Неопределено Тогда 424 | 425 | Для Каждого СтрокаДерева Из КаталогСвойства.Строки Цикл 426 | РекурсивноПрочитатьСвойстваПравил(СтрокаДереваСвойства, СтрокаДерева); 427 | КонецЦикла; 428 | КонецЕсли; 429 | 430 | СтрокаДереваЗначения = ДобавитьНовуюСтрокуДереваПравил(ТекущийУзел, "Значения",,,,100); 431 | КаталогЗначения = ТекущаяСтрокаДерева.Строки.Найти("Значения", "Имя"); 432 | Если КаталогЗначения <> Неопределено Тогда 433 | Для Каждого СтрокаДерева Из КаталогЗначения.Строки Цикл 434 | 435 | СтрокаПоиска = СтрокаДерева.Строки.Найти("Значение.xml", "Имя"); 436 | Если СтрокаПоиска = Неопределено Тогда 437 | Продолжить; 438 | КонецЕсли; 439 | 440 | ТекущийУзел = ДобавитьНовуюСтрокуДереваПравил(СтрокаДереваЗначения, "Значение"); 441 | ЗаполнитьДанныеСвойствПриЗагрузке(ТекущийУзел, СтрокаПоиска.Путь); 442 | 443 | КонецЦикла; 444 | КонецЕсли; 445 | 446 | КонецЕсли; 447 | 448 | КонецПроцедуры 449 | 450 | Функция ЧтениеXMLВДерево(Путь) 451 | 452 | Дерево = ОбщийФункционал.ПолучитьСтруктуруДереваПравил(); 453 | 454 | XMLФайл = Новый ЧтениеXML; 455 | XMLФайл.ОткрытьФайл(Путь); 456 | 457 | ПрочитатьXMLПоТегам(XMLФайл, Дерево.Строки); 458 | 459 | XMLФайл.Закрыть(); 460 | 461 | Возврат Дерево; 462 | 463 | КонецФункции 464 | 465 | Процедура ПрочитатьXMLПоТегам(XMLФайл, ТекущийНаборСтрок) 466 | 467 | Пока XMLФайл.Прочитать() Цикл 468 | Если XMLФайл.ТипУзла = ТипУзлаXML.НачалоЭлемента Тогда 469 | 470 | НоваяСтрока = ТекущийНаборСтрок.Добавить(); 471 | НоваяСтрока.Имя = XMLФайл.Имя; 472 | НоваяСтрока.Значение = ""; 473 | НоваяСтрока.ТипСтроки = "Элемент"; 474 | 475 | Пока XMLФайл.ПрочитатьАтрибут() Цикл 476 | 477 | НоваяСтрокаАтрибут = НоваяСтрока.Строки.Добавить(); 478 | НоваяСтрокаАтрибут.Имя = XMLФайл.Имя; 479 | НоваяСтрокаАтрибут.Значение = XMLФайл.Значение; 480 | НоваяСтрокаАтрибут.ТипСтроки = "Атрибут"; 481 | 482 | Если XMLФайл.Имя = "Имя" Тогда 483 | НоваяСтрока.Идентификатор = НоваяСтрокаАтрибут.Значение; 484 | КонецЕсли; 485 | 486 | КонецЦикла; 487 | 488 | ПрочитатьXMLПоТегам(XMLФайл, НоваяСтрока.Строки); 489 | 490 | 491 | ИначеЕсли XMLФайл.ТипУзла = ТипУзлаXML.КонецЭлемента Тогда 492 | 493 | Возврат; 494 | 495 | ИначеЕсли XMLФайл.ТипУзла = ТипУзлаXML.Текст Тогда 496 | 497 | ТекущийНаборСтрок.Родитель.Значение = XMLФайл.Значение; 498 | 499 | Если ТекущийНаборСтрок.Родитель.Имя = "Код" 500 | Или ТекущийНаборСтрок.Родитель.Имя = "Номер" 501 | Или ТекущийНаборСтрок.Родитель.Имя = "Имя" Тогда 502 | 503 | ТекущийНаборСтрок.Родитель.Родитель.Идентификатор = СокрЛП(XMLФайл.Значение); 504 | 505 | ИначеЕсли ТекущийНаборСтрок.Родитель.Имя = "Порядок" Тогда 506 | 507 | ТекущийНаборСтрок.Родитель.Родитель.Порядок = Число(СокрЛП(XMLФайл.Значение)); 508 | 509 | КонецЕсли; 510 | 511 | КонецЕсли; 512 | 513 | КонецЦикла; 514 | 515 | КонецПроцедуры 516 | 517 | Процедура РекурсивноДобавитьВДерево(Источник, ТекущийУзел) 518 | 519 | Для Каждого СтрокаДерева Из Источник.Строки Цикл 520 | НоваяСтрокаДерева = ТекущийУзел.Строки.Добавить(); 521 | ЗаполнитьЗначенияСвойств(НоваяСтрокаДерева, СтрокаДерева); 522 | НоваяСтрокаДерева.Порядок = ТекущийПорядок; 523 | ТекущийПорядок = ТекущийПорядок + 1; 524 | 525 | РекурсивноДобавитьВДерево(СтрокаДерева, НоваяСтрокаДерева); 526 | КонецЦикла; 527 | 528 | КонецПроцедуры 529 | 530 | Функция ДобавитьНовуюСтрокуДереваПравил(КорневойУзел, Имя, Идентификатор = "", Значение = "", ТипСтроки = "Элемент", Порядок = 0) 531 | 532 | НоваяСтрокаДерева = КорневойУзел.Строки.Добавить(); 533 | НоваяСтрокаДерева.Имя = Имя; 534 | НоваяСтрокаДерева.Идентификатор = Идентификатор; 535 | НоваяСтрокаДерева.Значение = Значение; 536 | НоваяСтрокаДерева.ТипСтроки = ТипСтроки; 537 | НоваяСтрокаДерева.Порядок = Число(Порядок); 538 | 539 | Возврат НоваяСтрокаДерева; 540 | 541 | КонецФункции 542 | 543 | Функция ПрочитатьИзТекстовогоДокумента(Путь) 544 | 545 | Чтение = Новый ТекстовыйДокумент; 546 | Чтение.Прочитать(Путь, КодировкаТекста.UTF8); 547 | Текст = Чтение.ПолучитьТекст(); 548 | Чтение = Неопределено; 549 | Возврат Текст; 550 | 551 | КонецФункции 552 | 553 | Функция ПолучитьПорядокПоИмени(ИмяСобытия) 554 | 555 | Порядок = ИменаСобытийКонвертации.Найти(ИмяСобытия); 556 | Возврат ?(Порядок = Неопределено, 0, 100 + Порядок + 1); 557 | 558 | КонецФункции 559 | 560 | Процедура ЗаполнитьДанныеСвойствПриЗагрузке(СтрокаДерева, Путь) 561 | 562 | ТекущийПорядок = 1; 563 | 564 | Дерево = ЧтениеXMLВДерево(Путь); 565 | КорневойУзелДерева = Дерево.Строки[0]; 566 | СтрокаДерева.Идентификатор = КорневойУзелДерева.Идентификатор; 567 | СтрокаДерева.Порядок = КорневойУзелДерева.Порядок; 568 | РекурсивноДобавитьВДерево(КорневойУзелДерева, СтрокаДерева); 569 | 570 | КонецПроцедуры 571 | 572 | Процедура РекурсивноПрочитатьГруппыИАлгоритмы(УзелРодитель, СтрокаДерева) 573 | 574 | РекурсивноПрочитатьГруппыАлгоритмыЗапросыОбщий(УзелРодитель, СтрокаДерева); 575 | 576 | КонецПроцедуры 577 | 578 | Процедура РекурсивноПрочитатьГруппыИЗапросы(УзелРодитель, СтрокаДерева) 579 | 580 | РекурсивноПрочитатьГруппыАлгоритмыЗапросыОбщий(УзелРодитель, СтрокаДерева, "Запрос"); 581 | 582 | КонецПроцедуры 583 | 584 | Процедура РекурсивноПрочитатьГруппыАлгоритмыЗапросыОбщий(УзелРодитель, СтрокаДерева, ИмяУзлаПоискаЭлемента = "Алгоритм") 585 | 586 | СтрокаПоиска = СтрокаДерева.Строки.Найти(ИмяУзлаПоискаЭлемента + ".xml", "Имя"); 587 | Если СтрокаПоиска = Неопределено Тогда 588 | СтрокаПоиска = СтрокаДерева.Строки.Найти("Группа.xml", "Имя"); 589 | КонецЕсли; 590 | 591 | Если СтрокаПоиска = Неопределено Тогда 592 | Возврат; 593 | КонецЕсли; 594 | 595 | ИмяУзла = СтрЗаменить(СтрокаПоиска.Имя, ".xml", ""); 596 | 597 | УзелАлгоритма = ДобавитьНовуюСтрокуДереваПравил(УзелРодитель, ИмяУзла); 598 | 599 | ЗаполнитьДанныеСвойствПриЗагрузке(УзелАлгоритма, СтрокаПоиска.Путь); 600 | 601 | СтрокаДереваСобытий = СтрокаДерева.Строки.Найти("Ext", "Имя"); 602 | Если СтрокаДереваСобытий <> Неопределено Тогда 603 | 604 | СтрокаТекста = СтрокаДереваСобытий.Строки.Найти("Текст.bsl", "Имя"); 605 | Если СтрокаТекста <> Неопределено Тогда 606 | Текст = ПрочитатьИзТекстовогоДокумента(СтрокаТекста.Путь); 607 | ДобавитьНовуюСтрокуДереваПравил(УзелАлгоритма, "Текст",,Текст); 608 | КонецЕсли; 609 | 610 | СтрокаПараметры = СтрокаДереваСобытий.Строки.Найти("Параметры", "Имя"); 611 | Если СтрокаПараметры <> Неопределено Тогда 612 | Параметры = ПрочитатьИзТекстовогоДокумента(СтрокаПараметры.Путь); 613 | ДобавитьНовуюСтрокуДереваПравил(УзелАлгоритма, "Параметры",,Параметры); 614 | КонецЕсли; 615 | 616 | КонецЕсли; 617 | 618 | Если УзелАлгоритма.Имя = "Группа" Тогда 619 | 620 | Строки = СтрокаДерева.Строки.НайтиСтроки(Новый Структура("ЭтоКаталог", Истина)); 621 | Для Каждого ПодчиненнаяСтрока Из Строки Цикл 622 | РекурсивноПрочитатьГруппыАлгоритмыЗапросыОбщий(УзелАлгоритма, ПодчиненнаяСтрока, ИмяУзлаПоискаЭлемента); 623 | КонецЦикла; 624 | 625 | КонецЕсли; 626 | 627 | КонецПроцедуры 628 | 629 | Процедура РекурсивноПрочитатьСвойстваПравил(СтрокаДереваПравилРодитель, ТекущаяСтрокаДерева) 630 | 631 | 632 | СтрокаПоиска = ТекущаяСтрокаДерева.Строки.Найти("Группа.xml", "Имя"); 633 | Если СтрокаПоиска = Неопределено Тогда 634 | СтрокаПоиска = ТекущаяСтрокаДерева.Строки.Найти("Свойство.xml", "Имя"); 635 | КонецЕсли; 636 | 637 | Если СтрокаПоиска = Неопределено Тогда 638 | Сообщить("Не нашли: " + ТекущаяСтрокаДерева.Имя); 639 | Возврат; 640 | КонецЕсли; 641 | 642 | ИмяУзла = СтрЗаменить(СтрокаПоиска.Имя, ".xml", ""); 643 | ТекущийУзел = ДобавитьНовуюСтрокуДереваПравил(СтрокаДереваПравилРодитель, ИмяУзла); 644 | 645 | // свойства из xml 646 | ЗаполнитьДанныеСвойствПриЗагрузке(ТекущийУзел, СтрокаПоиска.Путь); 647 | 648 | СтрокаУзлаСобытий = ТекущаяСтрокаДерева.Строки.Найти("Ext", "Имя"); 649 | Если Не СтрокаУзлаСобытий = Неопределено Тогда 650 | Для Каждого СтрокаДерева Из СтрокаУзлаСобытий.Строки Цикл 651 | 652 | ИмяСобытия = СтрЗаменить(СтрокаДерева.Имя, ".bsl", ""); 653 | НоваяСтрокаДерева = ДобавитьНовуюСтрокуДереваПравил( 654 | ТекущийУзел, 655 | СтрЗаменить(СтрокаДерева.Имя, ".bsl", ""),, 656 | ПрочитатьИзТекстовогоДокумента(СтрокаДерева.Путь),, 657 | ПолучитьПорядокПоИмени(ИмяСобытия)); 658 | 659 | КонецЦикла; 660 | КонецЕсли; 661 | 662 | Если ИмяУзла = "Группа" Тогда 663 | Для Каждого СтрокаДерева Из ТекущаяСтрокаДерева.Строки Цикл 664 | Если ОбщийФункционал.ЭтоXMLФайл(СтрокаДерева.Имя) Или СтрокаДерева.Имя = "Ext" Тогда 665 | Продолжить; 666 | КонецЕсли; 667 | РекурсивноПрочитатьСвойстваПравил(ТекущийУзел, СтрокаДерева); 668 | КонецЦикла; 669 | КонецЕсли; 670 | 671 | 672 | 673 | КонецПроцедуры 674 | 675 | Функция ПолучитьXMLПоУзлуДерева(СтрокаДерева) 676 | 677 | ИмяВременногоФайла = ПолучитьИмяВременногоФайла("xml"); 678 | ЗаписьXML = Новый ЗаписьXML(); 679 | // Ждем релиза onescript с новым функционалом 680 | // ПараметрыЗаписиXML = Новый ПараметрыЗаписиXML("UTF-8", "1.0", Истина, Ложь, Символы.Таб); 681 | // ЗаписьXML.ОткрытьФайл(ИмяВременногоФайла, ПараметрыЗаписиXML, Истина); 682 | ЗаписьXML.ОткрытьФайл(ИмяВременногоФайла, "UTF-8"); 683 | ЗаписатьXMLЭлементаБезКонтроля(ЗаписьXML, СтрокаДерева); 684 | ЗаписьXML.Закрыть(); 685 | Возврат ИмяВременногоФайла; 686 | 687 | КонецФункции 688 | 689 | Процедура ЗаписатьXMLЭлементаБезКонтроля(ЗаписьXML, СтрокаУзла) 690 | 691 | Если СтрокаУзла.ТипСтроки = "Атрибут" Тогда 692 | ЗаписьXML.ЗаписатьАтрибут(СтрокаУзла.Имя, СтрокаУзла.Значение); 693 | Возврат; 694 | КонецЕсли; 695 | 696 | МассивАтрибутов = Новый Массив; 697 | МассивСвойств = Новый Массив; 698 | 699 | Для Каждого Строка Из СтрокаУзла.Строки Цикл 700 | 701 | Если Строка.ТипСтроки = "Атрибут" Тогда 702 | МассивАтрибутов.Добавить(Строка); 703 | Иначе 704 | МассивСвойств.Добавить(Строка); 705 | КонецЕсли; 706 | 707 | КонецЦикла; 708 | 709 | ЗаписьXML.ЗаписатьНачалоЭлемента(СтрокаУзла.Имя); 710 | 711 | Для Каждого Строка Из МассивАтрибутов Цикл 712 | ЗаписьXML.ЗаписатьАтрибут(Строка.Имя, Строка.Значение); 713 | КонецЦикла; 714 | 715 | Для Каждого Строка Из МассивСвойств Цикл 716 | ЗаписатьXMLЭлементаБезКонтроля(ЗаписьXML, Строка); 717 | КонецЦикла; 718 | 719 | Если ЗначениеЗаполнено(СтрокаУзла.Значение) Тогда 720 | ЗначениеЗаписи = ?(СтрокаУзла.Имя = "Текст" Или СтрокаУзла.Имя = "Обработка" Или ИменаСобытийКонвертации.Найти(СтрокаУзла.Имя) <> Неопределено, СокрЛП(СтрокаУзла.Значение), СтрокаУзла.Значение); 721 | ЗаписьXML.ЗаписатьТекст(ЗначениеЗаписи); 722 | КонецЕсли; 723 | 724 | ЗаписьXML.ЗаписатьКонецЭлемента(); 725 | 726 | КонецПроцедуры 727 | 728 | Процедура ИнициализироватьИмена() 729 | 730 | СтруктураПараметров = ОбщийФункционал.ПолучитьПараметрыПравил(); 731 | ИменаСобытийКонвертации = СтруктураПараметров.ИменаСобытийКонвертации; 732 | 733 | КонецПроцедуры 734 | 735 | Процедура ОбработатьОтступыВXML(ПутьКФайлу) 736 | 737 | ТД = Новый ТекстовыйДокумент; 738 | ТД.Прочитать(ПутьКФайлу, "UTF-8"); 739 | ЗаписьТекста = Новый ТекстовыйДокумент; 740 | Для НомерСтроки = 1 По ТД.КоличествоСтрок() Цикл 741 | ТекущаяСтрока = ТД.ПолучитьСтроку(НомерСтроки); 742 | КоличествоПробеловПодряд = 0; 743 | Для ПорядокСимвола = 1 По СтрДлина(ТекущаяСтрока) Цикл 744 | 745 | ТекущийСимвол = Сред(ТекущаяСтрока, ПорядокСимвола, 1); 746 | Если ТекущийСимвол = " " Тогда 747 | КоличествоПробеловПодряд = КоличествоПробеловПодряд + 1; 748 | Иначе 749 | Прервать; 750 | КонецЕсли; 751 | 752 | КонецЦикла; 753 | 754 | НоваяСтрока = ТекущаяСтрока; 755 | Если КоличествоПробеловПодряд > 0 Тогда 756 | Допстрока = ""; 757 | КоличествоОтступов = Цел(КоличествоПробеловПодряд / 4); 758 | Для Интерация = 1 По КоличествоОтступов Цикл 759 | Допстрока = Допстрока + Символы.Таб; 760 | КонецЦикла; 761 | 762 | Если СтрДлина(Допстрока) > 0 Тогда 763 | НоваяСтрока = Допстрока + Прав(ТекущаяСтрока, СтрДлина(ТекущаяСтрока) - (КоличествоОтступов * 4)); 764 | КонецЕсли; 765 | КонецЕсли; 766 | 767 | НоваяСтрока = СтрЗаменить(НоваяСтрока, " />", "/>"); 768 | ЗаписьТекста.ДобавитьСтроку(НоваяСтрока); 769 | КонецЦикла; 770 | 771 | ЗаписьТекста.Записать(ПутьКФайлу); 772 | 773 | КонецПроцедуры -------------------------------------------------------------------------------- /tasks/coverage.os: -------------------------------------------------------------------------------- 1 | #Использовать coverage 2 | #Использовать 1commands 3 | #Использовать fs 4 | 5 | ФС.ОбеспечитьПустойКаталог("coverage"); 6 | ПутьКСтат = "coverage/stat.json"; 7 | 8 | Команда = Новый Команда; 9 | Команда.УстановитьКоманду("oscript"); 10 | Команда.ДобавитьПараметр("-encoding=utf-8"); 11 | Команда.ДобавитьПараметр(СтрШаблон("-codestat=%1", ПутьКСтат)); 12 | Команда.ДобавитьПараметр("tasks/test.os"); 13 | Команда.ПоказыватьВыводНемедленно(Истина); 14 | 15 | КодВозврата = Команда.Исполнить(); 16 | 17 | Файл_Стат = Новый Файл(ПутьКСтат); 18 | 19 | ИмяПакета = "gitrules"; 20 | 21 | Каталог = Новый Файл("coverage"); 22 | ПроцессорГенерации = Новый ГенераторОтчетаПокрытия(); 23 | ПроцессорГенерации.РабочийКаталог(Каталог.ПолноеИмя); 24 | 25 | ПроцессорГенерации.ОтносительныеПути() 26 | .ИмяФайлаСтатистики("stat*.json") 27 | .ФайлСтатистики(Файл_Стат.ПолноеИмя) 28 | .GenericCoverage() 29 | .Cobertura() 30 | .Clover(ИмяПакета) 31 | .Сформировать(); 32 | 33 | ЗавершитьРаботу(КодВозврата); -------------------------------------------------------------------------------- /tasks/test.os: -------------------------------------------------------------------------------- 1 | // #Использовать "../" 2 | #Использовать 1bdd 3 | #Использовать 1testrunner 4 | 5 | Функция ПрогнатьТесты() 6 | 7 | Тестер = Новый Тестер; 8 | 9 | ПутьКТестам = ОбъединитьПути(ТекущийСценарий().Каталог, "..", "tests"); 10 | ПутьКОтчетуJUnit = ОбъединитьПути(ТекущийСценарий().Каталог, ".."); 11 | 12 | КаталогТестов = Новый Файл(ПутьКТестам); 13 | Если Не КаталогТестов.Существует() Тогда 14 | Сообщить(СтрШаблон("Не найден каталог тестов %1", ПутьКТестам)); 15 | Возврат Истина; 16 | КонецЕсли; 17 | 18 | РезультатТестирования = Тестер.ТестироватьКаталог( 19 | КаталогТестов, 20 | Новый Файл(ПутьКОтчетуJUnit) 21 | ); 22 | 23 | Успешно = РезультатТестирования = 0; 24 | 25 | Возврат Успешно; 26 | КонецФункции // ПрогнатьТесты() 27 | 28 | Функция ПрогнатьФичи() 29 | 30 | ПутьОтчетаJUnit = "./bdd-log.xml"; 31 | 32 | КаталогФич = ОбъединитьПути(".", "features"); 33 | 34 | Файл_КаталогФич = Новый Файл(КаталогФич); 35 | Если Не Файл_КаталогФич.Существует() Тогда 36 | Сообщить(СтрШаблон("Не найден каталог фич %1", КаталогФич)); 37 | Возврат Истина; 38 | КонецЕсли; 39 | 40 | ИсполнительБДД = Новый ИсполнительБДД; 41 | РезультатыВыполнения = ИсполнительБДД.ВыполнитьФичу(Файл_КаталогФич, Файл_КаталогФич); 42 | ИтоговыйРезультатВыполнения = ИсполнительБДД.ПолучитьИтоговыйСтатусВыполнения(РезультатыВыполнения); 43 | 44 | СтатусВыполнения = ИсполнительБДД.ВозможныеСтатусыВыполнения().НеВыполнялся; 45 | Если РезультатыВыполнения.Строки.Количество() > 0 Тогда 46 | 47 | СтатусВыполнения = ИсполнительБДД.ПолучитьИтоговыйСтатусВыполнения(РезультатыВыполнения); 48 | 49 | КонецЕсли; 50 | 51 | ГенераторОтчетаJUnit = Новый ГенераторОтчетаJUnit; 52 | ГенераторОтчетаJUnit.Сформировать(РезультатыВыполнения, СтатусВыполнения, ПутьОтчетаJUnit); 53 | 54 | Сообщить(СтрШаблон("Результат прогона фич <%1> 55 | |", ИтоговыйРезультатВыполнения)); 56 | 57 | Возврат ИтоговыйРезультатВыполнения <> ИсполнительБДД.ВозможныеСтатусыВыполнения().Сломался; 58 | КонецФункции // ПрогнатьФичи() 59 | 60 | ТестыПрошли = Истина; 61 | 62 | Попытка 63 | ТестыПрошли = ПрогнатьТесты(); 64 | 65 | Исключение 66 | ТестыПрошли = Ложь; 67 | Сообщить(СтрШаблон("Тесты через 1testrunner выполнены неудачно 68 | |%1", ПодробноеПредставлениеОшибки(ИнформацияОбОшибке()))); 69 | КонецПопытки; 70 | 71 | ФичиПрошли = Истина; 72 | 73 | // Попытка 74 | // ФичиПрошли = ПрогнатьФичи(); 75 | // Исключение 76 | // ФичиПрошли = Ложь; 77 | // Сообщить(СтрШаблон("Тесты поведения через 1bdd выполнены неудачно 78 | // |%1", ПодробноеПредставлениеОшибки(ИнформацияОбОшибке()))); 79 | // КонецПопытки; 80 | 81 | Если Не ТестыПрошли Или Не ФичиПрошли Тогда 82 | ВызватьИсключение "Тестирование завершилось неудачно!"; 83 | Иначе 84 | Сообщить(СтрШаблон("Результат прогона тестов <%1> 85 | |", ТестыПрошли)); 86 | КонецЕсли; -------------------------------------------------------------------------------- /tests/РазобратьсяПравилаОбмена_test.os: -------------------------------------------------------------------------------- 1 | #использовать "../src/core" 2 | #Использовать asserts 3 | #Использовать logos 4 | 5 | Перем юТест; 6 | Перем Лог; 7 | Перем КаталогРаспаковки; 8 | 9 | Функция ПолучитьСписокТестов(Знач Тестирование) Экспорт 10 | 11 | юТест = Тестирование; 12 | 13 | ИменаТестов = Новый Массив; 14 | 15 | ИменаТестов.Добавить("ТестДолжен_ПроверитьРазборкуПравилОбмена"); 16 | ИменаТестов.Добавить("ТестДолжен_ПроверитьРазборкуПравилОбменаССозданиеПараметровДляАлгоритмов"); 17 | 18 | Возврат ИменаТестов; 19 | 20 | КонецФункции 21 | 22 | Процедура ПередОкончаниемСценария() Экспорт 23 | ВременныеФайлы.УдалитьФайл(КаталогРаспаковки); 24 | КонецПроцедуры 25 | 26 | Процедура ТестДолжен_ПроверитьРазборкуПравилОбмена() Экспорт 27 | 28 | КаталогРаспаковки = ВременныеФайлы.СоздатьКаталог(); 29 | ПутьКФайлуПравила = ТестовыеПравила(); 30 | 31 | ОбработчикПравил = Новый ОбработкаПравил(); 32 | ОбработчикПравил.РазложитьПравилаКонвертации(ПутьКФайлуПравила, КаталогРаспаковки); 33 | 34 | МассивФайлов = НайтиФайлы(КаталогРаспаковки, "*.*", Истина); 35 | 36 | Ожидаем.Что(МассивФайлов.Количество(), "Количество файлов должно быть больше 0").Больше(0); 37 | 38 | КонецПроцедуры 39 | 40 | Процедура ТестДолжен_ПроверитьРазборкуПравилОбменаССозданиеПараметровДляАлгоритмов() Экспорт 41 | 42 | Результат = Ложь; 43 | 44 | МассивФайлов = НайтиФайлы(КаталогРаспаковки, "Параметры", Истина); 45 | 46 | Для каждого СтрокаМассива Из МассивФайлов Цикл 47 | Если СтрокаМассива.ЭтоФайл() Тогда 48 | Результат = Истина; 49 | КонецЕсли; 50 | КонецЦикла; 51 | 52 | Ожидаем.Что(Результат, "Должен быть файл Параметры").Равно(Истина); 53 | 54 | КонецПроцедуры 55 | 56 | Функция ТестовыеПравила() 57 | Возврат ОбъединитьПути(ТекущийСценарий().Каталог, "fixtures","fake-rules.xml"); 58 | КонецФункции -------------------------------------------------------------------------------- /tests/Тест_ПроверитьCLI.os: -------------------------------------------------------------------------------- 1 | #использовать "../src/core" 2 | #Использовать asserts 3 | #Использовать logos 4 | 5 | Перем юТест; 6 | Перем Лог; 7 | 8 | Функция ПолучитьСписокТестов(Знач Тестирование) Экспорт 9 | 10 | юТест = Тестирование; 11 | ИменаТестов = Новый Массив; 12 | ИменаТестов.Добавить("ТестДолжен_ПроверитьДоступностьCLI"); 13 | 14 | Возврат ИменаТестов; 15 | 16 | КонецФункции 17 | 18 | Процедура ТестДолжен_ПроверитьДоступностьCLI() Экспорт 19 | 20 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/Тест_СобратьПравилаОбмена.os: -------------------------------------------------------------------------------- 1 | #использовать "../src/core" 2 | #Использовать asserts 3 | #Использовать logos 4 | #Использовать fs 5 | 6 | Перем юТест; 7 | Перем Лог; 8 | 9 | Функция ПолучитьСписокТестов(Знач Тестирование) Экспорт 10 | 11 | юТест = Тестирование; 12 | ИменаТестов = Новый Массив; 13 | ИменаТестов.Добавить("ТестДолжен_ПроверитьСборкуПравилОбмена"); 14 | ИменаТестов.Добавить("ТестДолжен_ПроверитьСборкуПравилРегистрации"); 15 | 16 | Возврат ИменаТестов; 17 | 18 | КонецФункции 19 | 20 | Процедура ТестДолжен_ПроверитьСборкуПравилОбмена() Экспорт 21 | 22 | БазовыйКаталог = ПолучитьТестовыйКаталогДляСборки(); 23 | КаталогSRC = ОбъединитьПути(БазовыйКаталог, "src"); 24 | ФС.ОбеспечитьПустойКаталог(КаталогSRC); 25 | МенеджерПравил = Новый ОбработкаПравил(); 26 | 27 | //Подготовим разборку 28 | Сообщить("Разборка.."); 29 | ПутьКПравиламОбмена = ПолучитьТестовыеПравилаКонвертации("ПравилаОбмена"); 30 | ИмяПравилОбмена = ОбщийФункционал.ПолучитьИмяФайла(ПутьКПравиламОбмена); 31 | МенеджерПравил.РазложитьПравилаКонвертации(ПутьКПравиламОбмена, КаталогSRC); 32 | 33 | КаталогИсходныхФайлов = ОбъединитьПути(КаталогSRC, ИмяПравилОбмена); 34 | 35 | МассивФайлов = НайтиФайлы(КаталогИсходныхФайлов, "*.*", Истина); 36 | Ожидаем.Что(МассивФайлов.Количество(), "Количество файлов должно быть больше 0").Больше(0); 37 | 38 | //Сделаем сборку 39 | Сообщить("Сборка.."); 40 | МенеджерПравил.СобратьПравилаКонвертации(КаталогИсходныхФайлов, БазовыйКаталог); 41 | 42 | //Проверим что файл сборки создан 43 | МассивФайлов = НайтиФайлы(БазовыйКаталог, ИмяПравилОбмена); 44 | Ожидаем.Что(МассивФайлов.Количество(), "Файл со сборкой правил должен быть найден").Больше(0); 45 | 46 | УдалитьФайлы(БазовыйКаталог); 47 | 48 | КонецПроцедуры 49 | 50 | Процедура ТестДолжен_ПроверитьСборкуПравилРегистрации() Экспорт 51 | 52 | //КаталогСборки = ПолучитьТестовыйКаталогДляСборки(); 53 | 54 | КонецПроцедуры 55 | 56 | Функция ПолучитьТестовыйКаталогДляСборки() 57 | ПутьККаталогу = ОбъединитьПути(ТекущийСценарий().Каталог, "fixtures", "assembly"); 58 | ФС.ОбеспечитьПустойКаталог(ПутьККаталогу); 59 | Возврат ПутьККаталогу; 60 | КонецФункции 61 | 62 | Функция ПолучитьТестовыеПравилаКонвертации(ТипПравил = "ПравилаОбмена") 63 | // по умолчанию 64 | Значение = ОбъединитьПути(ТекущийСценарий().Каталог, "fixtures","fake-rules.xml"); 65 | Если ТипПравил = "ПравилаОбмена" Тогда 66 | Значение = ОбъединитьПути(ТекущийСценарий().Каталог, "fixtures","fake-rules.xml"); 67 | ИначеЕсли ТипПравил = "ПравилаРегистрации" Тогда 68 | Значение = ОбъединитьПути(ТекущийСценарий().Каталог, "fixtures","fake-rules.xml"); 69 | КонецЕсли; 70 | Возврат Значение; 71 | КонецФункции --------------------------------------------------------------------------------