<?xml version="1.0" encoding="windows-1251"?>
<registry>
<script type="abl" exec="">
включить "\библиотеки\libru.lib";
включить "\библиотеки\Documents.lib";
включить "\Библиотеки\Reports.lib";
включить '\Библиотеки\output.lib';
включить "\Макросы\Вспомогательные.abl";
включить "\Библиотеки\SysUtils.lib";
включить "\библиотеки\Layers.lib";
включить "\Макросы\слои\ПоддержкаСлойницы.abl";

ПреобразованиеВБуквенныйКлассификатор;


константы
  алиасПодключенийКБазамДанных = "Платформа.БазыДанных.Подключения";
  алиасПользователейБД         = "Платформа.БазыДанных.Пользователи";
  аЗанятыеПоля                 = "Платформа.СтроковыйЦСР.Поля";
  
  аБлоки = "Платформа.ДескрипторыБлоков";
  аРасширения = "Платформа.ДескрипторыБлоков.РасширенияКомпонентов"; //РасширенияКомпонентов
  аОбработчики = "Платформа.Компоненты.ОписаниеПодключенийОбработчиков"; //ПодключениеОбработчиков
  аПередача = "Платформа.Компоненты.ОписаниеПередачиПараметров"; //ПередачаПараметров
  аКонтроллеры = "Платформа.Контроллеры.ОписаниеКонтроллеров"; //Контроллер 
  
  аСлои = "Платформа.Слои.ОписанияСлоев";
  аПоля = "Платформа.Слои.ОписанияПолей";
  
  КонтроллерыДобавленияПоля = "Платформа.Слои.ИзменитьАтрибутыКолонки,Платформа.Слои.ЗадатьОписаниеПоля";
переменные
  ПараметрыПодключения: Строка;
  МенеджерСлоев: ILayersMan;
  

функция СформироватьАлиасБД(ИмяБазы: строка; ПараметрыПодключения: строка): целое;
переменные
  СлойБД, СлойПользователей: ILayer;
  ДанныеБД, ДанныеПользователей: СтатическиеДанные;
  ПараметрыБД: Текст;
  ИмяДрайвера, ИмяСервера, Схема, Логин, Пароль: строка;
  Данные: СтатическиеДанные;
начало
  ПараметрыПодключения := "";
  если IsOracle() тогда
  начало
    //путь к базе получаем из слоя "Базы данных"
    СлойБД := ПолучитьМенеджерСлоев.CreateLayerByAlias(АлиасПодключенийКБазамДанных);
    СлойБД.SelectData(nil);
    ДанныеБД := СлойБД.LayerData;
    ДанныеБД.Локализовать("ИмяБазыДанных", ИмяБазы, 0);
    ИмяДрайвера := ДанныеБД.ПолеПоИмени("ИмяДрайвера").КакСтрока;  
    ПараметрыБД := СоздатьТекст;
    попытка
      ПараметрыБД.РазделенноеЗначение := ДанныеБД.ПолеПоИмени("ПараметрыБД").КакСтрока;
      ИмяСервера := ПараметрыБД.ЗначениеПараметра("AliasName");
      Схема := '';
      если ДанныеБД.ПолеПоИмени("ТипБазыДанных").КакСтрока = "Oracle" тогда
        Схема := 'schema='+ПараметрыБД.ЗначениеПараметра("Schema"); 
    обязательно
      УдалитьОбъект(ПараметрыБД);
    конец;
    ПараметрыПодключения := Формат("DatabaseName=%s"#13#10"DriverName=%s"#13#10"SERVER NAME=%s"#13#10"%s",
                                                      ИмяБазы, ИмяДрайвера, ИмяСервера, Схема);
    
    //логин и пароль хранятся в слое "Пользователи баз данных"
    СлойПользователей := ПолучитьМенеджерСлоев.CreateLayerByAlias(АлиасПользователейБД);
    СлойПользователей.SelectData(nil);
    ДанныеПользователей := СлойПользователей.LayerData;   
    ДанныеПользователей.Фильтр := "ИмяПользователяЛокальное='"+ТекущийПользователь+"'";
    если не ДанныеПользователей.Локализовать("ИмяБазыДанных", ИмяБазы, 0) тогда
      ВызватьОшибку("Не найдены параметры подключения к базе данных с именем '" + ИмяБазы +"' !");  
    Логин := ДанныеПользователей.ПолеПоИмени("ИмяПользователяУдаленное").КакСтрока;
    Пароль := ДанныеПользователей.ПолеПоИмени("ПарольУдаленный").КакСтрока;
    ПараметрыПодключения := Формат("%s"#13#10"USER NAME=%s"#13#10"PASSWORD=%s", ПараметрыПодключения, Логин, Пароль);
  
    попытка
      Данные := СоздатьСтатическиеДанные;
      Данные.СоединитьБД(ПараметрыПодключения);
      Данные.Запрос := "[PumpData]{select count(*) from LayerData}";
      Данные.Открыть;
      результат := Данные.RecordCount &gt; 0;
    неудача
      результат := нет;
      ПараметрыПодключения := ПоследняяОшибка;
    конец;
  конец
  иначе
    результат := да;

конец;
      
  // Комментарий
  функция ЕслиЗначение(Условие: целое; Val1, Val2: строка): строка;
  начало
    если Условие тогда
      результат := Val1
    иначе
      результат := Val2;
  конец;

  // Есть ли поле в LayerData
  функция СуществуетПоле(Имя: строка): целое;
  переменные
    Данные: СтатическиеДанные;
  начало
    Данные := СоздатьСтатическиеДанные;
    если IsOracle() тогда
    начало
      Данные.СоединитьБД(ПараметрыПодключения);
      Данные.Запрос := "[PumpData]{select count(*) from User_Tab_Columns where Table_Name = 'LAYERDATA' and Column_Name = '@FieldName'}";
    конец
    иначе
    начало
      Данные.СоединитьБД;
      Данные.Запрос := "[PumpData]{select count(*) from rdb\$Relation_Fields where rdb\$Relation_Name = 'LAYERDATA' and rdb\$Field_Name = '@FieldName'}";
    конец;
    Данные.Параметр("FieldName") := Имя;
    Данные.Открыть;
    результат := Данные.Поля(0).КакЦелое;
  конец;
  
  // Комментарий
  функция СуществуетСвободноеСтроковоеПоле(СтроковыеПоляСлоев: IVariables; Алиас: строка; ИмяПоля: строка): целое;
  переменные
    Данные, Поля: СтатическиеДанные;
    к, Необходимо: целое;
    СтроковыеПоля, НомерПоля: строка;
    Слой: ILayer;
  начало
    результат := нет; ИмяПоля := '';
    если СтроковыеПоляСлоев.ПараметрСуществует(Алиас) тогда
    начало
      СтроковыеПоля := СтроковыеПоляСлоев.Значение(Алиас);
      Необходимо := да;
    конец
    иначе
    начало
      попытка
        Слой := МенеджерСлоев.CreateLayerByAlias(Алиас);
        Необходимо := Слой.Description.Params('TableName') = 'LayerData' или Слой.Description.Params('TableName') = 'CalcData';
        Поля := Слой.Description.Fields.Data;
      неудача
        Поля := СоздатьСтатическиеДанные;
        Поля.СоединитьБД;
        Поля.Запрос := "[PumpData]{select lf.*, l.TableName TableName from LayerFields lf, Layers l where lf.RecordIndex = l.ID and l.Alias = '@LayerAlias'}";
        Поля.Параметр("LayerAlias") := Алиас;
        Поля.Открыть;
        Необходимо := Поля.Поле('TableName').КакСтрока = 'LayerData' или Поля.Поле('TableName').КакСтрока = 'CalcData';
      конец;
      если Необходимо тогда
      начало
        Данные := СоздатьСтатическиеДанные;
        Данные.ДобавитьСтроковоеПоле('DBName', 4096);
        Данные.ДобавитьЦелоеПоле('Flag');
        Данные.Открыть;
        Данные.Группировать(Поля, "keys=*;DBName=DBName;Flag=DBName like 'STRFIELD%'");
        Данные.Filter := 'Flag=1';
        Данные.Filtered := да;
        если Данные.ВНачале и Данные.ВКонце тогда
        начало
          ИмяПоля := 'STRFIELD00';
          результат := да;
        конец
        иначе
        начало
          ВнутренняяГруппировка(Данные, 'keys=;DBName=sum(DBName + ",")', да);
          СтроковыеПоля := Данные.Поле('DBName').КакСтрока;
        конец;
      конец;
    конец;
    
    
    если результат тогда
      СтроковыеПоляСлоев.Значение(Алиас) := ИмяПоля
    иначе
      если Необходимо тогда  
        от к := 0 до 25 делать
        начало
          НомерПоля := ЦелоеВСтроку(к);
          если к &lt; 10 тогда НомерПоля := "0" + НомерПоля;
          ИмяПоля := "STRFIELD" + НомерПоля;
          если Позиция(ИмяПоля, СтроковыеПоля) = 0 тогда
          начало
            результат := да;
            если СтроковыеПоляСлоев.ПараметрСуществует(Алиас) тогда
              СтроковыеПоляСлоев.Значение(Алиас) := СтроковыеПоляСлоев.Значение(Алиас) + "," + ИмяПоля
            иначе
              СтроковыеПоляСлоев.Значение(Алиас) := СтроковыеПоля + "," + ИмяПоля;
            прервать;
          конец;
        конец;  
  конец;

  // Комментарий
  функция ДобавитьПолеКодВСлой(Алиас: строка);
  переменные
    Данные: СтатическиеДанные;
  начало
    Данные := СоздатьСтатическиеДанные;
    Данные.СоединитьБД;
    Данные.Запрос := "[PumpData]{select l.ID LayerID, lf.DBName IsCode from Layers l left join LayerFields lf "#13#10
    + "on lf.RecordIndex = l.ID and (lf.DBName = 'CODE' or lf.FieldName = 'Код') where l.Alias in (@LayerAlias)}";
    Данные.Параметр("LayerAlias") := Алиас;
    Данные.Открыть;
    если Данные.Поле('IsCode').Пустое тогда
    начало
      ВыполнитьЗапрос("update LayerFields set DisplayLabel = 'ИД' where RecordIndex = :LayerID and DBName = 'ID'", МассивИз(Данные.Поле('LayerID').КакЦелое));
      ВыполнитьЗапрос("insert into LayerFields (RecordIndex, FieldName, DisplayLabel, DBName, FieldType, FieldRole, Mask)"#13#10
      + "values(:LayerID, 'Code', 'Код', 'CODE', 6, 2, '-')", МассивИз(Данные.Поле('LayerID').КакЦелое));
    конец;

  конец;

  функция ПараметрыОткрытия(Имена, Значения: Переменная): IVariables; будущая;

  // Комментарий
  функция СоздатьКонтроллер(Имя: строка): Переменная;
  переменные
    ПараметрыВызова: IVariables; 
  начало
    ПараметрыВызова := CreateVariables;
    ПараметрыВызова.Значение("ИмяОбъекта") := Имя;
    ПолучитьМенеджерСлоев.PerformController('Платформа.СоздатьОбъект', ПараметрыВызова);
    результат := ПараметрыВызова.Значение("Объект"); 
  конец;
  
  // Комментарий
  функция БезЗапятой(СЗапятой: строка): строка;
  начало
    если Подстрока(СЗапятой, Длина(СЗапятой), 1) = ',' тогда
      результат := Подстрока(СЗапятой, 1, Длина(СЗапятой) - 1)
    иначе
      результат := СЗапятой;
  конец;


  // Комментарий
  функция ЭкспортОписаний(СписокСлоев: строка);
  переменные
    Слой: ILayer;
    Параметры: IVariables;
  начало
    если СписокСлоев &lt;&gt; '' тогда
    начало
      СписокСлоев := БезЗапятой(СписокСлоев);

      Слой := ПолучитьМенеджерСлоев.CreateLayerByAlias("Платформа.Слои.ОписанияСлоев");
      Параметры := CreateVariables;

      Слой.SelectData(ПараметрыОткрытия(МассивИз('$Layer.ID', '$Layer.ID.Ограничение'), МассивИз(СписокСлоев, 'in')));
      //Параметры.Значение("СписокВыделенныхАтрибутов") := СписокСлоев; 
      Параметры.Значение("Слой") := Слой;
      Параметры.Значение("СброситьКэш") := да;   
      Параметры.Значение("СохранениеКомпонента") := СоздатьКонтроллер('Платформа.Синхронизация.ЭкспортИмпорт.ЭкспортДокументаВФайл');
      //Параметры.Значение("ТипЭкспорта") := 0;
      //Параметры.Значение("ЭкспортироватьВОдинФайл") := 1;
      ПолучитьМенеджерСлоев.PerformController('Платформа.Синхронизация.ЭкспортИмпорт.ВнешнееЧтениеКомпонентов', Параметры);
    конец;
  конец;


  // Комментарий
  функция СоздатьИдентификаторы: СтатическиеДанные;
  начало
    результат := СоздатьСтатическиеДанные;
    результат.ДобавитьЦелоеПоле('LayerID');
    результат.ДобавитьЦелоеПоле('NaturalKey');
    результат.ДобавитьСтроковоеПоле('LayerList', 4096);
    результат.Open;
  конец;


  // Комментарий
  функция СписокИдентификатов(Поля: СтатическиеДанные; ИмяПоля: строка): строка;
  переменные
    Идентификаторы: СтатическиеДанные;
  начало
    Идентификаторы := СоздатьСтатическиеДанные;
    Идентификаторы.ДобавитьЦелоеПоле(ИмяПоля);
    Идентификаторы.ДобавитьСтроковоеПоле('LayerList', 4096);
    Идентификаторы.Open;
    Идентификаторы.GroupData(Поля, 'keys=' + ИмяПоля + ';LayerList=' + ИмяПоля);
    ВнутренняяГруппировка(Идентификаторы,'keys=;LayerList=sum(LayerList+",")', да);
    результат := Идентификаторы.Поле('LayerList').КакСтрока;
  конец;

  // Комментарий
  функция СоздатьПоля: СтатическиеДанные;
  начало
    результат := СоздатьСтатическиеДанные;
    результат.ДобавитьЦелоеПоле('ID');
    результат.ДобавитьЦелоеПоле('LayerID');
    результат.ДобавитьЦелоеПоле('NaturalKey');
    результат.ДобавитьСтроковоеПоле('Alias',255);
    результат.ДобавитьСтроковоеПоле('fieldname',255);
    результат.ДобавитьСтроковоеПоле('DBName',255);
    результат.ДобавитьСтроковоеПоле('Reason',4096);
  конец;
  
  // Комментарий
  функция ПараметрыОткрытия(Имена, Значения: Переменная): IVariables;
  переменные
    ж: целое;
  начало
    результат := CreateVariables;
    от ж := Имена.НижняяГраницаМассива(1) до Имена.ВерхняяГраницаМассива(1) делать
      результат.Значение(Имена.КакСтрока(ж)) := Значения.КакСтрока(ж);
  конец;
  
  // Сравнение имен полей
  функция ЗначениеПараметраПохоже(ДанныеПередачи: СтатическиеДанные; Имя, Значение: строка): целое;
  переменные
    сс: СтатическиеДанные;
  начало
    результат := нет;
    если ДанныеПередачи.Локализовать("ИмяПараметра", МассивИз(Имя), 0) тогда
    начало
      сс := СоздатьСтатическиеДанные;
      сс.ДобавитьСтроковоеПоле("СтрокаИсточника", 255);
      сс.Открыть;
      сс.СкопироватьЗапись(1, ДанныеПередачи);
      сс.Filter := "СтрокаИсточника like '%" + Значение + "%'";
      сс.Filtered := да;
//      сс.Группировать(nil, "ИмяПараметра=ИмяПараметра;СтрокаИсточника=СтрокаИсточника;Флаг=СтрокаИсточника like '%" + Значение + "%'");
      результат := не (сс.Bof и сс.Eof);
    конец;
  конец;
  
  // Сравнение имен полей
  функция ЗначениеПараметраВ(ДанныеПередачи: СтатическиеДанные; Имя, Значение: строка): целое;
  переменные
    сс: СтатическиеДанные;
  начало
    результат := нет;
    если ДанныеПередачи.Локализовать("ИмяПараметра", МассивИз(Имя), 0) тогда
    начало
      если Значение &lt;&gt; "" тогда
      начало
        сс := СоздатьСтатическиеДанные;
        сс.ДобавитьСтроковоеПоле("СтрокаИсточника", 255);
        сс.Открыть;
        сс.СкопироватьЗапись(1, ДанныеПередачи);
        сс.Filter := "СтрокаИсточника in [" + Значение + "]";
        сс.Filtered := да;
        результат := не (сс.Bof и сс.Eof);
      конец;
    конец;
  конец;
  
  // Сравнение для Маски
  функция ЗначениеПараметраРавно(ДанныеПередачи: СтатическиеДанные; Имя, Значение: строка): целое;
  переменные
    сс: СтатическиеДанные;
  начало
    результат := нет;
    если ДанныеПередачи.Локализовать("ИмяПараметра", МассивИз(Имя), 0) тогда
    начало
      сс := СоздатьСтатическиеДанные;
      сс.ДобавитьСтроковоеПоле("СтрокаИсточника", 255);
      сс.Открыть;
      сс.СкопироватьЗапись(1, ДанныеПередачи);

      сс.Filter := "/*$T-*/ СтрокаИсточника = '" + Значение + "' /*$T=*/";
      сс.Filtered := да;
      результат := не (сс.Bof и сс.Eof);
    конец;
  конец;
  
  // Комментарий
  функция ПолучитьПодключенияСправочников(ТекущиеПередачи: СтатическиеДанные; алиасКлассификатор: строка): строка;
  переменные
    ПоляСправочников: СтатическиеДанные;
  начало
    результат := '';
    ТекущиеПередачи.Filter := "ИмяПараметра = 'АлиасСлоя' and СтрокаИсточника = '" + алиасКлассификатор + "'";
    ПоляСправочников := СоздатьСтатическиеДанные;
    ПоляСправочников.ДобавитьЦелоеПоле('ИДПодключения');
    ПоляСправочников.Открыть;
    ПоляСправочников.Закачать(ТекущиеПередачи);
    ПоляСправочников.ВНачало; 
    пока не ПоляСправочников.ВКонце делать
    начало
      ТекущиеПередачи.Filter := "ИмяПараметра = 'Имя' and ИДПодключения = " + ЦелоеВСтроку(ПоляСправочников.Поле('ИДПодключения').КакЦелое);
      если результат = '' тогда
        результат := "'" + ТекущиеПередачи.Поле('СтрокаИсточника').КакСтрока + "'"
      иначе
        результат := результат + ",'" + ТекущиеПередачи.Поле('СтрокаИсточника').КакСтрока + "'";
      ПоляСправочников.Следующая;
    конец;
    ТекущиеПередачи.Filter := "";
  конец;

  // Комментарий
  функция ПолучитьПоляИзДескриптора(НоваяМаска, алиасКлассификатор, ПодстрокаРус, ПодстрокаЛат: строка): СтатическиеДанные;
  переменные
    Контроллеры, Обработчики, НужнаяПередача, Передача, Расширения: ILayer;
    ДанныеОбработчиков, ДанныеПередачи, ДанныеРасширений, ТекущиеПередачи: СтатическиеДанные;
    ПоляПодключений, Reason: строка;
  начало
    результат := СоздатьПоля;
    результат.Открыть;
    
    Контроллеры := МенеджерСлоев.CreateLayerByAlias(аКонтроллеры);
    Контроллеры.SelectData(ПараметрыОткрытия(МассивИз("$Layer.Наименование", "$Layer.Наименование.Ограничение"), МассивИз(КонтроллерыДобавленияПоля, "in")));
    
    Обработчики := МенеджерСлоев.CreateLayerByAlias(аОбработчики);
    Обработчики.SelectData(ПараметрыОткрытия(МассивИз("$Layer.ИДКонтроллера", "$Layer.ИДКонтроллера.Ограничение", "$Layer.ИмяТочкиПодключения"), 
    МассивИз(БезЗапятой(СписокИдентификатов(Контроллеры.LayerData, 'ИД')), "in", "ИнициализацияКомпонента")));
    
    Передача := МенеджерСлоев.CreateLayerByAlias(аПередача);
    Передача.SelectData(ПараметрыОткрытия(МассивИз("$Layer.ИДПодключения", "$Layer.ИДПодключения.Ограничение"), 
    МассивИз(БезЗапятой(СписокИдентификатов(Обработчики.LayerData, 'ИД')), "in")));
    
    Расширения := МенеджерСлоев.CreateLayerByAlias(аРасширения);
    Расширения.SelectData(ПараметрыОткрытия(МассивИз("$Layer.ИД", "$Layer.ИД.Ограничение"), 
    МассивИз(БезЗапятой(СписокИдентификатов(Обработчики.LayerData, 'ИДЗаголовка')), "in")));
    
       
    ТекущиеПередачи := СоздатьСтатическиеДанные;
    ТекущиеПередачи.AssignFields(Передача.LayerData);
    ТекущиеПередачи.Открыть;
    ТекущиеПередачи.Filter := "";
    ТекущиеПередачи.Filtered := да;
    
    ДанныеРасширений := Расширения.LayerData;
    ДанныеРасширений.ВНачало;
    пока не ДанныеРасширений.ВКонце делать
    начало
      ТекущиеПередачи.Clear;
      Обработчики := Расширения.GetDetail('ПодключениеОбработчиков');
      ДанныеОбработчиков := Обработчики.LayerData;
      
      ДанныеОбработчиков.ВНачало;
      пока не ДанныеОбработчиков.ВКонце делать
      начало
        НужнаяПередача := Обработчики.GetDetail("ПередачаПараметров");
        ТекущиеПередачи.Закачать(НужнаяПередача.LayerData, "");
        
        ДанныеОбработчиков.Следующая;
      конец;
      
      ДанныеОбработчиков.ВНачало;
      пока не ДанныеОбработчиков.ВКонце делать
      начало
        НужнаяПередача := Обработчики.GetDetail("ПередачаПараметров");
        Reason := '';
        ПоляПодключений := ПолучитьПодключенияСправочников(ТекущиеПередачи, алиасКлассификатор);
        ДанныеПередачи := НужнаяПередача.LayerData;
        если (ЗначениеПараметраПохоже(ДанныеПередачи, "Имя", ПодстрокаРус)
        или ЗначениеПараметраПохоже(ДанныеПередачи, "Имя", ПодстрокаЛат)
        или ЗначениеПараметраПохоже(ДанныеПередачи, "ИмяПоляБД", ПодстрокаРус) 
        или ЗначениеПараметраПохоже(ДанныеПередачи, "ИмяПоляБД", ПодстрокаЛат) 
        или ЗначениеПараметраПохоже(ДанныеПередачи, "Формула", алиасКлассификатор)
        или ЗначениеПараметраВ(ДанныеПередачи, "ГлавноеПоле", ПоляПодключений))
        и (не ЗначениеПараметраРавно(ДанныеПередачи, "Маска", НоваяМаска)
        и не ЗначениеПараметраРавно(ДанныеПередачи, "Маска", "")
        и ДанныеПередачи.Локализовать("ИмяПараметра", МассивИз("Маска"), 0))
        и ЗначениеПараметраРавно(ДанныеПередачи, "Вставить", "1") тогда
        начало
          результат.Вставить;
          
          если ЗначениеПараметраПохоже(ДанныеПередачи, "Имя", ПодстрокаРус)
          или ЗначениеПараметраПохоже(ДанныеПередачи, "Имя", ПодстрокаЛат) тогда
            Reason := Reason + 'Дескриптор Имя; ';
          если ЗначениеПараметраПохоже(ДанныеПередачи, "ИмяПоляБД", ПодстрокаРус) 
          или ЗначениеПараметраПохоже(ДанныеПередачи, "ИмяПоляБД", ПодстрокаЛат) тогда
            Reason := Reason + 'Дескриптор ИмяПоляБД; ';
          если ЗначениеПараметраПохоже(ДанныеПередачи, "Формула", алиасКлассификатор) тогда
            Reason := Reason + 'Descr Формула; ';
          если ЗначениеПараметраВ(ДанныеПередачи, "ГлавноеПоле", ПоляПодключений) тогда
            Reason := Reason + 'Дескриптор ГлавноеПоле; ';
            
          результат.Поле('ID').КакЦелое := - ДанныеОбработчиков.Поле('ИД').КакЦелое;
          ДанныеПередачи.Локализовать("ИмяПараметра", МассивИз('Имя'), 0); результат.Поле('fieldname').КакСтрока := ДанныеПередачи.Поле('СтрокаИсточника').КакСтрока;
          результат.Поле('LayerID').КакЦелое := МенеджерСлоев.CreateLayerByAlias(ДанныеРасширений.Поле('ИмяКомпонента').КакСтрока).LayerID;
          ДанныеПередачи.Локализовать("ИмяПараметра", МассивИз('ИмяПоляБД'), 0); результат.Поле('DBName').КакСтрока := ДанныеПередачи.Поле('СтрокаИсточника').КакСтрока;
          если ДанныеПередачи.Локализовать("ИмяПараметра", МассивИз('НатуральныйКлюч'), 0) тогда
            результат.Поле('NaturalKey').КакЦелое := СтрокаВЦелое(ДанныеПередачи.Поле('СтрокаИсточника').КакСтрока)
          /*иначе
            результат.Поле('NaturalKey').IsNull := да*/;
          
          результат.Поле('Alias').КакСтрока := ДанныеРасширений.Поле('ИмяКомпонента').КакСтрока;
          
          результат.Поле('Reason').КакСтрока := Reason;
          результат.Сохранить;
        конец;

        ДанныеОбработчиков.Следующая;
      конец;
      ДанныеРасширений.Следующая;
    конец;
  конец;

  // Комментарий
  функция ВыполнитьЗаменуВДескрипторе(НегативныйИД: целое; ИмяПоляБД: строка); 
  переменные
    ИДПодключения: целое;
    Обработчики, Передача: ILayer;
    ДанныеПередачи: СтатическиеДанные;
  начало
    ИДПодключения := - НегативныйИД;
    Обработчики := МенеджерСлоев.CreateLayerByAlias(аОбработчики);
    Обработчики.SelectData(ПараметрыОткрытия(МассивИз("$Layer.ИД"), 
    МассивИз(ИДПодключения)));
    Передача := Обработчики.GetDetail("ПередачаПараметров");
    ДанныеПередачи := Передача.LayerData;
    если ДанныеПередачи.Локализовать("ИмяПараметра", МассивИз("ИмяПоляБД"), 0) тогда
    начало
      ДанныеПередачи.Edit;
      ДанныеПередачи.Поле("СтрокаИсточника").КакСтрока := ИмяПоляБД;
      ДанныеПередачи.Post;
    конец;
    Передача.Commit;
  конец;
  
  // Комментарий
  функция СвободноеПолеИзОписания(Описание: СтатическиеДанные; ИмяПоля: строка): целое;
  переменные
    СтроковоеОписание: СтатическиеДанные;
    к: целое;
    СтроковыеПоля: строка;
  начало
    результат := нет;
    СтроковоеОписание := СоздатьСтатическиеДанные;
    СтроковоеОписание.ДобавитьЦелоеПоле('Flag');
    СтроковоеОписание.ДобавитьСтроковоеПоле('DBName', 4096);
    СтроковоеОписание.Группировать(Описание, "keys=*;DBName=DBName;Flag=DBName like 'STRFIELD%'");
    СтроковоеОписание.Filter := "Flag=1";
    СтроковоеОписание.Filtered := да;
    если СтроковоеОписание.Bof и СтроковоеОписание.Eof тогда
    начало
      результат := да;
      ИмяПоля := 'STRFIELD00';
    конец  
    иначе
    начало
      ВнутренняяГруппировка(СтроковоеОписание, "keys=;DBName=sum(DBName + ',')", да);
      СтроковыеПоля := СтроковоеОписание.Поле('DBName').КакСтрока;
      от к := 0 до 25 делать
      начало
        ИмяПоля := 'STRFIELD' + ЛевоеВыравнивание(ЦелоеВСтроку(к), 2, '0');
        если Позиция(ИмяПоля, СтроковыеПоля) = 0 тогда
        начало
          результат := да;
          прервать;
        конец;
      конец;
    конец;
  конец;


  // Комментарий
  функция ПереносДанных(Лог: ОкноВывода);
  переменные
    ЗанятыеПоля, ОписаниеПолей, Тест, Слой: ILayer;
    ЗанятыеДанные, Описание, Данные: СтатическиеДанные;
    СтарыйАлиас: строка;
    ИД, Алиас, ИмяПоля, ИмяПоляБД, ИмяВБД, СлойИД: Поле;
    НовоеПоле: строка;
    НуженСтроковыйПеренос: целое;
  начало
    ОписаниеПолей := ПолучитьМенеджерСлоев.CreateLayerByAlias(аПоля);
    Описание := ОписаниеПолей.LayerData;
    ОписаниеПолей.SelectData(nil);
    Описание.IndexFieldNames := 'СлойАлиас;ИмяПоля';
    ИмяВБД := Описание.Поле('ИмяПоляБД');
    СлойИД := Описание.Поле('СлойИД'); 
    
    
    Тест := ПолучитьМенеджерСлоев.CreateLayerByAlias(аЗанятыеПоля);
    Данные := Тест.LayerData;
    Тест.OpenEmpty;
    
    ЗанятыеПоля := ПолучитьМенеджерСлоев.CreateLayerByAlias(аЗанятыеПоля);
    ЗанятыеДанные := ЗанятыеПоля.LayerData;
    ЗанятыеПоля.Open;
    ИД := ЗанятыеДанные.Поле("ИД");
    Алиас := ЗанятыеДанные.Поле("АлиасСлоя");    
    ИмяПоля := ЗанятыеДанные.Поле("ИмяПоля");  
    ИмяПоляБД := ЗанятыеДанные.Поле("ИмяПоляБД"); 
    
    СтарыйАлиас := '';
    ЗанятыеДанные.IndexFieldNames := 'АлиасСлоя;ИмяПоля';
    ЗанятыеДанные.ВНачало;
    пока не ЗанятыеДанные.ВКонце делать
    начало
      
      если Описание.Локализовать('СлойАлиас;ИмяПоля', МассивИз(Алиас.КакСтрока, ИмяПоля.КакСтрока), 0) тогда
      начало
        если СтарыйАлиас &lt;&gt; Алиас.КакСтрока тогда
        начало
          // одно поле есть KCSR
          если 'KCSR' &lt;&gt; ИмяВБД.КакСтрока тогда
          начало
            если ИмяПоляБД.КакСтрока &lt;&gt; 'KCSR' тогда
            начало
              ВыполнитьЗапрос(Формат('update LayerData set KCSR = %s where LayerRef = %d', ИмяПоляБД.КакСтрока, СлойИД.КакЦелое));
              ВыполнитьЗапрос(Формат('update LayerData set %s = null where LayerRef = %d', ИмяПоляБД.КакСтрока, СлойИД.КакЦелое));
            конец;
            если ИД.КакЦелое &gt; 0 тогда
            начало
              Описание.Edit;
              ИмяВБД.КакСтрока := 'KCSR';
              Описание.Post;
            конец
            иначе
              ВыполнитьЗаменуВДескрипторе(ИД.КакЦелое, 'KCSR');
          конец;
        конец
        иначе 
        начало
          НуженСтроковыйПеренос := ИмяПоляБД.КакСтрока &lt;&gt; ИмяВБД.КакСтрока или Подстрока(ИмяВБД.КакСтрока, 1, 8) = 'INTFIELD';
 
          попытка
            Слой := ПолучитьМенеджерСлоев.CreateLayerByAlias(Алиас.КакСтрока);
            если СвободноеПолеИзОписания(Слой.Description.Fields.Data, НовоеПоле) тогда
            начало
              если НовоеПоле &lt;&gt; ИмяВБД.КакСтрока тогда
                если ИД.КакЦелое &gt; 0 тогда
                начало
                  Описание.Edit;
                  ИмяВБД.КакСтрока := НовоеПоле;
                  Описание.Post;
                конец
                иначе
                  ВыполнитьЗаменуВДескрипторе(ИД.КакЦелое, НовоеПоле);
                
              если НовоеПоле = ИмяПоляБД.КакСтрока тогда
                НуженСтроковыйПеренос := нет;
            конец
            иначе
              НуженСтроковыйПеренос := нет;
            
            если НуженСтроковыйПеренос тогда
            начало
              ВыполнитьЗапрос(Формат("update LayerData set %s = LPAD(%s, %d, '0') where LayerRef = %d", НовоеПоле, ИмяПоляБД.КакСтрока, 7, СлойИД.КакЦелое));
              ВыполнитьЗапрос(Формат('update LayerData set %s = null where LayerRef = %d', ИмяПоляБД.КакСтрока, СлойИД.КакЦелое));
            конец;
          неудача
            Лог.Вывести('Ошибка при запросе описания слоя ' + Алиас.КакСтрока + ' ' + ПоследняяОшибка);  
          конец;
        конец;
      конец;
    
      СтарыйАлиас := Алиас.КакСтрока;
      ЗанятыеДанные.Следующая;
    конец;
    ВыполнитьЗапрос(Формат("update LayerData set KCSR = LPAD(KCSR, %d, '0') where KCSR is not null" + ЕслиЗначение(IsOracle, "", " or Trim(KCSR) &lt;&gt; ''"), 7));
    ОписаниеПолей.Commit;
    //показать(Данные);
  конец;


переменные
  Лог: ОкноВывода;
  ТекстВФайл: строка;
  ДлинаТекста: целое;
  Файл: целое;
  СтроковыеПоля: IVariables;
  СписокСлоев: строка;
  ОбновленияНатуральныхКлючей: СтатическиеДанные;
//  Идентификаторы: СтатическиеДанные;
начало
  Лог := ОкноВывода;
  Лог.Очистить;
  если СформироватьАлиасБД("Planning", ПараметрыПодключения) тогда
  начало
    МенеджерСлоев := ПолучитьМенеджерСлоев;
   
    ТекстВФайл:='&lt;html&gt;&lt;head&gt;&lt;title&gt;Преобразовали Классификаторы к буквенно-цифровой маске&lt;/title&gt;
                &lt;style type="text/css"&gt;
                   td { 
                    font-size: 10pt;
                    font-weight: normal;
                   }
                   th { 
                    font-size: 10pt;
                    font-weight: normal; 
                   }
                  &lt;/style&gt;
                &lt;/head&gt;&lt;body&gt;';

    СтроковыеПоля := СоздатьКоллекцию;
  //  Идентификаторы := СоздатьИдентификаторы;
    СписокСлоев := '';
    ОбновленияНатуральныхКлючей := СоздатьИдентификаторы;
    ПереносДанных(Лог);                    

    ЭкспортОписаний(СписокСлоев);
    
    ОбновленияНатуральныхКлючей.Filter := 'NaturalKey&gt;0';
    ОбновленияНатуральныхКлючей.Filtered := да;
    ВнутренняяГруппировка(ОбновленияНатуральныхКлючей, 'keys=;LayerList=sum(LayerList + #13#10)', да);
    Лог.Вывести(#13#10#13#10'Слои требующие обновления натуральных ключей:');
    Лог.Вывести(ОбновленияНатуральныхКлючей.Поле('LayerList').КакСтрока);
    
    ТекстВФайл:=ТекстВФайл+'&lt;p&gt;Слои требующие обновления натуральных ключей:&lt;/p&gt;';
    //ТекстВФайл:=ТекстВФайл+'&lt;p&gt;' + ЗаменитьПодстроку(ОбновленияНатуральныхКлючей.Поле('LayerList').КакСтрока, #13#10, '&lt;br&gt;', да) + '&lt;/p&gt;';
    ТекстВФайл:=ТекстВФайл+'&lt;pre&gt;' + ОбновленияНатуральныхКлючей.Поле('LayerList').КакСтрока + '&lt;/pre&gt;';
  конец
  иначе
    Лог.Вывести('Ошибка при подключении к базе Planning '#13#10 + ПараметрыПодключения);
  
  Лог.Показать; 
  
  ТекстВФайл:=ТекстВФайл+'&lt;/body&gt;&lt;/html&gt;';
  ДлинаТекста:=Длина(ТекстВФайл);
  попытка
    Файл := FileCreate('ФайлБуквЦифр.html');
    FileWrite(Файл,ТекстВФайл,ДлинаТекста);
  обязательно
    FileClose(Файл);  
  конец;  
конец.
</script>
</registry>