Compare text

Find the difference between two text files

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

Tools

Untitled diff

Created 9 years agoDiff never expires

//-----------------------------------------------------------------------------

// scr_DataflowUtils

//-----------------------------------------------------------------------------

var DataflowUtils = new Object();

var DataflowNodeName = 'Dataflow';

var ItemNodeName = 'Item';

var ItemsNodeName = 'Items';

var SettingsNodeName = 'Settings';

var DestinationNodeName = 'Destination';

var ColumnsNodeName = 'Columns';

var BackRelationsNodeName = 'BackRelations';

var EnumNodeName = 'Enum';

var EnumItemNodeName = 'EnumItem';

var NameAttributeName = 'Name';

var SourceNameAttributeName = 'SourceName';

var RootTableSQLNameAttributeName = 'RootTableSQLName';

var FirstRowAttributeName = 'FirstRow';

var FirstColumnAttributeName = 'FirstColumn';

var LastColumnAttributeName = 'LastColumn';

var IsFirstHeaderAttributeName = 'IsFirstHeader';

var ValueAttributeName = 'Value';

var TypeAttributeName = 'Type';

var IsDefaultAttributeName = 'IsDefault';

var IsPrimaryAttributeName = 'IsPrimary';

var ForeignKeyFieldAttributeName = 'ForeignKeyField';

var IDAttributeName = 'ID';

var TempFieldNameAttributeName = 'TempFieldName';

var TempIndexAttributeName = 'TempIndex';

var FileBodyAttributeName = 'FileBody';

var gtPrimaryKeys = 0;

var gtDefaultValues = 1;

var gtEnumItems = 2;

var ErrorDelimiter = '***';

var ErrorIndent = '***';

var WarningIndent = '-----';

var InformationIndent = ' ';

var EnumItemValueDelimiter = ';'

//TODO

var msgDeletePrimaryKeysConfirmation =

"Вы действительно хотите удалить первичные ключи?";

//TODO

var msgDeleteDefaultValuesConfirmation =

"Вы действительно хотите удалить значения по умолчанию?";

//TODO

var msgDeleteColumnConfirmation =

"Вы действительно хотите удалить колонку?";

//TODO

var msgFieldIsAssignedToColumn =

"Поле уже привязано к колонке. Продолжить?"

var msgFieldIsDefaultValue =

"Полю уже назначено значение по умолчанию. Продолжить?";

//TODO

var msgFieldIsPrimaryDisplay =

"Поле является первичным для отображения. Добавить в первичный ключ?";

var msgDataflowTypeIsNotDefined =

"Тип интеграции не определен";

var msgDataflowOperationIsNotDefined =

"Операция невозможна для даного типа интеграции";

var msgSelectFileForImport =

"Выберите файл для импорта"

var msgDestinationNodeNotFound =

"Узел 'Destination' не найден";

var msgSettingsNodeNotFound =

"Узел 'Settings' не найден";

var msgDatasetWasNotCreated =

"Набор данных не был сформирован";

var msgImportDataToTable =

"Импортируются данные в таблицу '%1'";

var msgImportDataToTableFinished =

"Импорт данных в таблицу '%1' завершен. Добавлено: %2. Обновлено: %3.";

//TODO

var msgPrimaryKeysDoesntExistsSkip =

"Первичные поля не существуют. Таблица пропускается.";

var msgImportRecord =

"Импортируется запись %1";

var msgRecordIsAlreadyImported =

"Запись уже была проимпортирована";

//TODO

var msgPrimaryKeyIsEmptySkip =

"Первичное поле '%1' пустое. Запись пропускается.";

var msgUnsupportedNodeType =

"Недопустимый тип узла";

var msgInsertRecord =

"Запись добавлена";

var msgUpdateRecord =

"Запись обновлена";

var msgLookupWasNotImported =

"Справочник для поля '%1' не был проимпортирован";

var msgLookupIsNotDefined =

"Справочник для поля '%1' не определен";

var msgWrangDEfaultValue =

"Некорректно определено значение по умолчанию для поля '%1'";

var msgDatafieldIsNotDefined =

"Не определено поле в наборе данных для поля '%1'";

var msgUpdateRecordIsNotNeed =

"Нет необходимости обновлять запись";

var msgCantImportTableSkip =

"Невозможно импортировать данные. Таблица пропускается.";

var msgImportInterruptedbyUser =

"Импорт прерван пользователем";

var msgExecuteImportFromFile =

"Импортируются данные из файла '%1'";

var msgTableIsNotAssigned =

"Таблица не указана";

var msgDoYouWantLookImportLog =

"Импорт завершен. Показать журнал процесса импорта?";

var msgDataflowWasChanged =

"Настройки интеграции были изменены. Сохранить изменения?"

function NotifyParentWindow(Window, Message, Data) {

var ParentWindow = Window.Attributes('ParentWindow');

ParentWindow.Notify(Window, Message, Data);

}

function AddCommonRecord(Dataset, ID, ParentID, RecordType, Caption, HasChild){

Dataset.Append();

Dataset.Values('ID') = ID;

Dataset.Values('ParentID') = ParentID;

Dataset.Values('RecordType') = RecordType;

Dataset.Values('Caption') = Caption;

Dataset.Values('HasChild') = HasChild;

Dataset.Post();

}

function AddPrimaryKeyRecord(Dataset, ID, ParentID, Caption, HasChild){

Dataset.Append();

Dataset.Values('ID') = ID;

Dataset.Values('ParentID') = ParentID;

Dataset.Values('RecordType') = rtcField;

Dataset.Values('Caption') = Caption;

Dataset.Values('IsPrimaryKey') = true;

Dataset.Values('HasChild') = HasChild;

Dataset.Post();

}

function AddDefaultValueRecord(Dataset, ID, ParentID, Caption, HasChild){

Dataset.Append();

Dataset.Values('ID') = ID;

Dataset.Values('ParentID') = ParentID;

Dataset.Values('RecordType') = rtcField;

Dataset.Values('Caption') = Caption;

Dataset.Values('IsDefaultValue') = true;

Dataset.Values('HasChild') = HasChild;

Dataset.Post();

}

function AddEnumRecord(Dataset, ID, ParentID, Caption, HasChild,

EnumItemID){

Dataset.Append();

Dataset.Values('ID') = ID;

Dataset.Values('ParentID') = ParentID;

Dataset.Values('RecordType') = rtcField;

Dataset.Values('Caption') = Caption;

Dataset.Values('IsEnum') = true;

Dataset.Values('HasChild') = HasChild;

Dataset.Values('EnumItemID') = EnumItemID;

Dataset.Post();

}

function GetDestinationCountByDestinationNode(

DestinationNode, DestinationCount){

var BackRelations = DestinationNode.FindChildNode(BackRelationsNodeName);

if (Assigned(BackRelations)){

for (var i = 0; i < BackRelations.Count; i++){

DestinationCount = GetDestinationCountByDestinationNode(

BackRelations.Items(i), DestinationCount);

}

var Column;

var DestinationSubNode;

var Columns = DestinationNode.FindChildNode(ColumnsNodeName);

if (Assigned(Columns)){

for (var i = 0; i < Columns.Count; i++){

Column = Columns.Items(i);

DestinationSubNode = Column.FindChildNode(DestinationNodeName);

if (Assigned(DestinationSubNode)){

DestinationCount = GetDestinationCountByDestinationNode(

DestinationSubNode, DestinationCount)

}

DestinationCount++;

return DestinationCount;

}

function TranslateDestinationNodeToDataset(Dataset, DestinationNode, ParentID,

TranslationType, Nodes, Skip){

if (!Assigned(Nodes)){

Nodes = new Object();

}

var TableName = DestinationNode.GetAttributeAsStr(NameAttributeName, '');

if (IsEmptyValue(TableName)){

return Nodes;

}

var Table = Services.GetSingleItemByUSI(TableName);

var ForeignKeyFieldName =

DestinationNode.GetAttributeAsStr(ForeignKeyFieldAttributeName, '');

var Caption;

if (IsEmptyValue(ForeignKeyFieldName )){

Caption = Table.Caption;

} else {

Caption = GetBackRelationCaption(Table, ForeignKeyFieldName);

}

var DestinationID;

if (!Skip){

DestinationID = Connector.GenGUID();

AddCommonRecord(Dataset, DestinationID, ParentID, rtcTable, Caption);

} else {

DestinationID = ParentID;

}

var BackRelations = DestinationNode.FindChildNode(BackRelationsNodeName);

if (Assigned(BackRelations)){

var BackRelationID = Connector.GenGUID();

AddCommonRecord(Dataset, BackRelationID, DestinationID,

rtcBackRelationsGroup, rcBackRelationsGroup);

for (var i = 0; i < BackRelations.Count; i++){

Nodes = TranslateDestinationNodeToDataset(Dataset,

BackRelations.Items(i), BackRelationID, TranslationType, Nodes);

}

if (TranslationType == gtEnumItems){

if (!Dataset.Locate('ParentID', BackRelationID)){

Dataset.Locate('ID', BackRelationID);

Dataset.Delete();

}

var Columns = DestinationNode.FindChildNode(ColumnsNodeName);

if (Assigned(Columns)){

var Column;

var DestinationSubNode;

var IsPrimary;

var ColumnID;

var FieldName;

var Field;

var PostColumn;

var Caption;

var DestinationSubNodeExist;

var SubTableCode;

var SubTableCaption;

var Enum;

var EnumItem;

var ID;

for (var i = 0; i < Columns.Count; i++){

Column = Columns.Items(i);

DestinationSubNode = Column.FindChildNode(DestinationNodeName);

FieldName = Column.GetAttributeAsStr(NameAttributeName, false)

Field = Table.Fields.ItemsByName(FieldName);

IsPrimary =

Column.GetAttributeAsBool(IsPrimaryAttributeName, false);

IsDefault =

Column.GetAttributeAsBool(IsDefaultAttributeName, false);

IsEnum = (Field.SQLDataType == sdtEnum) && !IsDefault;

PostIsPrimary = IsPrimary && (TranslationType == gtPrimaryKeys);

PostIsDefault = IsDefault && (TranslationType == gtDefaultValues);

PostIsEnum = IsEnum && (TranslationType == gtEnumItems);

PostColumn = PostIsPrimary || PostIsDefault || PostIsEnum;

DestinationSubNodeExist = Assigned(DestinationSubNode);

if (!DestinationSubNodeExist && !PostColumn) {

continue;

}

ColumnID = Connector.GenGUID();

if (DestinationSubNodeExist){

SubTableCode =

DestinationSubNode.GetAttributeAsStr(NameAttributeName, '');

// TODO

if (!SubTableCode) {

Caption = Field.Caption;

} else {

SubTableCaption =

Services.GetSingleItemByUSI(SubTableCode).Caption;

Caption = FormatStr(rcForeignKeyColumn, SubTableCaption,

Field.Caption);

}

}else {

Caption = Field.Caption;

}

if (PostIsPrimary){

AddPrimaryKeyRecord(Dataset, ColumnID, DestinationID, Caption,

DestinationSubNodeExist);

} else if (PostIsDefault){

AddDefaultValueRecord(Dataset, ColumnID, DestinationID,

Caption, DestinationSubNodeExist);

} else if (PostIsEnum){

AddEnumRecord(Dataset, ColumnID, DestinationID, Caption,

true, null);

Enum = Field.Enum;

if (Assigned(Enum)){

for (var j = 0; j < Enum.Count; j++) {

EnumItem = Enum.Items(j);

ID = Connector.GenGUID();

AddEnumRecord(Dataset, ID, ColumnID,

EnumItem.Caption, false, EnumItem.ID);

}

} else {

AddCommonRecord(Dataset, ColumnID, DestinationID, rtcField,

Caption, DestinationSubNodeExist);

}

if (PostColumn){

Nodes[ColumnID] = Column;

}

if (DestinationSubNodeExist) {

Nodes = TranslateDestinationNodeToDataset(Dataset,

DestinationSubNode, ColumnID, TranslationType, Nodes, true);

if (TranslationType == gtEnumItems){

if (!Dataset.Locate('ParentID', ColumnID)){

Dataset.Locate('ID', ColumnID);

Dataset.Delete();

}

if ((TranslationType == gtEnumItems) && !Skip){

if (!Dataset.Locate('ParentID', DestinationID)){

Dataset.Locate('ID', DestinationID);

Dataset.Delete();

}

return Nodes;

}

function GetCanDragOverFromTablesTree(DataTreeGrid, DataGridColumn, RowIDs) {

if (DataTreeGrid.Tag != 'TablesTree') {

return false;

}

var Result = Assigned(DataGridColumn) && Assigned(DataGridColumn.DataField)

&& RowIDs.Count;

if (Result){

var Dataset = DataTreeGrid.DatasetLink.Dataset;

DataTreeGrid.BeginUpdate();

Dataset.DisableEvents();

try {

var OldID = Dataset.Values(mdfnID);

for (var i = 0; i < RowIDs.Count; i++) {

Dataset.Locate(mdfnID, RowIDs.Items(i));

if (Dataset.Values(mdfnRecordTypeCode) != rtcField) {

Result = false;

break;

}

Dataset.Locate(mdfnID, OldID);

} finally {

Dataset.EnableEvents();

DataTreeGrid.EndUpdate();

}

return Result;

}

function AddColumnInfoToNode(TreeDataset, ImportItemNode, PathIDs, ParentNode){

if (PathIDs.length == 0){

return ParentNode;

}

var RowID = PathIDs.pop();

TreeDataset.Locate(mdfnID, RowID);

var Node;

if (!Assigned(ParentNode)){

Node = ImportItemNode.GetChildNode(DestinationNodeName);

Node.SetAttributeAsStr(NameAttributeName,

TreeDataset.Values(mdfnTableCode), '');

} else {

var RecordType = TreeDataset.Values(mdfnRecordTypeCode);

var TableCode;

switch (RecordType){

case rtcEmpty:

Log.Write(lmtError, msgUnsupportedNodeType);

return null;

break;

case rtcTable:

TableCode = TreeDataset.Values(mdfnTableCode);

if (ParentNode.Name == BackRelationsNodeName){

Node = ParentNode.GetChildNodeByAttributeValue(

DestinationNodeName, NameAttributeName, TableCode);

} else {

Node = ParentNode.GetChildNode(DestinationNodeName);

}

Node.SetAttributeAsStr(NameAttributeName,

TableCode, '');

Node.SetAttributeAsStr(ForeignKeyFieldAttributeName,

TreeDataset.Values(mdfnFieldName), '');

break;

case rtcField:

ParentNode = ParentNode.GetChildNode(ColumnsNodeName);

Node = ParentNode.GetChildNodeByAttributeValue(ItemNodeName,

NameAttributeName, TreeDataset.Values(mdfnFieldName));

if (PathIDs.length != 0){

Node = Node.GetChildNode(DestinationNodeName);

var ChildID = PathIDs[PathIDs.length - 1];

TreeDataset.Locate(mdfnID, ChildID);

if (IsEmptyStr(Node.GetAttributeAsStr(NameAttributeName, ''))) {

Node.SetAttributeAsStr(NameAttributeName,

TreeDataset.Values(mdfnTableCode), '');

}

break;

case rtcBackRelationsGroup:

Node = ParentNode.GetChildNode(BackRelationsNodeName);

break;

}

return AddColumnInfoToNode(TreeDataset, ImportItemNode, PathIDs, Node);

}

function GetFieldPathIDs(TreeDataset, RowID, PathIDs){

if (!Assigned(PathIDs)){

PathIDs = new Array();

}

if (IsEmptyGUID(RowID)){

return PathIDs;

}

PathIDs.push(RowID);

if (TreeDataset.Locate(mdfnID, RowID)){

var ParentID = TreeDataset.Values(mdfnParentID);

PathIDs = GetFieldPathIDs(TreeDataset, ParentID, PathIDs);

}

return PathIDs;

}

function ClearColumnAttributes(Node){

Node.SetAttributeAsInt(SourceNameAttributeName, -1, -1);

Node.SetAttributeAsBool(IsPrimaryAttributeName, false, false);

Node.SetAttributeAsBool(IsDefaultAttributeName, false, false);

Node.SetAttributeAsInt(TypeAttributeName, -1, -1);

Node.SetAttributeAsStr(ValueAttributeName, '', '');

var EnumNode = Node.FindChildNode(EnumNodeName);

if (Assigned(EnumNode)){

Node.RemoveChildNode(EnumNode);

}

function GetTableFieldByColumnNode(Node){

var DestinationNode = Node.ParentNode.ParentNode;

var TableCode = DestinationNode.GetAttributeAsStr(NameAttributeName, '');

var Table = Services.GetSingleItemByUSI(TableCode);

if (!Assigned(Table)){

return null;

}

var FieldName = Node.GetAttributeAsStr(NameAttributeName, '');

return Table.Fields.ItemsByName(FieldName);

}

function GetTableFieldTypeByColumnNode(Node){

var Type = -1;

var Field = GetTableFieldByColumnNode(Node);

if (Assigned(Field)){

Type = Field.SQLDataType;

}

return Type;

}

function GetIsPrimaryKeysExists(Columns){

var Column;

var Exists = false;

for (var i = 0; i < Columns.Count ; i++) {

Column = Columns.Items(i);

Exists = Column.GetAttributeAsBool(IsPrimaryAttributeName, false);

if (Exists){

break;

}

return Exists;

}

function CheckRequiredFieldInDestination(Node, ResultArray){

var BackRelations = Node.FindChildNode(BackRelationsNodeName);

if (Assigned(BackRelations)){

for (var i = 0; i < BackRelations.Count; i++){

CheckRequiredFieldInDestination(BackRelations.Items(i),

ResultArray);

}

var Columns = Node.FindChildNode(ColumnsNodeName);

var NotAssignedFields = new Array();

if (Assigned(Columns)){

var PrimaryKeysExists = GetIsPrimaryKeysExists(Columns);

if (PrimaryKeysExists){

var TableCode = Node.GetAttributeAsStr(NameAttributeName, '');

var Table = Services.GetSingleItemByUSI(TableCode);

var Fields = Table.Fields;

var Field;

var Column;

for (var i = 0; i < Fields.Count ; i++) {

Field = Fields.Items(i);

if (Field.IsRequired && (Field.SQLName != 'ID')){

Column = Columns.FindChildNodeByAttributeValue(ItemNodeName,

NameAttributeName, Field.SQLName);

if (!Assigned(Column)){

NotAssignedFields.push(Field.SQLName);

}

var DestinationNode;

for (var i = 0; i < Columns.Count ; i++) {

Column = Columns.Items(i);

DestinationNode = Column.FindChildNode(DestinationNodeName);

if (Assigned(DestinationNode)){

CheckRequiredFieldInDestination(DestinationNode, ResultArray);

}

if (NotAssignedFields.length > 0){

NotAssignedFields.Node = Columns;

ResultArray.push(NotAssignedFields);

}

function CheckRequiredFieldInDataflow(XMLStorage){

var FullResult = new Array();

var ItemsNode = XMLStorage.RootNode.GetChildNode(ItemsNodeName);

var Item;

var ItemResult;

for (var i = 0; i < ItemsNode.Count; i++) {

Item = ItemsNode.Items(i).GetChildNode(DestinationNodeName);

ItemResult = new Array();

CheckRequiredFieldInDestination(Item, ItemResult);

if (ItemResult.length > 0){

ItemResult.Node = Item;

FullResult.push(ItemResult);

}

return FullResult;

}

function GetDataFieldByTableField(DataFields, TableField){

var DataField;

switch (TableField.SQLDataType){

case sdtInteger:

DataField = DataFields.CreateIntegerDataField();

break;

case sdtFloat:

DataField = DataFields.CreateFloatDataField();

DataField.Size = TableField.SQLSize;

DataField.Precision = TableField.SQLPrecision;

break;

case sdtString:

case sdtUnicodeString:

DataField = DataFields.CreateStringDataField();

DataField.TextLength = TableField.SQLSize;

break;

case sdtBlob:

DataField = DataFields.CreateStringDataField();

DataField.TextLength = 10000;

break;

case sdtDateTime:

DataField = DataFields.CreateDateTimeDataField();

break;

case sdtBoolean:

DataField = DataFields.CreateBoolDataField();

break;

case sdtGUID:

case sdtEnum:

case sdtIdentity:

DataField = DataFields.CreateStringDataField();

break;

}

return DataField;

}

function BuildMemoryDatasetByDestinationNode(DestinationNode, MemoryDataset){

function BuildMemoryDatasetByDestinationNode(DestinationNode, MemoryDataset, AddColumns){

if (!Assigned(MemoryDataset)){

MemoryDataset = Services.CreateItem('MemoryDataset');

}

var TableName = DestinationNode.GetAttributeAsStr(NameAttributeName, '');

if (IsEmptyValue(TableName)){

return MemoryDataset;

}

var Table = Services.GetSingleItemByUSI(TableName);

var BackRelations = DestinationNode.FindChildNode(BackRelationsNodeName);

if (Assigned(BackRelations)){

for (var i = 0; i < BackRelations.Count; i++){

MemoryDataset = BuildMemoryDatasetByDestinationNode(

BackRelations.Items(i), MemoryDataset);

}

var Columns = DestinationNode.FindChildNode(ColumnsNodeName);

if (Assigned(Columns)){

var Column;

var DestinationSubNode;

var SourceName;

var FieldName;

var Field;

var TableFieldName;

var TableField;

var FieldsCounter;

var DataFields = MemoryDataset.DataFields;

for (var i = 0; i < Columns.Count; i++){

Column = Columns.Items(i);

DestinationSubNode = Column.FindChildNode(DestinationNodeName);

if (Assigned(DestinationSubNode)){

MemoryDataset = BuildMemoryDatasetByDestinationNode(

DestinationSubNode, MemoryDataset);

}

SourceName = Column.GetAttributeAsStr(SourceNameAttributeName, '');

if (SourceName == ''){

continue;

}

TableFieldName = Column.GetAttributeAsStr(NameAttributeName, false);

TableField = Table.Fields.ItemsByName(TableFieldName);

FieldsCounter = MemoryDataset.Attributes('FieldsCounter') * 1;

FieldsCounter++;

MemoryDataset.Attributes('FieldsCounter') = FieldsCounter;

FieldName = 'Field_' + FieldsCounter;

Column.SetAttributeAsStr(

TempFieldNameAttributeName, FieldName, '');

Field = GetDataFieldByTableField(DataFields, TableField);

Field.GroupName = SourceName;

Field.Name = FieldName;

DataFields.Add(Field);

}

if (AddColumns) {

TableField = Table.Fields.ItemsByName('ID');

for (i = 1; i <= AddColumns; i++) {

Field = GetDataFieldByTableField(DataFields, TableField);

Field.GroupName = i;

Field.Name = 'AllFields_' + IntToLetter(i);

DataFields.Add(Field);

}

return MemoryDataset;

}

function GetEnumInfoFromColumn(Column, ColumnObject, Field){

ColumnObject.EnumDictionary = new Object();

var Enum = Field.Enum;

if (!Assigned(Enum)){

return;

}

var EnumItem;

var EnumItemNode;

var EnumItemID;

var Value;

var ValueArray;

var EnumNode = Column.GetChildNode(EnumNodeName);

for (var i = 0; i < EnumNode.Count; i++) {

EnumItemNode = EnumNode.Items(i);

EnumItemID = EnumItemNode.GetAttributeAsStr(IDAttributeName, '');

EnumItem = Enum.ItemsByID(EnumItemID);

if (!Assigned(EnumItem)){

continue;

}

Value = EnumItemNode.GetAttributeAsStr(ValueAttributeName, '');

ValueArray = Value.split(EnumItemValueDelimiter);

for (var j = 0; j < ValueArray.length; j++) {

ColumnObject.EnumDictionary[ValueArray[j].toUpperCase()] = EnumItemID;

ColumnObject.EnumDictionary[ValueArray[j]] = EnumItemID;

}

function GetDefaultInfoFromColumn(Column, ColumnObject, Field){

ColumnObject.DefaultType =

Column.GetAttributeAsInt(TypeAttributeName, -1);

ColumnObject.DefaultIsCorrect = true;

var Value;

switch (String(ColumnObject.DefaultType)) {

case dvtValue:

break;

case dvtFunction:

ColumnObject.DefaultValue = Column.GetAttributeAsInt(

ValueAttributeName, -1);

ColumnObject.DefaultIsCorrect = (ColumnObject.DefaultValue > 0);

return;

break;

default:

ColumnObject.DefaultIsCorrect = false;

return;

}

switch(Field.SQLDataType){

case sdtInteger:

ColumnObject.DefaultValue = Column.GetAttributeAsInt(

ValueAttributeName, 0);

break;

case sdtFloat:

ColumnObject.DefaultValue = Column.GetAttributeAsFloat(

ValueAttributeName, 0);

break;

case sdtBlob:

case sdtString:

case sdtUnicodeString:

case sdtGUID:

case sdtEnum:

ColumnObject.DefaultValue = Column.GetAttributeAsStr(

ValueAttributeName, '');

break;

case sdtDateTime:

ColumnObject.DefaultValue = Column.GetAttributeAsDateTime(

ValueAttributeName, 0);

break;

case sdtBoolean:

ColumnObject.DefaultValue = Column.GetAttributeAsBool(

ValueAttributeName, false);

break;

default:

ColumnObject.DefaultIsCorrect = false;

break;

}

function GetImportObjectByNode(Destination, Dataset, ImportObjects, UpdateRecords){

function GetImportObjectByNode(Destination, Dataset, ImportObjects, UpdateRecords,

ScriptItem, DataflowID) {

var ImportProgressObject = Connector.Attributes('ImportProgressObject');

var ImportObject = new Object();

ImportObject.Updated = 0;

ImportObject.Inserted = 0;

ImportObject.PrimaryKeys = new Array();

ImportObject.PrimaryKeysIndexes = new Array();

ImportObject.DefaultValues = new Array();

ImportObject.MappedColumns = new Array();

ImportObject.Records = new Object();

ImportObject.ErrorList = new Array();

Destination.SetAttributeAsInt(TempIndexAttributeName, ImportObjects.length,

-1);

ImportObject.ImportObjects = ImportObjects;

ImportObject.IsPrimaryObject = !ImportObjects.length;

ImportObject.Position = ImportObjects.length;

ImportObjects.push(ImportObject);

var ForeignKeyFieldName =

Destination.GetAttributeAsStr(ForeignKeyFieldAttributeName, '');

ImportObject.ForeignKeyFieldName = ForeignKeyFieldName;

if (!IsEmptyStr(ForeignKeyFieldName)){

var ForeignKeyNode = Destination.ParentNode.ParentNode;

ImportObject.ForeignKeyIndex =

ForeignKeyNode.GetAttributeAsInt(TempIndexAttributeName, -1);

ImportObject.ForeignKeyObject =

ImportObject.ImportObjects[ImportObject.ForeignKeyIndex];

}

var TableName = Destination.GetAttributeAsStr(NameAttributeName, '');

if (IsEmptyValue(TableName)){

return ImportObject;

}

ImportObject.TableName = TableName;

var Table = Services.GetSingleItemByUSI(TableName);

var Columns = Destination.FindChildNode(ColumnsNodeName);

if (!Assigned(Columns)){

return ImportObject;

}

ImportObject.Table = Table;

var Column;

var DestinationSubNode;

var TempIndex;

var ColumnObject;

var SourceName;

var FieldName;

var Field;

var DataFieldName;

var DataField;

for (var i = 0; i < Columns.Count; i++){

Column = Columns.Items(i);

DestinationSubNode = Column.FindChildNode(DestinationNodeName);

ColumnObject = new Object();

SourceName = Column.GetAttributeAsStr(SourceNameAttributeName, '');

FieldName = Column.GetAttributeAsStr(NameAttributeName, false)

Field = Table.Fields.ItemsByName(FieldName);

ColumnObject.Field = Field;

ColumnObject.IsLookup = false;

if (Assigned(DestinationSubNode)){

ImportObjects = ImportDataByDestinationNode(

ImportObjects = ImportDataByDestinationNode(DestinationSubNode, Dataset,

DestinationSubNode, Dataset, ImportObjects, UpdateRecords);

ImportObjects, UpdateRecords, ScriptItem, DataflowID);

if (Assigned(ImportProgressObject) &&

ImportProgressObject.CancelledByUser){

return;

}

if (SourceName != ''){

ColumnObject.Index = DestinationSubNode.

GetAttributeAsInt(TempIndexAttributeName, -1);

ColumnObject.IsLookup = true;

if ((ColumnObject.Index == -1)){

ImportObject.ErrorList.push(FormatStr(

msgLookupIsNotDefined, ColumnObject.Field.Caption))

} else if (!(ImportObjects[ColumnObject.Index].Imported)){

ImportObjec

Saved diffs

Original text

Open file

//-----------------------------------------------------------------------------
// scr_DataflowUtils
//-----------------------------------------------------------------------------

var DataflowUtils = new Object();

var DataflowNodeName = 'Dataflow';
var ItemNodeName = 'Item';
var ItemsNodeName = 'Items';
var SettingsNodeName = 'Settings';
var DestinationNodeName = 'Destination';
var ColumnsNodeName = 'Columns';
var BackRelationsNodeName = 'BackRelations';
var EnumNodeName = 'Enum';
var EnumItemNodeName = 'EnumItem';

var NameAttributeName = 'Name';
var SourceNameAttributeName = 'SourceName';
var RootTableSQLNameAttributeName = 'RootTableSQLName';
var FirstRowAttributeName = 'FirstRow';
var FirstColumnAttributeName = 'FirstColumn';
var LastColumnAttributeName = 'LastColumn';
var IsFirstHeaderAttributeName = 'IsFirstHeader';
var ValueAttributeName = 'Value';
var TypeAttributeName = 'Type';
var IsDefaultAttributeName = 'IsDefault';
var IsPrimaryAttributeName = 'IsPrimary';
var ForeignKeyFieldAttributeName = 'ForeignKeyField';
var IDAttributeName = 'ID';
var TempFieldNameAttributeName = 'TempFieldName';
var TempIndexAttributeName = 'TempIndex';
var FileBodyAttributeName = 'FileBody';

var gtPrimaryKeys = 0;
var gtDefaultValues = 1;
var gtEnumItems = 2;

var ErrorDelimiter = '***';
var ErrorIndent = '***';
var WarningIndent = '-----';
var InformationIndent = '      ';

var EnumItemValueDelimiter = ';'

var msgDeletePrimaryKeysConfirmation = 
	"Вы действительно хотите удалить первичные ключи?";
var msgDeleteDefaultValuesConfirmation = 
	"Вы действительно хотите удалить значения по умолчанию?";
var msgDeleteColumnConfirmation = 
	"Вы действительно хотите удалить колонку?";
var msgFieldIsAssignedToColumn = 
	"Поле уже привязано к колонке. Продолжить?"	
var msgFieldIsDefaultValue = 
	"Полю уже назначено значение по умолчанию. Продолжить?";
var msgFieldIsPrimaryDisplay = 
	"Поле является первичным для отображения. Добавить в первичный ключ?";
var msgDataflowTypeIsNotDefined = 
	"Тип интеграции не определен";
var msgDataflowOperationIsNotDefined = 
	"Операция невозможна для даного типа интеграции";
var msgSelectFileForImport =
	"Выберите файл для импорта"	
var msgDestinationNodeNotFound = 
	"Узел 'Destination' не найден";
var msgSettingsNodeNotFound	=
	"Узел 'Settings' не найден";
var msgDatasetWasNotCreated =
	"Набор данных не был сформирован";
var msgImportDataToTable = 
	"Импортируются данные в таблицу '%1'";
var msgImportDataToTableFinished = 
	"Импорт данных в таблицу '%1' завершен. Добавлено: %2. Обновлено: %3.";
var msgPrimaryKeysDoesntExistsSkip = 
	"Первичные поля не существуют. Таблица пропускается.";
var msgImportRecord = 
	"Импортируется запись %1";
var msgRecordIsAlreadyImported = 
	"Запись уже была проимпортирована";
var msgPrimaryKeyIsEmptySkip = 
	"Первичное поле '%1' пустое. Запись пропускается.";	
var msgUnsupportedNodeType = 
	"Недопустимый тип узла";
var msgInsertRecord = 
	"Запись добавлена";
var msgUpdateRecord = 
	"Запись обновлена";
var msgLookupWasNotImported = 
	"Справочник для поля '%1' не был проимпортирован";
var msgLookupIsNotDefined = 
	"Справочник для поля '%1' не определен";
var msgWrangDEfaultValue = 
	"Некорректно определено значение по умолчанию для поля '%1'";
var msgDatafieldIsNotDefined =
	"Не определено поле в наборе данных для поля '%1'";
var msgUpdateRecordIsNotNeed = 
	"Нет необходимости обновлять запись";
var msgCantImportTableSkip = 
	"Невозможно импортировать данные. Таблица пропускается.";
var msgImportInterruptedbyUser = 
	"Импорт прерван пользователем";
var msgExecuteImportFromFile = 
	"Импортируются данные из файла '%1'";
var msgTableIsNotAssigned = 
	"Таблица не указана";
var msgDoYouWantLookImportLog = 
	"Импорт завершен. Показать журнал процесса импорта?";
var msgDataflowWasChanged = 
	"Настройки интеграции были изменены. Сохранить изменения?"

function NotifyParentWindow(Window, Message, Data) {
	var ParentWindow = Window.Attributes('ParentWindow');
	ParentWindow.Notify(Window, Message, Data);
}

function AddCommonRecord(Dataset, ID, ParentID, RecordType, Caption, HasChild){
	Dataset.Append();
	Dataset.Values('ID') = ID;
	Dataset.Values('ParentID') = ParentID;
	Dataset.Values('RecordType') = RecordType;
	Dataset.Values('Caption') = Caption;
	Dataset.Values('HasChild') = HasChild;
	Dataset.Post();
}

function AddPrimaryKeyRecord(Dataset, ID, ParentID, Caption, HasChild){
	Dataset.Append();
	Dataset.Values('ID') = ID;
	Dataset.Values('ParentID') = ParentID;
	Dataset.Values('RecordType') = rtcField;
	Dataset.Values('Caption') = Caption;
	Dataset.Values('IsPrimaryKey') = true;
	Dataset.Values('HasChild') = HasChild;
	Dataset.Post();
}

function AddDefaultValueRecord(Dataset, ID, ParentID, Caption, HasChild){
	Dataset.Append();
	Dataset.Values('ID') = ID;
	Dataset.Values('ParentID') = ParentID;
	Dataset.Values('RecordType') = rtcField;
	Dataset.Values('Caption') = Caption;
	Dataset.Values('IsDefaultValue') = true;
	Dataset.Values('HasChild') = HasChild;
	Dataset.Post();
	
}

function AddEnumRecord(Dataset, ID, ParentID, Caption, HasChild, 
	EnumItemID){
	Dataset.Append();
	Dataset.Values('ID') = ID;
	Dataset.Values('ParentID') = ParentID;
	Dataset.Values('RecordType') = rtcField;
	Dataset.Values('Caption') = Caption;
	Dataset.Values('IsEnum') = true;
	Dataset.Values('HasChild') = HasChild;
	Dataset.Values('EnumItemID') = EnumItemID;
	Dataset.Post();	
}

function GetDestinationCountByDestinationNode(
		DestinationNode, DestinationCount){
	var BackRelations = DestinationNode.FindChildNode(BackRelationsNodeName);
	if (Assigned(BackRelations)){
		for (var i = 0; i < BackRelations.Count; i++){
			DestinationCount = GetDestinationCountByDestinationNode(
				BackRelations.Items(i), DestinationCount);
		}
	}
	var Column;
	var DestinationSubNode;
	var Columns = DestinationNode.FindChildNode(ColumnsNodeName);
	if (Assigned(Columns)){
		for (var i = 0; i < Columns.Count; i++){
			Column = Columns.Items(i);
			DestinationSubNode = Column.FindChildNode(DestinationNodeName);
			if (Assigned(DestinationSubNode)){
				DestinationCount = GetDestinationCountByDestinationNode(
					DestinationSubNode, DestinationCount)
			}
		}
	}
	DestinationCount++;
	return DestinationCount;
}


function TranslateDestinationNodeToDataset(Dataset, DestinationNode, ParentID,
	TranslationType, Nodes, Skip){
	if (!Assigned(Nodes)){
		Nodes = new Object();
	}
	var TableName = DestinationNode.GetAttributeAsStr(NameAttributeName, '');
	if (IsEmptyValue(TableName)){
		return Nodes;
	}
	var Table = Services.GetSingleItemByUSI(TableName);
	var ForeignKeyFieldName = 
		DestinationNode.GetAttributeAsStr(ForeignKeyFieldAttributeName, '');	
	var Caption;
	if (IsEmptyValue(ForeignKeyFieldName )){
		Caption = Table.Caption;
	} else {
		Caption = GetBackRelationCaption(Table, ForeignKeyFieldName);
	}
	var DestinationID;
	if (!Skip){
		DestinationID = Connector.GenGUID();
		AddCommonRecord(Dataset, DestinationID, ParentID, rtcTable, Caption);
	} else {
		DestinationID = ParentID;
	}
	var BackRelations = DestinationNode.FindChildNode(BackRelationsNodeName);
	if (Assigned(BackRelations)){
		var BackRelationID = Connector.GenGUID();
		AddCommonRecord(Dataset, BackRelationID, DestinationID, 
			rtcBackRelationsGroup, rcBackRelationsGroup);
		for (var i = 0; i < BackRelations.Count; i++){
			Nodes = TranslateDestinationNodeToDataset(Dataset, 
				BackRelations.Items(i),	BackRelationID, TranslationType, Nodes);
		}
		if (TranslationType == gtEnumItems){
			if (!Dataset.Locate('ParentID', BackRelationID)){
				Dataset.Locate('ID', BackRelationID);
				Dataset.Delete();
			}
		}
	}
	var Columns = DestinationNode.FindChildNode(ColumnsNodeName);
	if (Assigned(Columns)){
		var Column;
		var DestinationSubNode;
		var IsPrimary;
		var ColumnID;
		var FieldName;
		var Field;
		var PostColumn;	
		var Caption;
		var DestinationSubNodeExist;
		var SubTableCode;
		var SubTableCaption;
		var Enum;
		var EnumItem;
		var ID;
		for (var i = 0; i < Columns.Count; i++){
			Column = Columns.Items(i);
			DestinationSubNode = Column.FindChildNode(DestinationNodeName);
			FieldName = Column.GetAttributeAsStr(NameAttributeName, false)
			Field = Table.Fields.ItemsByName(FieldName);
			IsPrimary = 
				Column.GetAttributeAsBool(IsPrimaryAttributeName, false);
			IsDefault = 
				Column.GetAttributeAsBool(IsDefaultAttributeName, false);
			IsEnum = (Field.SQLDataType == sdtEnum) && !IsDefault;
			PostIsPrimary = IsPrimary && (TranslationType == gtPrimaryKeys);	
			PostIsDefault = IsDefault && (TranslationType == gtDefaultValues);
			PostIsEnum = IsEnum && (TranslationType == gtEnumItems);
			PostColumn = PostIsPrimary || PostIsDefault || PostIsEnum;
			DestinationSubNodeExist = Assigned(DestinationSubNode);
			if (!DestinationSubNodeExist && !PostColumn) {
				continue;
			}
			ColumnID = Connector.GenGUID();
			if (DestinationSubNodeExist){
				SubTableCode = 
					DestinationSubNode.GetAttributeAsStr(NameAttributeName, '');
				if (!SubTableCode) {
					Caption = Field.Caption;
				} else {
					SubTableCaption = 
						Services.GetSingleItemByUSI(SubTableCode).Caption;
					Caption = FormatStr(rcForeignKeyColumn, SubTableCaption, 
						Field.Caption);
				}
			}else {
				Caption = Field.Caption;
			}
			if (PostIsPrimary){
				AddPrimaryKeyRecord(Dataset, ColumnID, DestinationID, Caption,
					DestinationSubNodeExist);
			} else if (PostIsDefault){
				AddDefaultValueRecord(Dataset, ColumnID, DestinationID, 
					Caption, DestinationSubNodeExist);
			} else if (PostIsEnum){
				AddEnumRecord(Dataset, ColumnID, DestinationID, Caption, 
					true, null);
				Enum = Field.Enum;
				if (Assigned(Enum)){
					for (var j = 0; j < Enum.Count; j++) {
						EnumItem = Enum.Items(j);
						ID = Connector.GenGUID();
						AddEnumRecord(Dataset, ID, ColumnID, 
							EnumItem.Caption, false, EnumItem.ID);
					}
				}				
			} else {
				AddCommonRecord(Dataset, ColumnID, DestinationID, rtcField, 
					Caption, DestinationSubNodeExist);
			}
			if (PostColumn){
				Nodes[ColumnID] = Column;
			}
			if (DestinationSubNodeExist) {
				Nodes = TranslateDestinationNodeToDataset(Dataset, 
					DestinationSubNode, ColumnID, TranslationType, Nodes, true);
				if (TranslationType == gtEnumItems){
					if (!Dataset.Locate('ParentID', ColumnID)){
						Dataset.Locate('ID', ColumnID);
						Dataset.Delete();
					}
				}
			}
		}
	}
	if ((TranslationType == gtEnumItems) && !Skip){
		if (!Dataset.Locate('ParentID', DestinationID)){
			Dataset.Locate('ID', DestinationID);
			Dataset.Delete();
		}
	}
	return Nodes;
}

function GetCanDragOverFromTablesTree(DataTreeGrid, DataGridColumn, RowIDs) {
	if (DataTreeGrid.Tag != 'TablesTree') {
		return false;
	}
	var Result = Assigned(DataGridColumn) && Assigned(DataGridColumn.DataField) 
		&& RowIDs.Count;
	if (Result){
		var Dataset = DataTreeGrid.DatasetLink.Dataset;
		DataTreeGrid.BeginUpdate();
		Dataset.DisableEvents();
		try {
			var OldID = Dataset.Values(mdfnID);
			for (var i = 0; i < RowIDs.Count; i++) {
			    Dataset.Locate(mdfnID, RowIDs.Items(i));
			    if (Dataset.Values(mdfnRecordTypeCode) != rtcField) {
			        Result = false;
			        break;
			    }
			}
		    Dataset.Locate(mdfnID, OldID);
		} finally {
			Dataset.EnableEvents();
			DataTreeGrid.EndUpdate();
		}	
	}
	return Result;
}

function AddColumnInfoToNode(TreeDataset, ImportItemNode, PathIDs, ParentNode){
	if (PathIDs.length == 0){
		return ParentNode;
	}
	var RowID = PathIDs.pop();
	TreeDataset.Locate(mdfnID, RowID);
	var Node;
	if (!Assigned(ParentNode)){
		Node = ImportItemNode.GetChildNode(DestinationNodeName);
		Node.SetAttributeAsStr(NameAttributeName, 
			TreeDataset.Values(mdfnTableCode), '');
	} else {
		var RecordType = TreeDataset.Values(mdfnRecordTypeCode);
		var TableCode;
		switch (RecordType){
			case rtcEmpty:
				Log.Write(lmtError, msgUnsupportedNodeType);
				return null;
				break;
			case rtcTable:
				TableCode = TreeDataset.Values(mdfnTableCode);
				if (ParentNode.Name == BackRelationsNodeName){
					Node = ParentNode.GetChildNodeByAttributeValue(
						DestinationNodeName, NameAttributeName, TableCode);
				} else {
					Node = ParentNode.GetChildNode(DestinationNodeName);
				}
				Node.SetAttributeAsStr(NameAttributeName, 
					TableCode, '');
				Node.SetAttributeAsStr(ForeignKeyFieldAttributeName, 
					TreeDataset.Values(mdfnFieldName), '');					
				break;
			case rtcField:
				ParentNode = ParentNode.GetChildNode(ColumnsNodeName);
				Node = ParentNode.GetChildNodeByAttributeValue(ItemNodeName, 
					NameAttributeName, TreeDataset.Values(mdfnFieldName));
				if (PathIDs.length != 0){
					Node = Node.GetChildNode(DestinationNodeName);
					var ChildID = PathIDs[PathIDs.length - 1];
					TreeDataset.Locate(mdfnID, ChildID);
					if (IsEmptyStr(Node.GetAttributeAsStr(NameAttributeName, ''))) {
						Node.SetAttributeAsStr(NameAttributeName, 
							TreeDataset.Values(mdfnTableCode), '');
					}
				}
				break;
			case rtcBackRelationsGroup:
				Node = ParentNode.GetChildNode(BackRelationsNodeName);
				break;
		}                    
	}
	return AddColumnInfoToNode(TreeDataset, ImportItemNode, PathIDs, Node);
}

function GetFieldPathIDs(TreeDataset, RowID, PathIDs){
	if (!Assigned(PathIDs)){
		PathIDs = new Array();
	}
	if (IsEmptyGUID(RowID)){
		return PathIDs;
	}
	PathIDs.push(RowID);
	if (TreeDataset.Locate(mdfnID, RowID)){
		var ParentID = TreeDataset.Values(mdfnParentID);
		PathIDs = GetFieldPathIDs(TreeDataset, ParentID, PathIDs);
	}
	return PathIDs;
}

function ClearColumnAttributes(Node){
	Node.SetAttributeAsInt(SourceNameAttributeName, -1, -1);
	Node.SetAttributeAsBool(IsPrimaryAttributeName, false, false);
	Node.SetAttributeAsBool(IsDefaultAttributeName, false, false);
	Node.SetAttributeAsInt(TypeAttributeName, -1, -1);
	Node.SetAttributeAsStr(ValueAttributeName, '', '');
	var EnumNode = Node.FindChildNode(EnumNodeName);
	if (Assigned(EnumNode)){
		Node.RemoveChildNode(EnumNode);
	}
}

function GetTableFieldByColumnNode(Node){
	var DestinationNode = Node.ParentNode.ParentNode;
	var TableCode = DestinationNode.GetAttributeAsStr(NameAttributeName, '');
	var Table = Services.GetSingleItemByUSI(TableCode);
	if (!Assigned(Table)){
		return null;
	}
	var FieldName = Node.GetAttributeAsStr(NameAttributeName, '');					
	return Table.Fields.ItemsByName(FieldName);
}

function GetTableFieldTypeByColumnNode(Node){
	var Type = -1;
	var Field = GetTableFieldByColumnNode(Node);
	if (Assigned(Field)){
		Type = Field.SQLDataType;
	}
	return Type;
}

function GetIsPrimaryKeysExists(Columns){
	var Column;
	var Exists = false;
	for (var i = 0; i < Columns.Count ; i++) {
		Column = Columns.Items(i);
		Exists = Column.GetAttributeAsBool(IsPrimaryAttributeName, false);
		if (Exists){
			break;
		}
	}
	return Exists;
}

function CheckRequiredFieldInDestination(Node, ResultArray){
	var BackRelations = Node.FindChildNode(BackRelationsNodeName);
	if (Assigned(BackRelations)){
		for (var i = 0; i < BackRelations.Count; i++){
			 CheckRequiredFieldInDestination(BackRelations.Items(i), 
			 	ResultArray);
		}
	}	
	var Columns = Node.FindChildNode(ColumnsNodeName);
	var NotAssignedFields = new Array();	
	if (Assigned(Columns)){
		var PrimaryKeysExists = GetIsPrimaryKeysExists(Columns);
		if (PrimaryKeysExists){
			var TableCode = Node.GetAttributeAsStr(NameAttributeName, '');
			var Table = Services.GetSingleItemByUSI(TableCode);
			var Fields = Table.Fields;
			var Field;
			var Column;
			for (var i = 0; i < Fields.Count ; i++) {
				Field = Fields.Items(i);
				if (Field.IsRequired && (Field.SQLName != 'ID')){
					Column = Columns.FindChildNodeByAttributeValue(ItemNodeName,
						NameAttributeName, Field.SQLName);
					if (!Assigned(Column)){
						NotAssignedFields.push(Field.SQLName);
					}
				}
			}
		}
		var DestinationNode;
		for (var i = 0; i < Columns.Count ; i++) {
			Column = Columns.Items(i);
			DestinationNode = Column.FindChildNode(DestinationNodeName);
			if (Assigned(DestinationNode)){
				CheckRequiredFieldInDestination(DestinationNode, ResultArray);
			}
		}
	}
	if (NotAssignedFields.length > 0){
		NotAssignedFields.Node = Columns;
		ResultArray.push(NotAssignedFields);
	}
}

function CheckRequiredFieldInDataflow(XMLStorage){
	var FullResult = new Array();
	var ItemsNode = XMLStorage.RootNode.GetChildNode(ItemsNodeName);
	var Item;
	var ItemResult;		
	for (var i = 0; i < ItemsNode.Count; i++) {
		Item = ItemsNode.Items(i).GetChildNode(DestinationNodeName);
		ItemResult = new Array();
		CheckRequiredFieldInDestination(Item, ItemResult);
		if (ItemResult.length > 0){
			ItemResult.Node = Item;
			FullResult.push(ItemResult);
		}
	}
	return FullResult;
}

function GetDataFieldByTableField(DataFields, TableField){
	var DataField;
	switch (TableField.SQLDataType){
		case sdtInteger:
			DataField = DataFields.CreateIntegerDataField();
			break;
		case sdtFloat:
			DataField = DataFields.CreateFloatDataField();
			DataField.Size = TableField.SQLSize;
			DataField.Precision = TableField.SQLPrecision;
			break;
		case sdtString:
		case sdtUnicodeString:
			DataField = DataFields.CreateStringDataField();
			DataField.TextLength = TableField.SQLSize;
			break;
		case sdtBlob:
			DataField = DataFields.CreateStringDataField();
			DataField.TextLength = 10000;			
			break;
		case sdtDateTime:
			DataField = DataFields.CreateDateTimeDataField();
			break;
		case sdtBoolean:
			DataField = DataFields.CreateBoolDataField();
			break;
		case sdtGUID:                                      
		case sdtEnum:	
			DataField = DataFields.CreateStringDataField();
			break;
	}
	return DataField;
}

function BuildMemoryDatasetByDestinationNode(DestinationNode, MemoryDataset){
	if (!Assigned(MemoryDataset)){
		MemoryDataset = Services.CreateItem('MemoryDataset');
	}
	var TableName = DestinationNode.GetAttributeAsStr(NameAttributeName, '');
	if (IsEmptyValue(TableName)){
		return MemoryDataset;
	}
	var Table = Services.GetSingleItemByUSI(TableName);	
	var BackRelations = DestinationNode.FindChildNode(BackRelationsNodeName);
	if (Assigned(BackRelations)){
		for (var i = 0; i < BackRelations.Count; i++){
			MemoryDataset = BuildMemoryDatasetByDestinationNode(
				BackRelations.Items(i), MemoryDataset);
		}
	}					
	var Columns = DestinationNode.FindChildNode(ColumnsNodeName);
	if (Assigned(Columns)){
		var Column;
		var DestinationSubNode;
		var SourceName;
		var FieldName;
		var Field;
		var TableFieldName;
		var TableField;
		var FieldsCounter;
		var DataFields = MemoryDataset.DataFields;
		for (var i = 0; i < Columns.Count; i++){
			Column = Columns.Items(i);
			DestinationSubNode = Column.FindChildNode(DestinationNodeName);
			if (Assigned(DestinationSubNode)){
				MemoryDataset = BuildMemoryDatasetByDestinationNode(
					DestinationSubNode, MemoryDataset);
			}
			SourceName = Column.GetAttributeAsStr(SourceNameAttributeName, '');
			if (SourceName == ''){
				continue;
			}
		 	TableFieldName = Column.GetAttributeAsStr(NameAttributeName, false);
			TableField = Table.Fields.ItemsByName(TableFieldName);			
			FieldsCounter = MemoryDataset.Attributes('FieldsCounter') * 1;
			FieldsCounter++;
			MemoryDataset.Attributes('FieldsCounter') = FieldsCounter;
			FieldName = 'Field_' + FieldsCounter;
			Column.SetAttributeAsStr(
				TempFieldNameAttributeName, FieldName, '');
			Field = GetDataFieldByTableField(DataFields, TableField);
			Field.GroupName = SourceName;
			Field.Name = FieldName;
			DataFields.Add(Field);
		}
	}
	return MemoryDataset;
}

function GetEnumInfoFromColumn(Column, ColumnObject, Field){
	ColumnObject.EnumDictionary = new Object();
	var Enum = Field.Enum;
	if (!Assigned(Enum)){
		return;
	}
	var EnumItem;		
	var EnumItemNode;
	var EnumItemID;
	var Value;
	var ValueArray;	
	var EnumNode = Column.GetChildNode(EnumNodeName);
	for (var i = 0; i < EnumNode.Count; i++) {
		EnumItemNode = EnumNode.Items(i);
		EnumItemID = EnumItemNode.GetAttributeAsStr(IDAttributeName, '');
		EnumItem = Enum.ItemsByID(EnumItemID);
		if (!Assigned(EnumItem)){
			continue;
		}
		Value = EnumItemNode.GetAttributeAsStr(ValueAttributeName, '');
		ValueArray = Value.split(EnumItemValueDelimiter);
		for (var j = 0; j < ValueArray.length; j++) {
			ColumnObject.EnumDictionary[ValueArray[j].toUpperCase()] = EnumItemID;
		}
	}
}

function GetDefaultInfoFromColumn(Column, ColumnObject, Field){
	ColumnObject.DefaultType = 
		Column.GetAttributeAsInt(TypeAttributeName, -1);
	ColumnObject.DefaultIsCorrect = true;	
	var Value;
	switch (String(ColumnObject.DefaultType)) {
		case dvtValue:
			break;		
		case dvtFunction:
			ColumnObject.DefaultValue = Column.GetAttributeAsInt(
				ValueAttributeName, -1);
			ColumnObject.DefaultIsCorrect = (ColumnObject.DefaultValue > 0);
			return;
			break;
		default:
			ColumnObject.DefaultIsCorrect = false;
			return;				
	}
	switch(Field.SQLDataType){
		case sdtInteger:
			ColumnObject.DefaultValue = Column.GetAttributeAsInt(
				ValueAttributeName, 0);	
			break;
		case sdtFloat:
			ColumnObject.DefaultValue = Column.GetAttributeAsFloat(
				ValueAttributeName, 0);	
			break;
		case sdtBlob:
		case sdtString:
		case sdtUnicodeString:
		case sdtGUID:		
		case sdtEnum:
			ColumnObject.DefaultValue = Column.GetAttributeAsStr(
				ValueAttributeName, '');	
			break;
		case sdtDateTime:
			ColumnObject.DefaultValue = Column.GetAttributeAsDateTime(
				ValueAttributeName, 0);	
			break;
		case sdtBoolean:
			ColumnObject.DefaultValue = Column.GetAttributeAsBool(
				ValueAttributeName, false);	
			break;
		default:
			ColumnObject.DefaultIsCorrect = false;
			break;		
	}
}


function GetImportObjectByNode(Destination, Dataset, ImportObjects, UpdateRecords){
	var ImportProgressObject = Connector.Attributes('ImportProgressObject');
	var ImportObject = new Object();
	ImportObject.Updated = 0;
	ImportObject.Inserted = 0;
	ImportObject.PrimaryKeys = new Array();
	ImportObject.PrimaryKeysIndexes = new Array();
	ImportObject.DefaultValues = new Array();
	ImportObject.MappedColumns = new Array();
	ImportObject.Records = new Object();
	ImportObject.ErrorList = new Array();
	Destination.SetAttributeAsInt(TempIndexAttributeName, ImportObjects.length,
		-1);	
	ImportObject.ImportObjects = ImportObjects;
	ImportObjects.push(ImportObject);
	var ForeignKeyFieldName = 
		Destination.GetAttributeAsStr(ForeignKeyFieldAttributeName, '');		
	ImportObject.ForeignKeyFieldName = ForeignKeyFieldName;
	if (!IsEmptyStr(ForeignKeyFieldName)){
		var ForeignKeyNode = Destination.ParentNode.ParentNode;
		ImportObject.ForeignKeyIndex = 
			ForeignKeyNode.GetAttributeAsInt(TempIndexAttributeName, -1);
		ImportObject.ForeignKeyObject = 
			ImportObject.ImportObjects[ImportObject.ForeignKeyIndex];			
	}
	var TableName = Destination.GetAttributeAsStr(NameAttributeName, '');
	if (IsEmptyValue(TableName)){
		return ImportObject;
	}
	ImportObject.TableName = TableName;
	var Table = Services.GetSingleItemByUSI(TableName);
	var Columns = Destination.FindChildNode(ColumnsNodeName);
	if (!Assigned(Columns)){
		return ImportObject;
	}
	ImportObject.Table = Table;
	var Column;
	var DestinationSubNode;
	var TempIndex;
	var ColumnObject;
	var SourceName;
	var FieldName;
	var Field;
	var DataFieldName;
	var DataField;
	for (var i = 0; i < Columns.Count; i++){
		Column = Columns.Items(i);
		DestinationSubNode = Column.FindChildNode(DestinationNodeName);
		ColumnObject = new Object();
		SourceName = Column.GetAttributeAsStr(SourceNameAttributeName, '');
		FieldName = Column.GetAttributeAsStr(NameAttributeName, false)
		Field = Table.Fields.ItemsByName(FieldName);
		ColumnObject.Field = Field;
		ColumnObject.IsLookup = false;
		if (Assigned(DestinationSubNode)){
			ImportObjects = ImportDataByDestinationNode(
				DestinationSubNode, Dataset, ImportObjects, UpdateRecords);
			if (Assigned(ImportProgressObject) && 
				ImportProgressObject.CancelledByUser){
				return;
			}		
			if (SourceName != ''){
				ColumnObject.Index = DestinationSubNode.
					GetAttributeAsInt(TempIndexAttributeName, -1);
				ColumnObject.IsLookup = true;
				if ((ColumnObject.Index == -1)){
					ImportObject.ErrorList.push(FormatStr(
						msgLookupIsNotDefined, ColumnObject.Field.Caption))
				} else if (!(ImportObjects[ColumnObject.Index].Imported)){
					ImportObject.ErrorList.push(FormatStr(
						msgLookupWasNotImported, ColumnObject.Field.Caption));
				}
			}
		}
		if (SourceName == ''){
			ColumnObject.IsDefault = 
				Column.GetAttributeAsBool(IsDefaultAttributeName, false);	
			if (!ColumnObject.IsDefault){
				continue;
			}
			GetDefaultInfoFromColumn(Column, ColumnObject, Field);
			if (ColumnObject.DefaultIsCorrect){
				ImportObject.DefaultValues.push(ColumnObject);
				continue;
			} else {
				ImportObject.ErrorList.push(FormatStr(
					msgWrangDEfaultValue, ColumnObject.Field.Caption))	
			}
		} else {
			if (ColumnObject.IsLookup && (ColumnObject.Index == -1)){
				continue;
			}
			ColumnObject.SourceName  = SourceName;
			ColumnObject.IsPrimary = 
				Column.GetAttributeAsBool(IsPrimaryAttributeName, false);
			ColumnObject.IsEnum = (Field.SQLDataType == sdtEnum);
			DataFieldName = Column.GetAttributeAsStr(
				TempFieldNameAttributeName, '');
			DataField = Dataset.DataFields(DataFieldName);
			if (!Assigned(DataField)){
				ImportObject.ErrorList.push(FormatStr(
					msgDatafieldIsNotDefined, ColumnObject.Field.Caption));
				continue;				
			}
			ColumnObject.DataField = DataField;
			ColumnObject.FieldName = FieldName;
			if (ColumnObject.IsPrimary){
				ImportObject.PrimaryKeys.push(FieldName);
				ImportObject.PrimaryKeysIndexes.push(
					ImportObject.MappedColumns.length);
			}
			if (ColumnObject.IsEnum){
				GetEnumInfoFromColumn(Column, ColumnObject, Field);
			}
			ColumnObject.IsDefault = 
				Column.GetAttributeAsBool(IsDefaultAttributeName, false);	
			if (ColumnObject.IsDefault){
				GetDefaultInfoFromColumn(Column, ColumnObject, Field);
			}
		}
		ImportObject.MappedColumns.push(ColumnObject);
	}
	return ImportObject;
}

function GetPrimaryKeysStringForObject(Dataset, ImportObject){
	var Column;
	var Result = new Object();
	Result.Value = '';
	Result.DisplayValue = '';
	for (var i = 0; i < ImportObject.PrimaryKeys.length; i++){
		Column = ImportObject.MappedColumns[ImportObject.PrimaryKeysIndexes[i]];
		if (i > 0){
			Result.Value = Result.Value + '_';
			Result.DisplayValue = Result.DisplayValue + '  ';
		}
		Result.Value = Result.Value + Column.DataField.Value;
		Result.DisplayValue = Result.DisplayValue + FormatStr('%1 = %2', 
			Column.Field.Caption, Column.DataField.Value);
	}
	return Result;
}

function GetRecordID(ImportObject, Dataset){
	var PrimaryKeys = GetPrimaryKeysStringForObject(Dataset, ImportObject);
	var ID = ImportObject.Records[PrimaryKeys.Value];
	if (IsEmptyGUID(ID)){
		ID = null;
	}
	return ID;
}

function GetValueForColumn(ImportObjects, Column, Dataset){
	if (Column.IsLookup){
		var LookupObject = ImportObjects[Column.Index];
		return GetRecordID(LookupObject, Dataset);
	} else if (Column.IsEnum){
		return Column.EnumDictionary[Column.DataField.Value.toUpperCase()];
	} else {
		return Column.DataField.Value;
	}		
}

function ImportPreventEditingHandler(Message, IsHandled) {
	DataflowUtils.ImportErrorMessage = Message;
	IsHandled.Value = true;
}

function ImportRecord(Dataset, ImportObject, UpdateRecords){
	var PrimaryKeys = 
		GetPrimaryKeysStringForObject(Dataset, ImportObject);
	WriteMessageToFile(lmtInformation, FormatStr(msgImportRecord, 
		PrimaryKeys.DisplayValue));
	var ID = ImportObject.Records[PrimaryKeys.Value];
	if (!IsEmptyValue(ID)){
		WriteMessageToFile(lmtInformation, msgRecordIsAlreadyImported);
		return;
	}
	var ColumnObject;
	var PrimaryKeyValue;
	var Parameters = ImportObject.SelectQuery.Parameters;
	var ImportObjects = ImportObject.ImportObjects;
	for (var i = 0; i < ImportObject.PrimaryKeys.length; i++){
		ColumnObject =
			ImportObject.MappedColumns[ImportObject.PrimaryKeysIndexes[i]]
		PrimaryKeyValue = ColumnObject.DataField.Value;
		if (IsEmptyValue(PrimaryKeyValue)){
			var Message = FormatStr(msgPrimaryKeyIsEmptySkip,
				ColumnObject.Field.Caption);
			WriteMessageToFile(lmtError, Message);
			ImportObject.ErrorList.push(Message);
			return false;
		}
		Parameters(ImportObject.PrimaryKeys[i]).Value = 
			GetValueForColumn(ImportObjects, ColumnObject, Dataset);
	}
	if (Assigned(ImportObject.Dataset)){
		ImportObject.Dataset.Close();
		ImportObject.Dataset.Open();
	} else {
		ImportObject.Dataset = ImportObject.SelectQuery.Open();
	}
	var CustomPreventEditingHandlerOld = Connector.Attributes('CustomPreventEditingHandler');
	var IsShowCustomPreventEditingMessageOld = Connector.Attributes('IsShowCustomPreventEditingMessage');

	if ((ImportObject.Dataset.IsEmptyPage) || (!UpdateRecords)){
		ID = Connector.GenGUID();
		ImportObject.InsertQueryIDParam.Value = ID;
		for (var i = 0; i < ImportObject.MappedColumns.length; i++) {
			ColumnObject = ImportObject.MappedColumns[i];
			if (ColumnObject.Field.SQLDataType == sdtBlob){
				ColumnObject.InsertParam.ValAsRTF = System.DecodeText(
					GetValueForColumn(ImportObjects, ColumnObject, Dataset),
					'windows-1252');
			} else {
				ColumnObject.InsertParam.Value = 
					GetValueForColumn(ImportObjects, ColumnObject, Dataset);
				if (!ColumnObject.InsertParam.Value) {
					if (ColumnObject.IsDefault) {
						ColumnObject.InsertParam.Value = ColumnObject.DefaultValue;
					}					
				}
			}			
		}
		if (Assigned(ImportObject.ForeignKeyInsertParam)){		
			ImportObject.ForeignKeyInsertParam.Value = 
				GetRecordID(ImportObject.ForeignKeyObject, Dataset);			
		}
		try {
			Connector.Attributes('CustomPreventEditingHandler') = ImportPreventEditingHandler;
			Connector.Attributes('IsShowCustomPreventEditingMessage') = true;
			try {
				DataflowUtils.ImportErrorMessage = '';
				ImportObject.InsertQuery.Execute();
				if (IsEmptyValue(DataflowUtils.ImportErrorMessage)) {
					ImportObject.Inserted++;
					WriteMessageToFile(lmtInformation, msgInsertRecord);
				} else {
					WriteMessageToFile(lmtError, DataflowUtils.ImportErrorMessage);
					ImportObject.ErrorList.push(DataflowUtils.ImportErrorMessage);
				}
			} catch (e) {
				WriteMessageToFile(lmtError, e.message);
				ImportObject.ErrorList.push(e.message);
			}
		} finally {
			Connector.Attributes('CustomPreventEditingHandler') = CustomPreventEditingHandlerOld;
			Connector.Attributes('IsShowCustomPreventEditingMessage') = IsShowCustomPreventEditingMessageOld;
		}
	} else {
		ID = ImportObject.Dataset.Values('ID');
		if (ImportObject.CanUpdate){
			for (var i = 0; i < ImportObject.MappedColumns.length; i++) {
				ColumnObject = ImportObject.MappedColumns[i];
				if (ColumnObject.IsPrimary){
					continue;
				}
				if (ColumnObject.Field.SQLDataType == sdtBlob){
					ColumnObject.UpdateParam.ValAsRTF = 
						GetValueForColumn(ImportObjects, ColumnObject, Dataset);
				} else {
					ColumnObject.UpdateParam.Value = 
						GetValueForColumn(ImportObjects, ColumnObject, Dataset);
				}							
			}
			ImportObject.UpdateQueryIDParam.Value = ID;
			if (Assigned(ImportObject.ForeignKeyUpdateParam)){
				ImportObject.ForeignKeyUpdateParam.Value = 
					GetRecordID(ImportObject.ForeignKeyObject, Dataset);			
			}
			try {
				Connector.Attributes('CustomPreventEditingHandler') = ImportPreventEditingHandler;
				Connector.Attributes('IsShowCustomPreventEditingMessage') = true;
				try {
					DataflowUtils.ImportErrorMessage = '';
					ImportObject.UpdateQuery.Execute();
					if (IsEmptyValue(DataflowUtils.ImportErrorMessage)) {
						ImportObject.Updated++;
						WriteMessageToFile(lmtInformation, msgUpdateRecord);
					} else {
						WriteMessageToFile(lmtError, DataflowUtils.ImportErrorMessage);
						ImportObject.ErrorList.push(DataflowUtils.ImportErrorMessage);
					}
				} catch (e) {
					WriteMessageToFile(lmtError, e.message);
					ImportObject.ErrorList.push(e.message);
				}
			} finally {
				Connector.Attributes('CustomPreventEditingHandler') = CustomPreventEditingHandlerOld;
				Connector.Attributes('IsShowCustomPreventEditingMessage') = IsShowCustomPreventEditingMessageOld;
			}
		} else {
			WriteMessageToFile(lmtInformation, msgUpdateRecordIsNotNeed);
		}
	}
	ImportObject.Records[PrimaryKeys.Value] = ID;	
}

function ImportDataByImportObject(Dataset, ImportObject, UpdateRecords){
	if (!Assigned(ImportObject.Table)){
		WriteMessageToFile(lmtError, msgTableIsNotAssigned);	
		ImportObject.ErrorList.push(msgTableIsNotAssigned);
		return;
	}
	var ImportProgressObject = Connector.Attributes('ImportProgressObject');
	var ImportProgressObjectAssigned = Assigned(ImportProgressObject);
	var Prompt;
	var PromptCaption;
	if (ImportProgressObjectAssigned){
		ImportProgressObject.TablesBar.Position++;
		ImportProgressObject.RecordsBar.Position = 0;
		Prompt = ImportProgressObject.Prompt;
		PromptCaption = Prompt.Caption;
		Prompt.Caption = PromptCaption + 
			' (' + ImportObject.Table.Caption + ')';
	}
	try {
		ImportObject.Imported = false;
		WriteMessageToFile(lmtInformation, FormatStr(msgImportDataToTable, 
			ImportObject.Table.Caption));	
		if (ImportObject.PrimaryKeys.length == 0){
			WriteMessageToFile(lmtInformation, msgPrimaryKeysDoesntExistsSkip);	
			ImportObject.ErrorList.push(msgPrimaryKeysDoesntExistsSkip);
			return;
		}
		var ErrorList = ImportObject.ErrorList;
		if (ErrorList.length > 0){
			for (var i = 0; i < ErrorList.length; i++){
				WriteMessageToFile(lmtError, ErrorList[i]);
			}
			WriteMessageToFile(lmtError, msgCantImportTableSkip);
			ImportObject.ErrorList.push(msgCantImportTableSkip);
			return;
		}
		ImportObject.SelectQuery = scr_DB.CreateSelectQueryByTable(
			ImportObject.Table, null, ImportObject.PrimaryKeys, 
			null, null, -1,	false);
		InitRecordInsertQuery(ImportObject);
		InitRecordUpdateQuery(ImportObject)
		Dataset.GoToFirst();
		while (!Dataset.IsEOF){		
			ImportRecord(Dataset, ImportObject, UpdateRecords);
			System.ProcessMessages();
			if (Assigned(ImportProgressObject)){
				if (ImportProgressObject.CancelledByUser){
					return;
				} else {
					ImportProgressObject.RecordsBar.Position++;
				}
			}
			Dataset.GoToNext();
		}
		WriteMessageToFile(lmtInformation, FormatStr(msgImportDataToTableFinished, 
			ImportObject.Table.Caption, ImportObject.Inserted, 
			ImportObject.Updated));	
		ImportObject.Imported = true;
	} finally {
		if (ImportProgressObjectAssigned){
			Prompt.Caption = PromptCaption;
		}	
	}
}

function ImportDataByDestinationNode(Destination, Dataset, ImportObjects, UpdateRecords){
	var ImportProgressObject = Connector.Attributes('ImportProgressObject');
	if (!Assigned(ImportObjects)){
		ImportObjects = new Array();
	}	
	var ImportObject = 
		GetImportObjectByNode(Destination, Dataset, ImportObjects, UpdateRecords);
	if (Assigned(ImportProgressObject) && 
		ImportProgressObject.CancelledByUser){
		return;
	}							
	ImportDataByImportObject(Dataset, ImportObject, UpdateRecords);
	if (Assigned(ImportProgressObject) && 
		ImportProgressObject.CancelledByUser){
		return;
	}					
	var BackRelations = Destination.FindChildNode(BackRelationsNodeName);
	if (Assigned(BackRelations)){
		for (var i = 0; i < BackRelations.Count; i++){
			ImportObjects = ImportDataByDestinationNode(BackRelations.Items(i), 
				Dataset, ImportObjects, UpdateRecords);
			if (Assigned(ImportProgressObject) && 
				ImportProgressObject.CancelledByUser){
				return;
			}				
		}	
	}
	return ImportObjects;
}

function InitRecordInsertQuery(ImportObject) {
	ImportObject.InsertQuery = Services.CreateItem('InsertQuery');
	ImportObject.InsertQuery.Table = ImportObject.Table;
	var ColumnsValues = ImportObject.InsertQuery.ColumnsValues;
	var Field;
	var Column;
	for (var i = 0; i < ImportObject.MappedColumns.length; i++) {
		Column = ImportObject.MappedColumns[i];
		Field = Column.Field;
		Column.InsertParam = CreateParam(ColumnsValues, Field.SQLName, 
			GetParameterTypeBySQLDataType(Field.SQLDataType));
		if (Column.InsertParam.DataType == dftDateTime) {
			Column.InsertParam.DateTimeKind = Field.DateTimeKind;
		}
	}
	for (var i = 0; i < ImportObject.DefaultValues.length; i++) {
		Column = ImportObject.DefaultValues[i];
		if (!Column.DefaultIsCorrect){
			continue;
		}
		Field = Column.Field;
		if (String(Column.DefaultType) == dvtValue){
			Column.InsertParam = CreateParam(ColumnsValues, Field.SQLName, 
				GetParameterTypeBySQLDataType(Field.SQLDataType));
		} else {
			Column.InsertParam = CreateParam(ColumnsValues, Field.SQLName, 
				pdtFunction);
		}
		if (Column.Field.SQLDataType == sdtBlob){
			Column.InsertParam.ValAsRTF = Column.DefaultValue;
		} else {
			Column.InsertParam.Value = Column.DefaultValue;
		}
	}
	ImportObject.InsertQueryIDParam = CreateParam(ColumnsValues, 'ID', 
		sdtIdentity);
	var ForeignKey = ImportObject.ForeignKeyFieldName;
	if (IsEmptyStr(ForeignKey)){
		return;
	}
	if (!Assigned(ImportObject.ForeignKeyObject) ){
		return;
	}
	if (!ImportObject.ForeignKeyObject.Imported){
		return;
	}
	if (Assigned(ColumnsValues(ForeignKey))){
		return;
	}
	ImportObject.ForeignKeyInsertParam = CreateParam(ColumnsValues, ForeignKey, 
			pdtGUID);
}

function InitRecordUpdateQuery(ImportObject) {
	ImportObject.UpdateQuery = Services.CreateItem('UpdateQuery');
	ImportObject.UpdateQuery.Table = ImportObject.Table;
	var ColumnsValues = ImportObject.UpdateQuery.ColumnsValues;
	var Parameters = ImportObject.UpdateQuery.Parameters;
	var Field;
	var Column;
	for (var i = 0; i < ImportObject.MappedColumns.length; i++) {
		Column = ImportObject.MappedColumns[i];
		if (Column.IsPrimary){
			continue;
		}		
		Field = Column.Field;
		Column.UpdateParam = CreateParam(ColumnsValues, Field.SQLName, 
			GetParameterTypeBySQLDataType(Field.SQLDataType));
	}
	for (var i = 0; i < ImportObject.DefaultValues.length; i++) {
		Column = ImportObject.DefaultValues[i];
		if (!Column.DefaultIsCorrect){
			continue;
		}
		Field = Column.Field;
		if (String(Column.DefaultType) == dvtValue){
			Column.UpdateParam = CreateParam(ColumnsValues, Field.SQLName, 
				GetParameterTypeBySQLDataType(Field.SQLDataType));			
		} else {
			Column.UpdateParam = CreateParam(ColumnsValues, Field.SQLName, 
				pdtFunction);
		}
		if (Column.Field.SQLDataType == sdtBlob){
			Column.UpdateParam.ValAsRTF = Column.DefaultValue;
		} else {
			Column.UpdateParam.Value = Column.DefaultValue;
		}
	}
	ImportObject.UpdateQueryIDParam = CreateParam(Parameters, 'ID',
		pdtIdentity);
	AddFieldParamCompareFilter(ImportObject.UpdateQuery.Filters, 
		ImportObject.Table.Fields('ID'), ImportObject.Table.SQLName, 
		ImportObject.UpdateQueryIDParam, cotEqual);
	ImportObject.CanUpdate = (ColumnsValues.Count > 0)
	var ForeignKey = ImportObject.ForeignKeyFieldName;
	if (IsEmptyStr(ForeignKey)){
		return;
	}
	if (!Assigned(ImportObject.ForeignKeyObject) ){
		return;
	}
	if (!ImportObject.ForeignKeyObject.Imported){
		return;
	}
	if (Assigned(ColumnsValues(ForeignKey))){
		return;
	}
	for (var i = 0; i < ImportObject.PrimaryKeys.length; i++){
		if (ImportObject.PrimaryKeys[i] == ForeignKey){
			return;
		}
	}
	ImportObject.ForeignKeyUpdateParam = CreateParam(ColumnsValues, ForeignKey, 
			pdtGUID);		
	ImportObject.CanUpdate = true;
}

function GetImportXMLStorage(ImportID) {
	var DataflowXMLDataset = 
		GetSingleItemByCode('ds_DataflowXMLData', 'DataflowsGridArea');
    ApplyDatasetIDFilter(DataflowXMLDataset, ImportID, true);
    var XMLStorage;
    DataflowXMLDataset.Open();
    if (DataflowXMLDataset.IsEmptyPage){
    	return null;
	}
    try {
	    XMLStorage = GetNewXMLStorage();
	    XMLStorage.LoadFromDataset(DataflowXMLDataset, 'XMLData');
	} finally {
		DataflowXMLDataset.Close();
	}
    return XMLStorage;
}

function ShowDataflowTuning(RecordID, Dictionary){
	if (!Assigned(Dictionary)){
		Dictionary = GetNewDictionary();
	}
    Dictionary('RecordID') = RecordID;
    ShowEditWindowEx('wnd_DataflowTuning', Dictionary, null, false, true);
}

function ExpandTreeGridAndLocateToRootNode(TreeGrid){
	TreeGrid.ExpandAll();
	TreeGrid.DatasetLink.Dataset.Locate(TreeGrid.ParentDatafieldName, null);
}

function GetTuningItemsByPageName(Window){
	var TuningItemsByPageName = Window.Attributes('TuningItemsByPageName');
	if (!Assigned(TuningItemsByPageName)){
		TuningItemsByPageName = GetNewDictionary();
		Window.Attributes('TuningItemsByPageName') = TuningItemsByPageName;
	}
	return TuningItemsByPageName;
}

function WriteMessageToFile(MessageType, Message){
	var LogFile = DataflowUtils.ImportLogFile;
	if (!Assigned(LogFile)){
		return;
	}
	switch (MessageType){
		case lmtError :
			LogFile.WriteLine(ErrorDelimiter);
			LogFile.Write(ErrorIndent);
			break;
		case lmtWarning :
			LogFile.Write(WarningIndent);
			break;			
		case lmtInformation :
			LogFile.Write(InformationIndent);
			break;						
	}
	LogFile.WriteLine(Message);
	switch (MessageType){
		case lmtError :
			LogFile.WriteLine(ErrorDelimiter);
			break;
	}	
}

function PromptToOpenTemplate(FileName) {
	var Message = "Открыть сохраненный файл шаблона импорта?";
	if (ShowConfirmationDialog(Message) != mrYes) {
		return false;
	}
	var IsOpenedSuccessfully = System.OpenFile(FileName, fatReadWrite);
	if (!IsOpenedSuccessfully) {
		var Message = FormatStr("Ошибка открытия файла %1", FileName);
		ShowWarningDialog(Message);
		return false;
	}
	return true;
}

function GetColumnsToNodeMapping(Node, Mapping){
	if (!Assigned(Mapping)){
		Mapping = new Object();
	}
	var ChildNode;
	var ColumnsNode = Node.FindChildNode(ColumnsNodeName);
	if (Assigned(ColumnsNode)){
		for (var i = 0; i < ColumnsNode.Count; i++){
			ChildNode = ColumnsNode.Items(i);
			SourceName = ChildNode.GetAttributeAsInt(SourceNameAttributeName, -1);
			if (SourceName > 0){
				ColumnMapping = Mapping['Column' + SourceName];
				if (!Assigned(ColumnMapping)){
					ColumnMapping = new Array();
					Mapping['Column' + SourceName] = ColumnMapping;
				}
				ColumnMapping.push(ChildNode);
			}
			var DestinationNode = ChildNode.FindChildNode(DestinationNodeName);
			if (Assigned(DestinationNode)){
				Mapping = GetColumnsToNodeMapping(DestinationNode, Mapping)
			}
		}	
	}
	var BackRelationsNode = Node.FindChildNode(BackRelationsNodeName);
	if (Assigned(BackRelationsNode)){
		for (var i = 0; i < BackRelationsNode.Count; i++){
			ChildNode = BackRelationsNode.Items(i);
			Mapping = GetColumnsToNodeMapping(ChildNode, Mapping)
		}		
	}
	return Mapping;
}

function GetSettingsNode(XMLStorage) {
	return XMLStorage.RootNode.GetChildNode(SettingsNodeName);
}

function GetXMLFileName(DataflowID) {
	return Connector.UserSettingsDirectory + 'Dataflow' + DataflowID + '.xml';
}

function GetXMLStorage(DataflowID) {
	var XMLStorage = GetNewXMLStorage();
	var IsUserXMLData = GetDatasetFieldValueByID('ds_Dataflow', 
		DataflowID, 'IsUserXMLData');
	if (IsUserXMLData) {
		var FileName = GetXMLFileName(DataflowID);
		if (CheckFileExists(FileName)) {
			XMLStorage.LoadFromFile(FileName);
		} else {
			ShowWarningDialog(
				FormatStr("Файл настроек интеграции не найден '%1'", FileName));
		}
	} else {	
		var Dataset = GetSingleItemByCode('ds_DataflowXMLData', 'LoadConnectParam');
		ApplyDatasetFilter(Dataset, 'ID', DataflowID, true);
		Dataset.Open();
		try {
			if (!IsDatasetEmpty(Dataset)) {
				XMLStorage.LoadFromDataset(Dataset, 'XMLData');
			}		
		} finally {
			Dataset.Close();
		}
	}
	XMLStorage.InitRootNode(DataflowNodeName);
	return XMLStorage;		
}

function BeginHistory(TypeID, DataflowID) {
	var Dataset = GetHistoryDataset();
	Dataset.Append();
	var ID = Connector.GenGUID();
	Dataset('ID') = ID;	
	Dataset('DataflowID') = Param.DataflowID;
	Dataset('BeginDate') = (new Date()).getVarDate();	
	Dataset.Post();
	return ID;
}

function EndHistory(ID, Message, Param) {
	var Dataset = GetHistoryDataset();
	ApplyDatasetFilter(Dataset, 'ID', ID, true);
	Dataset.Open();
	try {
		if (!IsDatasetEmpty(Dataset)) {
			Dataset.Edit();
			Dataset('EndDate') = (new Date()).getVarDate();	
			if (!IsEmptyValue(Param.InsertCount)) {
				Dataset('InsertCount') = Param.InsertCount;
			}
			if (!IsEmptyValue(Param.UpdateCount)) {
				Dataset('UpdateCount') = Param.UpdateCount;
			}
			Dataset('Message') = Message;
			Dataset('TypeID') = TypeID;			
			Dataset.Post();
		}
	} finally {
		Dataset.Close();
	}
	Dataset.Post();
}

function GetHistoryDataset() {
	var HistoryDataset = DataflowUtils.HistoryDataset;
	if (!Assigned(HistoryDataset)) {
		HistoryDataset = Services.GetNewItemByUSI('ds_DataflowHistory');
		DataflowUtils.HistoryDataset = HistoryDataset;
		HistoryDataset.DataFields('Details').IsEnabled = true;
		HistoryDataset.SelectQuery.Columns('Details').IsEnabled = true;
	}
	return HistoryDataset;
}

function WriteHistory(TypeID, Message, Param, BeginDate, FinishDate, IsMain,
	IsUpdate){
	var HistoryDataset = GetHistoryDataset();
	if (!IsUpdate || IsEmptyValue(Param.HistoryObjectID)) {
		HistoryDataset.Append();
	} else {
		ApplyDatasetIDFilter(HistoryDataset, Param.HistoryObjectID, true);
		HistoryDataset.Open()
		HistoryDataset.Edit();
		ApplyDatasetIDFilter(HistoryDataset, Param.HistoryObjectID, false);
	}
	if (!IsEmptyValue(Param.ObjectID)) {
		HistoryDataset('ObjectID') = Param.ObjectID;
	}
	if (!IsEmptyValue(Param.DataflowID)) {
		HistoryDataset('DataflowID') = Param.DataflowID;
	}
	if (!IsEmptyValue(Param.InsertCount)) {
		HistoryDataset('InsertCount') = Param.InsertCount;
	}
	if (!IsEmptyValue(Param.UpdateCount)) {
		HistoryDataset('UpdateCount') = Param.UpdateCount;
	}
	if (!IsEmptyValue(Param.HistoryObjectID)) {
		if (IsMain) {
			HistoryDataset('ID') = Param.HistoryObjectID;
			if (!IsEmptyValue(Param.ErrorCount)) {
				HistoryDataset('ErrorCount') = Param.ErrorCount;
			}			
		} else {
			HistoryDataset('ParentID') = Param.HistoryObjectID;
		}
	}
		
	if (!IsEmptyValue(BeginDate)) {
		HistoryDataset('BeginDate') = BeginDate;
	} else {
		HistoryDataset('BeginDate') = new Date().getVarDate();
	}
	
	if (!IsEmptyValue(FinishDate)) {
		HistoryDataset('FinishDate') = FinishDate;
	} else {
		HistoryDataset('FinishDate') = new Date().getVarDate();
	}	
	
	if (!IsEmptyValue(Param.LogFileName)) {
		SaveFileToDataset(Param.LogFileName, HistoryDataset, 'Details');
	}
	HistoryDataset('Message') = Message;
	HistoryDataset('TypeID') = TypeID;
	HistoryDataset.Post();
	HistoryDataset.Close();
}

function DeleteRecords(Dataset, Dictionary) {
	var Error;
	try {
		if (!Assigned(Dataset)) {
			if (!IsEmptyValue(Dataset) && Assigned(Services.InformationsByUSI(Dataset))) {
				Dataset = Services.GetNewItemByUSI(Dataset);
			} else {
				return;
			}
		}
		if ('DBDataset' == Dataset.ServiceTypeCode) {
			var Table = Dataset.SelectQuery.Items(0).FromTable;
		} else
		if ('Table' == Dataset.ServiceTypeCode) {
			var Table = Dataset;
		} else {
			return;
		}
		var dq = Services.CreateItem('DeleteQuery');
		dq.Table = Table;
		var TableFields = Table.Fields;
		var Filters = dq.Filters;
		var Parameters = dq.Parameters;
	
		var TableField;
		var FilterFieldType;
		var CompareOperatorType = cotEqual;
		var Parameter;
		
		var Keys = new VBArray(Dictionary.Keys()).toArray();
		var KeysLength = Keys.length;
		for (var i = 0; i < KeysLength; i++) {
		    TableField = TableFields.ItemsByName(Keys[i]);
			FilterFieldType = GetParameterTypeBySQLDataType(TableField.SQLDataType);
			Parameter = AddQueryParameter(Parameters, Keys[i],
				FilterFieldType, Dictionary(Keys[i]));
			AddQueryCompareFilter(Filters, Keys[i], TableField,
				Parameter, CompareOperatorType);
		}
		dq.Execute();
	} catch(e) {
		Error = e;
	}
	return Error;
}

function GetLeetersFromGUID(GUID) {
	GUID = new String(GUID);
	var re = new RegExp("[{}-]","ig"); 		
	return GUID.replace(re, '');
}

function GetDatasetFieldValueByFieldValue(DatasetUSI, FilterName, IDValue, FieldName) {
	if (Assigned(DatasetUSI)) {
		var Dataset = DatasetUSI;
	} else {
		var Dataset = GetSingleItemByCode(DatasetUSI, DatasetUSI + FieldName);
	}
	ApplyDatasetFilter(Dataset, FilterName, IDValue, true);
	var Enabled = false;
	for (var i = 0; i < Dataset.DataFields.Count; i++) {
		DataField = Dataset.DataFields.Items(i);
		Enabled = (DataField.Name == FieldName || DataField.Name == FilterName);
		EnableDatasetField(Dataset, DataField, Enabled);
	}
	Dataset.Open();
	var Result = Dataset(FieldName);
	Dataset.Close();
	ApplyDatasetIDFilter(Dataset, null, false);
	return Result;
}

function CreateSelectQueryByTable(Table, FilterFieldNameArray, Top) {
	var CreatedQuery = Services.CreateItem('SelectQuery');
	var Select = CreatedQuery.CreateItem();
	if (IsEmptyValue(Top)){
		Select.Top = -1;
	} else {
       Select.Top = Top;
	}
	CreatedQuery.Add(Select);
	Select.FromTable = Table;
	var TableFields = Table.Fields;
	var Filters = Select.Filters;
	var Parameters = CreatedQuery.Parameters;
	for (var i = 0; i < TableFields.Count; i++) {
		scr_DB.AddGeneralColumn(Select.Columns, TableFields.Items(i), TableFields.Items(i).Name, true, false);
	}
	if (Assigned(FilterFieldNameArray)){
		for (i = 0; i < FilterFieldNameArray.length; i++){
			AddSelectQueryDefaultFilter(CreatedQuery, FilterFieldNameArray[i]);
		}	
	}
	return CreatedQuery;
}

function AddSelectQueryDefaultFilter(SelectQuery, FilterFieldName, CompareOperatorType) {
	var Select;
	for (var i = 0; i < SelectQuery.Count; i++) {
		Select = SelectQuery.Items(0);
		var TableFields = Select.FromTable.Fields;
		var Filters = Select.Filters;
		var Parameters = SelectQuery.Parameters;
		var Parameter = Parameters.ItemsByName(FilterFieldName);
	    var TableField = TableFields.ItemsByName(FilterFieldName.
			replace(IntegrationFiltersSuffix1C, ''));
		if (!Assigned(TableField)) {
			return;
		}
		if (!Assigned(Parameter)) {
			var FilterFieldType = GetParameterTypeBySQLDataType(TableField.SQLDataType);
			var FilterFieldValue = null;
			if (IsEmptyValue(CompareOperatorType)) {
				CompareOperatorType = cotEqual;
			}
			Parameter = AddQueryParameter(Parameters, FilterFieldName,
				FilterFieldType, FilterFieldValue);
		}
		if (!Assigned(Filters.ItemsByCode(FilterFieldName))) {
			AddQueryCompareFilter(Filters, FilterFieldName, TableField,
				Parameter, CompareOperatorType, Select.FromTableAlias);
		}		
	}
}

function BuildFilteredDatasetByTable(Table, IsFakeSelectQuery) {
	var SelectQuery = Services.CreateItem('SelectQuery');
	var Select = SelectQuery.CreateItem();
	if (IsFakeSelectQuery != true) {
		Select.FromTable = Table;
	} else {
		Select.FromTable = System.EmptyValue;
	}
	var Column;
	SelectQuery.Add(Select);
	var FieldName;
	var FieldCaption;
	var Field;
	var DBDataset = Services.CreateItem('DBDataset');
	DBDataset.SelectQuery = SelectQuery;	
	var DataFields = DBDataset.DataFields;

    for (var i = 0; i < Table.Fields.Count; i++) {
    	Field = Table.Fields.Items(i);
	    FieldName = Field.SQLName;
//	    if ('ID' == FieldName) {			continue; 		}
	    FieldCaption = Field.Caption;
	    FieldType = Field.SQLDataType;
		Column = Select.Columns.CreateGeneralColumn();
		if (IsFakeSelectQuery != true) {
			Column.Field = Field;
		} else {
			Column.ColumnAlias = FieldName;
		}
		Select.Columns.Add(Column);
		switch (FieldType) {
		case sdtIdentity:
		case sdtGUID:
		case sdtEnum:
			AddStringDataField(DataFields, FieldName, FieldCaption, 38);
			break;
		case sdtString:
		case sdtUnicodeString:  
			AddStringDataField(DataFields, FieldName, FieldCaption, Field.SQLSize);
			break;
		case sdtInteger:
		case sdtFloat:
			AddFloatDataField(DataFields, FieldName, FieldCaption);
			break;
		case sdtBoolean:
			AddBoolDataField(DataFields, FieldName, FieldCaption);
			break;
		case sdtDateTime:
			AddDateTimeDataField(DataFields, FieldName, FieldCaption);
			break;
		}
	}
	DBDataset.KeyDataField = DataFields('ID');
	return DBDataset;
}

function PromptForSettingsFileName(FileName, IsSavingOperation) {
	if (!System.PromptForFileName(FileName, 
		"Файлы интеграции Terrasoft" + ' (*.xml)|*.xml|'+
		"Все файлы" + ' (*.*)|*.*', 'xml', '', '', IsSavingOperation)) {
		return false;
	}
	return true;
}

function DoImportFileOperation(ImportID, DataflowTypeID, FileNameStr, IsSavingOperation) {
	var FileName = GetNewValue();
	FileName.Value = ExtractFileNameWithoutExtension(FileNameStr);
	if (!PromptForSettingsFileName(FileName, IsSavingOperation)) {
		return;
	}	
	if (!IsSavingOperation) {
		var XMLStorage = GetNewXMLStorage();
		if (!CheckFileExists(FileName.Value)) {
			ShowWarningDialog(FormatStr("Не удается найти файл: '%1'", FileName.Value));
			return;
		}
		XMLStorage.LoadFromFile(FileName.Value);
		var RootNode = XMLStorage.RootNode;
		var DataflowTypeID = RootNode.GetAttributeAsStr('DataflowTypeID', EmptyStr);
	}
	if (DataflowTypeID == edt1C) {
		if (IsSavingOperation) {
			var XMLStorage = Save1CSettingsToFile(ImportID);
			XMLStorage.SaveToFile(FileName.Value);
		} else {
			Load1CSettingsFromFile(ImportID, XMLStorage);
		}	
	} else {
		var DataflowXMLDataset = GetSingleItemByCode('ds_DataflowXMLData', 
			'DataflowsGridArea');
	    ApplyDatasetIDFilter(DataflowXMLDataset, ImportID, true);
	    DataflowXMLDataset.Open();
	    var DataFieldName = 'XMLData';
		try {
			if (IsSavingOperation) {
				LoadFileFromDataset(FileName.Value, DataflowXMLDataset,
					DataFieldName);	
			} else {
				DataflowXMLDataset.Edit();
				SaveFileToDataset(FileName.Value, DataflowXMLDataset, DataFieldName);
				DataflowXMLDataset.Post();
			}	
		} finally {
			DataflowXMLDataset.Close();
		}	
	}
}

//==============================================================================
//   1C Save/Load   Settings
//==============================================================================

function Save1CSettingsToFile(DataflowID) {
	var SaveConnectSettings = true;
	//Check	(mrYes == ShowConfirmationDialog("Сохранять данные по настройке соединения?"));
	var XMLStorage = GetNewXMLStorage();
	XMLStorage.InitRootNode('Dataflow');
	/* Script */
	var sq1CScript = GetSingleItemByCode('sq_1CScript', 'Extract1CScripts');
	ApplySelectQueryFilter(sq1CScript, 'DataflowID', DataflowID, true);
	XMLStorage.RootNode.SetAttributeAsStr('DataflowID', DataflowID, EmptyStr);
	XMLStorage.RootNode.SetAttributeAsStr('DataflowTypeID', edt1C, EmptyStr);
	var ScriptsNode = XMLStorage.RootNode.AddChildNode('Scripts');
    ds1CScript = sq1CScript.Open();
	while (!ds1CScript.IsEOF) {
		var ScriptNode = ScriptsNode.AddChildNode('Script')		
		var Service = Services.GetSingleItemByID(ds1CScript('ID'));
		Service.Serialize(ScriptNode);
		ds1CScript.GotoNext();		
	}	
	/* Data */
	var DataNode = XMLStorage.RootNode.AddChildNode('Data')			
	var USIs = new Array();	
	if (SaveConnectSettings) {
		USIs.push('sq_DataflowXMLData');	
	}
	USIs.push('sq_1CObject');
	USIs.push('sq_1CObjectFields');
	ProcessDataExtractionFromSelectQuery(DataNode, USIs, 'DataflowID', 
		DataflowID, 'ParentID');	
	return XMLStorage;
}

function Load1CSettingsFromFile(DataflowID, XMLStorage) {
	var RootNode = XMLStorage.RootNode;
	/* Dataflow */
	var SettingsFileDataflowID = RootNode.GetAttributeAsStr('DataflowID', EmptyStr);
	
	var DefaultValues = GetNewDictionary();
	var UpdateSettings = false;
	var UpdateData = true;
	if (IsEmptyValue(DataflowID)) {
		UpdateData = false;
		UpdateSettings = true;
	} else {
		UpdateData = true;
		if (SettingsFileDataflowID != DataflowID) {
			var dsDataflow = GetSingleItemByCode('ds_Dataflow', 'Load1CSettingsFromFile');
			ApplyDatasetIDFilter(dsDataflow, SettingsFileDataflowID, true);
			try {
				dsDataflow.Open();
				if (!dsDataflow.IsEmptyPage) {
					if(mrYes == ShowConfirmationDialog(
					"Идентификаторы в настройке и загружаемом файле отличаются."
					+ '\n' + "Загрузить данные в настройку " 
					+ dsDataflow('Name') + '?')) {
			 			UpdateData = true;
						UpdateSettings = (mrYes == 
							ShowConfirmationDialog("Обновлять настройки соединения?"));
					} else {
						return;
					}
				} else {
					if (mrYes == ShowConfirmationDialog(
					"Идентификаторы в настройке и загружаемом файле отличаются."
					+ '\n' + "Добавить новую настройку?")) {
			 			UpdateData = false;
	 					UpdateSettings = true;
					} else {
						return;
					}					 	
				}
			} finally {
				dsDataflow.Close();
			}
		} else {
			UpdateSettings = (mrYes == 
				ShowConfirmationDialog("Обновлять настройки соединения?"));
		}
	}
	/* Script */
	var ScriptsNode = RootNode.FindChildNode('Scripts');
	if (Assigned(ScriptsNode)) {
		for (var i = 0; i < ScriptsNode.Count; i++) {
			var ScriptNode = ScriptsNode.Items(i);
			var ScriptUID = ScriptNode.GetAttributeAsStr('UID', EmptyStr);
			if (IsEmptyStr(ScriptUID)) {
				continue;
			}
			try {
				var Script = Services.GetSingleItemByID(ScriptUID);
			} catch(e) {
			}
			if (!Assigned(Script)) {
				Script = Services.CreateItem('Script');
			}
			Script.Deserialize(ScriptNode);
			Services.SaveItem(Script, 1);
			Services.RemoveItemFromCache(Script.USI);
		}
	}
	/* Data */
	var DataNode = RootNode.FindChildNode('Data');
	if (Assigned(DataNode)) {
//		DefaultValues('DataflowID') = DataflowID;
//		DefaultValues('ID') = null;
		var DefaultFieldNames = new VBArray(DefaultValues.Keys()).toArray();
		ReplacedIDs = GetNewDictionary();
		UsedIDs1CObject = new Array();
		UsedIDs1CObjectFields = new Array();
		for (var i = 0; i < DataNode.Count; i++) {
			LoadDataByTableNode(DataNode.Items(i), DefaultFieldNames, 
				DefaultValues, UpdateSettings, UpdateData);
		}
		var ds1CObjectFields = GetSingleItemByCode('ds_1CObjectFields', 
			'Load1CSettingsFromFile');
		ApplyDatasetFilter(ds1CObjectFields, 'DataflowID', 
			SettingsFileDataflowID, true);
		ApplyDatasetIncludeFilter(ds1CObjectFields, 'NotIDs', 
			UsedIDs1CObjectFields, true);
		ApplyDatasetIncludeFilter(ds1CObjectFields, 'ObjectIDs', 
			UsedIDs1CObject, true);
		try {
			ds1CObjectFields.Open();
			if (!ds1CObjectFields.IsEmptyPage) {
				if (mrYes == ShowConfirmationDialog(
				"Набор полей синхронизации в загружаемом файле и настроеке отличаются." 
				+ '\n' + "Удалить поля из настройки?")) {
					while (!ds1CObjectFields.IsEOF) {
						ds1CObjectFields.Delete();
						ds1CObjectFields.GotoNext();
					}
				}
			}
		} finally {
			ds1CObjectFields.Close();			
		}
		
		var ds1CObject = GetSingleItemByCode('ds_1CObject', 
			'Load1CSettingsFromFile');
		ApplyDatasetFilter(ds1CObject, 'DataflowID', 
			SettingsFileDataflowID, true);
		ApplyDatasetIncludeFilter(ds1CObject, 'NotIDs', 
			UsedIDs1CObject, true);
		try {
			ds1CObject.Open();
			if (!ds1CObject.IsEmptyPage) {
				if (mrYes == ShowConfirmationDialog(
				"Набор объектов синхронизации в загружаемом файле и настроеке отличаются." 
				+ '\n' + "Удалить объекты из настройки?")) {
					while (!ds1CObject.IsEOF) {
						ds1CObject.Delete();
						ds1CObject.GotoNext();
					}
				}
			}
		} finally {
			ds1CObject.Close();			
		}
	}
}

function AddXMLNodeForSelectQuery(RootNode, SelectQuery, FilterName, FilterValue, 
	OrderByColumnName) {
	var TableNode = 
		RootNode.AddChildNode('TableNode');
	TableNode.SetAttributeAsStr('TableSQLName', 
		SelectQuery.Items(0).FromTable.SQLName, '');
	ApplySelectQueryFilter(SelectQuery, FilterName, FilterValue, true);
	if (!IsEmptyValue(OrderByColumnName) && 
	Assigned(SelectQuery.Items(0).Columns.ItemsByAlias(OrderByColumnName))) {
		SelectQuery.Items(0).Columns.ItemsByAlias(OrderByColumnName).OrderType = otAsc;
	}
	var Dataset = SelectQuery.Open();
	Dataset.DisableEvents();
	Dataset.Open();
	while (!Dataset.IsEOF) {
		AddDatasetRowDataToXMLNode(TableNode, Dataset);
	 	Dataset.GotoNext();
	}
	Dataset.EnableEvents();
}

function ProcessDataExtractionFromSelectQuery(RootNode, USIs, FilterName, 
	FilterValue, OrderByColumnName) {
	var Table;
	for (var i = 0; i < USIs.length; i++) {
		Table = GetSingleItemByCode(USIs[i], 'ProcessDataExtractionFromSelectQuery');
		AddXMLNodeForSelectQuery(RootNode, Table, FilterName, FilterValue,
			OrderByColumnName);
	}
}


function LoadDataByTableNode(TableNode, DefaultFieldNames, DefaultValues, 
	UpdateSettings, UpdateData) {
	var TableSQLName = TableNode.GetAttributeAsStr('TableSQLName', EmptyStr);
	if (TableSQLName == 'tbl_Dataflow' && !UpdateSettings) {
		return;
	}
	var Table = Services.GetNewItemByUSI(TableSQLName);
	var Dataset = GenerateDatasetByTable(Table);
	var DataRowNode;
	for (var i = 0; i < TableNode.Count; i++) {
		DataRowNode = TableNode.Items(i);
		LoadDataFromDataRowNodeToDataset(DataRowNode, Dataset, 
			DefaultFieldNames, DefaultValues, TableSQLName);
	}
}

function LoadDataFromDataRowNodeToDataset(DataRowNode, Dataset, 
	DefaultFieldNames, DefaultValues, TableSQLName) {
	var RecordID = null;
	if (!IsStringInArray('ID', DefaultFieldNames)) {
		RecordID = DataRowNode.GetAttributeAsStr('ID', '');
		ApplyDatasetIDFilter(Dataset, RecordID, true);
		RefreshDataset(Dataset);
		if (Dataset.IsEmptyPage) {
			Dataset.Append();
		} else {
			Dataset.Edit();
		}
		if (TableSQLName == 'tbl_1CObjectFields') {
			UsedIDs1CObjectFields.push(RecordID);
		} else
		if (TableSQLName == 'tbl_1CObject') {
			UsedIDs1CObject.push(RecordID);
		}
	} else {
		RefreshDataset(Dataset);	
		Dataset.Append();		
	}
	SetDatasetValuesByDataRowNode(DataRowNode, Dataset,
		DefaultFieldNames, DefaultValues);
	try {
		Dataset.Post();
	} catch(e) {
		Log.Write(2, "Ошибка загрузки: " + e.message);
		Dataset.Close();
	}
}

function SetDatasetValuesByDataRowNode(DataRowNode, Dataset, DefaultFieldNames,
	 DefaultValues) {
	var DataField;
	var DataFieldName;
	var DefaultValue;
	var PreValue;
	for (var i = 0; i < Dataset.DataFields.Count; i++) {
		DataField = Dataset.DataFields.Items(i);
		DataFieldName = DataField.Name;
		if (IsStringInArray(DataFieldName, DefaultFieldNames)) {
			if (DataFieldName == 'ID') {
				DataField.Value = Connector.GenGUID();
				PreValue = DataRowNode.GetAttributeAsStr(DataFieldName, '');
				ReplacedIDs(PreValue) = DataField.Value;
			} else {
				DefaultValue = DefaultValues(DataFieldName);
				if (Assigned(DefaultValue)) {
					PreValue = DataRowNode.GetAttributeAsStr(DataFieldName, '');
					if (IsEmptyValue(DefaultValue(PreValue))) {
						DataField.Value = null;
					} else {
						DataField.Value = DefaultValue(PreValue);
					}
				} else {
					DataField.Value = DefaultValues(DataField.Name);
				}
			}
			continue;
		} else {
			
		}
		if (DataRowNode.GetAttributeAsStr(DataField.Name, '') == 'IsNull') {
			DataField.Value = null;
			continue;
		}
		switch (DataField.FieldType) {
			case dftCalc:
				continue;
			break;
			case dftString:
			case dftEnum:
			case dftLookup:
			case dftBlob:
				PreValue = DataRowNode.GetAttributeAsStr(DataFieldName, '');
				if (System.IsValidGUIDString(PreValue) && 
					!IsEmptyValue(ReplacedIDs(PreValue))) {
					DataField.Value = ReplacedIDs(PreValue);
				} else {
					DataField.Value = PreValue;
				}
			break;
			case dftInteger:
				DataField.Value = 
					DataRowNode.GetAttributeAsInt(DataFieldName, 0);
			break;
			case dftFloat:
				DataField.Value = 
					DataRowNode.GetAttributeAsFloat(DataFieldName, 0);
			break;
			case dftBool:
				DataField.Value = 
					DataRowNode.GetAttributeAsBool(DataFieldName, false);	
			break;
			case dftDateTime:
				DataField.Value = 
					DataRowNode.GetAttributeAsStr(DataFieldName, 0);
			break;
		}
	}	
}

function GetCustomLogFileName(LogName) {
	CreateFolder(Connector.LogsDirectory);
	return Connector.LogsDirectory + LogName+ '_' + 
			DateToStr(new Date(System.Now()), '') + '_' +TimeToStr(new Date(System.Now()), '')  + '.log';
}

function ShowDataflowTextLog(HistoryID) {
	var HistoryDataset = GetSingleItemByCode('ds_DataflowHistoryDetailed', 
		'ShowDataflowDetailed');
	ApplyDatasetFilter(HistoryDataset, 'ID', HistoryID, true);
	RefreshDataset(HistoryDataset);
	try {
		if (!HistoryDataset.DataFields('Details').IsNull) {
			var FileName = HistoryID.replace(/[{}-]/g, '');
			var FileName = GetTemporaryFileName(
				'IntegrationHistory_' + FileName + '.log');
			LoadFileFromDataset(FileName, HistoryDataset, 'Details');
			OpenFileWithFullAccess(FileName);
		}
	} finally {
		HistoryDataset.Close();
	}
}

Changed text

Open file

//-----------------------------------------------------------------------------
// scr_DataflowUtils
//-----------------------------------------------------------------------------

var DataflowUtils = new Object();

var DataflowNodeName = 'Dataflow';
var ItemNodeName = 'Item';
var ItemsNodeName = 'Items';
var SettingsNodeName = 'Settings';
var DestinationNodeName = 'Destination';
var ColumnsNodeName = 'Columns';
var BackRelationsNodeName = 'BackRelations';
var EnumNodeName = 'Enum';
var EnumItemNodeName = 'EnumItem';

var NameAttributeName = 'Name';
var SourceNameAttributeName = 'SourceName';
var RootTableSQLNameAttributeName = 'RootTableSQLName';
var FirstRowAttributeName = 'FirstRow';
var FirstColumnAttributeName = 'FirstColumn';
var LastColumnAttributeName = 'LastColumn';
var IsFirstHeaderAttributeName = 'IsFirstHeader';
var ValueAttributeName = 'Value';
var TypeAttributeName = 'Type';
var IsDefaultAttributeName = 'IsDefault';
var IsPrimaryAttributeName = 'IsPrimary';
var ForeignKeyFieldAttributeName = 'ForeignKeyField';
var IDAttributeName = 'ID';
var TempFieldNameAttributeName = 'TempFieldName';
var TempIndexAttributeName = 'TempIndex';
var FileBodyAttributeName = 'FileBody';

var gtPrimaryKeys = 0;
var gtDefaultValues = 1;
var gtEnumItems = 2;

var ErrorDelimiter = '***';
var ErrorIndent = '***';
var WarningIndent = '-----';
var InformationIndent = '      ';

var EnumItemValueDelimiter = ';'

//TODO
var msgDeletePrimaryKeysConfirmation = 
	"Вы действительно хотите удалить первичные ключи?";
//TODO
var msgDeleteDefaultValuesConfirmation = 
	"Вы действительно хотите удалить значения по умолчанию?";
//TODO
var msgDeleteColumnConfirmation = 
	"Вы действительно хотите удалить колонку?";
//TODO
var msgFieldIsAssignedToColumn = 
	"Поле уже привязано к колонке. Продолжить?"	
var msgFieldIsDefaultValue = 
	"Полю уже назначено значение по умолчанию. Продолжить?";
//TODO
var msgFieldIsPrimaryDisplay = 
	"Поле является первичным для отображения. Добавить в первичный ключ?";
var msgDataflowTypeIsNotDefined = 
	"Тип интеграции не определен";
var msgSelectFileForImport =
	"Выберите файл для импорта"	
var msgDestinationNodeNotFound = 
	"Узел 'Destination' не найден";
var msgSettingsNodeNotFound	=
	"Узел 'Settings' не найден";
var msgDatasetWasNotCreated =
	"Набор данных не был сформирован";
var msgImportDataToTable = 
	"Импортируются данные в таблицу '%1'";
var msgImportDataToTableFinished = 
	"Импорт данных в таблицу '%1' завершен. Добавлено: %2. Обновлено: %3.";
//TODO
var msgPrimaryKeysDoesntExistsSkip = 
	"Первичные поля не существуют. Таблица пропускается.";
var msgImportRecord = 
	"Импортируется запись %1";
var msgRecordIsAlreadyImported = 
	"Запись уже была проимпортирована";
//TODO
var msgPrimaryKeyIsEmptySkip = 
	"Первичное поле '%1' пустое. Запись пропускается.";	
var msgUnsupportedNodeType = 
	"Недопустимый тип узла";
var msgInsertRecord = 
	"Запись добавлена";
var msgUpdateRecord = 
	"Запись обновлена";
var msgLookupWasNotImported = 
	"Справочник для поля '%1' не был проимпортирован";
var msgLookupIsNotDefined = 
	"Справочник для поля '%1' не определен";
var msgWrangDEfaultValue = 
	"Некорректно определено значение по умолчанию для поля '%1'";
var msgDatafieldIsNotDefined =
	"Не определено поле в наборе данных для поля '%1'";
var msgUpdateRecordIsNotNeed = 
	"Нет необходимости обновлять запись";
var msgCantImportTableSkip = 
	"Невозможно импортировать данные. Таблица пропускается.";
var msgImportInterruptedbyUser = 
	"Импорт прерван пользователем";
var msgExecuteImportFromFile = 
	"Импортируются данные из файла '%1'";
var msgTableIsNotAssigned = 
	"Таблица не указана";
var msgDoYouWantLookImportLog = 
	"Импорт завершен. Показать журнал процесса импорта?";
var msgDataflowWasChanged = 
	"Настройки интеграции были изменены. Сохранить изменения?"

function NotifyParentWindow(Window, Message, Data) {
	var ParentWindow = Window.Attributes('ParentWindow');
	ParentWindow.Notify(Window, Message, Data);
}

function AddCommonRecord(Dataset, ID, ParentID, RecordType, Caption, HasChild){
	Dataset.Append();
	Dataset.Values('ID') = ID;
	Dataset.Values('ParentID') = ParentID;
	Dataset.Values('RecordType') = RecordType;
	Dataset.Values('Caption') = Caption;
	Dataset.Values('HasChild') = HasChild;
	Dataset.Post();
}

function AddPrimaryKeyRecord(Dataset, ID, ParentID, Caption, HasChild){
	Dataset.Append();
	Dataset.Values('ID') = ID;
	Dataset.Values('ParentID') = ParentID;
	Dataset.Values('RecordType') = rtcField;
	Dataset.Values('Caption') = Caption;
	Dataset.Values('IsPrimaryKey') = true;
	Dataset.Values('HasChild') = HasChild;
	Dataset.Post();
}

function AddDefaultValueRecord(Dataset, ID, ParentID, Caption, HasChild){
	Dataset.Append();
	Dataset.Values('ID') = ID;
	Dataset.Values('ParentID') = ParentID;
	Dataset.Values('RecordType') = rtcField;
	Dataset.Values('Caption') = Caption;
	Dataset.Values('IsDefaultValue') = true;
	Dataset.Values('HasChild') = HasChild;
	Dataset.Post();
	
}

function AddEnumRecord(Dataset, ID, ParentID, Caption, HasChild, 
	EnumItemID){
	Dataset.Append();
	Dataset.Values('ID') = ID;
	Dataset.Values('ParentID') = ParentID;
	Dataset.Values('RecordType') = rtcField;
	Dataset.Values('Caption') = Caption;
	Dataset.Values('IsEnum') = true;
	Dataset.Values('HasChild') = HasChild;
	Dataset.Values('EnumItemID') = EnumItemID;
	Dataset.Post();	
}

function GetDestinationCountByDestinationNode(
		DestinationNode, DestinationCount){
	var BackRelations = DestinationNode.FindChildNode(BackRelationsNodeName);
	if (Assigned(BackRelations)){
		for (var i = 0; i < BackRelations.Count; i++){
			DestinationCount = GetDestinationCountByDestinationNode(
				BackRelations.Items(i), DestinationCount);
		}
	}
	var Column;
	var DestinationSubNode;
	var Columns = DestinationNode.FindChildNode(ColumnsNodeName);
	if (Assigned(Columns)){
		for (var i = 0; i < Columns.Count; i++){
			Column = Columns.Items(i);
			DestinationSubNode = Column.FindChildNode(DestinationNodeName);
			if (Assigned(DestinationSubNode)){
				DestinationCount = GetDestinationCountByDestinationNode(
					DestinationSubNode, DestinationCount)
			}
		}
	}
	DestinationCount++;
	return DestinationCount;
}


function TranslateDestinationNodeToDataset(Dataset, DestinationNode, ParentID,
	TranslationType, Nodes, Skip){
	if (!Assigned(Nodes)){
		Nodes = new Object();
	}
	var TableName = DestinationNode.GetAttributeAsStr(NameAttributeName, '');
	if (IsEmptyValue(TableName)){
		return Nodes;
	}
	var Table = Services.GetSingleItemByUSI(TableName);
	var ForeignKeyFieldName = 
		DestinationNode.GetAttributeAsStr(ForeignKeyFieldAttributeName, '');	
	var Caption;
	if (IsEmptyValue(ForeignKeyFieldName )){
		Caption = Table.Caption;
	} else {
		Caption = GetBackRelationCaption(Table, ForeignKeyFieldName);
	}
	var DestinationID;
	if (!Skip){
		DestinationID = Connector.GenGUID();
		AddCommonRecord(Dataset, DestinationID, ParentID, rtcTable, Caption);
	} else {
		DestinationID = ParentID;
	}
	var BackRelations = DestinationNode.FindChildNode(BackRelationsNodeName);
	if (Assigned(BackRelations)){
		var BackRelationID = Connector.GenGUID();
		AddCommonRecord(Dataset, BackRelationID, DestinationID, 
			rtcBackRelationsGroup, rcBackRelationsGroup);
		for (var i = 0; i < BackRelations.Count; i++){
			Nodes = TranslateDestinationNodeToDataset(Dataset, 
				BackRelations.Items(i),	BackRelationID, TranslationType, Nodes);
		}
		if (TranslationType == gtEnumItems){
			if (!Dataset.Locate('ParentID', BackRelationID)){
				Dataset.Locate('ID', BackRelationID);
				Dataset.Delete();
			}
		}
	}
	var Columns = DestinationNode.FindChildNode(ColumnsNodeName);
	if (Assigned(Columns)){
		var Column;
		var DestinationSubNode;
		var IsPrimary;
		var ColumnID;
		var FieldName;
		var Field;
		var PostColumn;	
		var Caption;
		var DestinationSubNodeExist;
		var SubTableCode;
		var SubTableCaption;
		var Enum;
		var EnumItem;
		var ID;
		for (var i = 0; i < Columns.Count; i++){
			Column = Columns.Items(i);
			DestinationSubNode = Column.FindChildNode(DestinationNodeName);
			FieldName = Column.GetAttributeAsStr(NameAttributeName, false)
			Field = Table.Fields.ItemsByName(FieldName);
			IsPrimary = 
				Column.GetAttributeAsBool(IsPrimaryAttributeName, false);
			IsDefault = 
				Column.GetAttributeAsBool(IsDefaultAttributeName, false);
			IsEnum = (Field.SQLDataType == sdtEnum) && !IsDefault;
			PostIsPrimary = IsPrimary && (TranslationType == gtPrimaryKeys);	
			PostIsDefault = IsDefault && (TranslationType == gtDefaultValues);
			PostIsEnum = IsEnum && (TranslationType == gtEnumItems);
			PostColumn = PostIsPrimary || PostIsDefault || PostIsEnum;
			DestinationSubNodeExist = Assigned(DestinationSubNode);
			if (!DestinationSubNodeExist && !PostColumn) {
				continue;
			}
			ColumnID = Connector.GenGUID();
			if (DestinationSubNodeExist){
				SubTableCode = 
					DestinationSubNode.GetAttributeAsStr(NameAttributeName, '');
				// TODO
				if (!SubTableCode) {
					Caption = Field.Caption;
				} else {
					SubTableCaption = 
						Services.GetSingleItemByUSI(SubTableCode).Caption;
					Caption = FormatStr(rcForeignKeyColumn, SubTableCaption, 
						Field.Caption);
				}
			}else {
				Caption = Field.Caption;
			}
			if (PostIsPrimary){
				AddPrimaryKeyRecord(Dataset, ColumnID, DestinationID, Caption,
					DestinationSubNodeExist);
			} else if (PostIsDefault){
				AddDefaultValueRecord(Dataset, ColumnID, DestinationID, 
					Caption, DestinationSubNodeExist);
			} else if (PostIsEnum){
				AddEnumRecord(Dataset, ColumnID, DestinationID, Caption, 
					true, null);
				Enum = Field.Enum;
				if (Assigned(Enum)){
					for (var j = 0; j < Enum.Count; j++) {
						EnumItem = Enum.Items(j);
						ID = Connector.GenGUID();
						AddEnumRecord(Dataset, ID, ColumnID, 
							EnumItem.Caption, false, EnumItem.ID);
					}
				}				
			} else {
				AddCommonRecord(Dataset, ColumnID, DestinationID, rtcField, 
					Caption, DestinationSubNodeExist);
			}
			if (PostColumn){
				Nodes[ColumnID] = Column;
			}
			if (DestinationSubNodeExist) {
				Nodes = TranslateDestinationNodeToDataset(Dataset, 
					DestinationSubNode, ColumnID, TranslationType, Nodes, true);
				if (TranslationType == gtEnumItems){
					if (!Dataset.Locate('ParentID', ColumnID)){
						Dataset.Locate('ID', ColumnID);
						Dataset.Delete();
					}
				}
			}
		}
	}
	if ((TranslationType == gtEnumItems) && !Skip){
		if (!Dataset.Locate('ParentID', DestinationID)){
			Dataset.Locate('ID', DestinationID);
			Dataset.Delete();
		}
	}
	return Nodes;
}

function GetCanDragOverFromTablesTree(DataTreeGrid, DataGridColumn, RowIDs) {
	if (DataTreeGrid.Tag != 'TablesTree') {
		return false;
	}
	var Result = Assigned(DataGridColumn) && Assigned(DataGridColumn.DataField) 
		&& RowIDs.Count;
	if (Result){
		var Dataset = DataTreeGrid.DatasetLink.Dataset;
		DataTreeGrid.BeginUpdate();
		Dataset.DisableEvents();
		try {
			var OldID = Dataset.Values(mdfnID);
			for (var i = 0; i < RowIDs.Count; i++) {
			    Dataset.Locate(mdfnID, RowIDs.Items(i));
			    if (Dataset.Values(mdfnRecordTypeCode) != rtcField) {
			        Result = false;
			        break;
			    }
			}
		    Dataset.Locate(mdfnID, OldID);
		} finally {
			Dataset.EnableEvents();
			DataTreeGrid.EndUpdate();
		}	
	}
	return Result;
}

function AddColumnInfoToNode(TreeDataset, ImportItemNode, PathIDs, ParentNode){
	if (PathIDs.length == 0){
		return ParentNode;
	}
	var RowID = PathIDs.pop();
	TreeDataset.Locate(mdfnID, RowID);
	var Node;
	if (!Assigned(ParentNode)){
		Node = ImportItemNode.GetChildNode(DestinationNodeName);
		Node.SetAttributeAsStr(NameAttributeName, 
			TreeDataset.Values(mdfnTableCode), '');
	} else {
		var RecordType = TreeDataset.Values(mdfnRecordTypeCode);
		var TableCode;
		switch (RecordType){
			case rtcEmpty:
				Log.Write(lmtError, msgUnsupportedNodeType);
				return null;
				break;
			case rtcTable:
				TableCode = TreeDataset.Values(mdfnTableCode);
				if (ParentNode.Name == BackRelationsNodeName){
					Node = ParentNode.GetChildNodeByAttributeValue(
						DestinationNodeName, NameAttributeName, TableCode);
				} else {
					Node = ParentNode.GetChildNode(DestinationNodeName);
				}
				Node.SetAttributeAsStr(NameAttributeName, 
					TableCode, '');
				Node.SetAttributeAsStr(ForeignKeyFieldAttributeName, 
					TreeDataset.Values(mdfnFieldName), '');					
				break;
			case rtcField:
				ParentNode = ParentNode.GetChildNode(ColumnsNodeName);
				Node = ParentNode.GetChildNodeByAttributeValue(ItemNodeName, 
					NameAttributeName, TreeDataset.Values(mdfnFieldName));
				if (PathIDs.length != 0){
					Node = Node.GetChildNode(DestinationNodeName);
					var ChildID = PathIDs[PathIDs.length - 1];
					TreeDataset.Locate(mdfnID, ChildID);
					Node.SetAttributeAsStr(NameAttributeName, 
						TreeDataset.Values(mdfnTableCode), '');
				}
				break;
			case rtcBackRelationsGroup:
				Node = ParentNode.GetChildNode(BackRelationsNodeName);
				break;
		}                    
	}
	return AddColumnInfoToNode(TreeDataset, ImportItemNode, PathIDs, Node);
}

function GetFieldPathIDs(TreeDataset, RowID, PathIDs){
	if (!Assigned(PathIDs)){
		PathIDs = new Array();
	}
	if (IsEmptyGUID(RowID)){
		return PathIDs;
	}
	PathIDs.push(RowID);
	if (TreeDataset.Locate(mdfnID, RowID)){
		var ParentID = TreeDataset.Values(mdfnParentID);
		PathIDs = GetFieldPathIDs(TreeDataset, ParentID, PathIDs);
	}
	return PathIDs;
}

function ClearColumnAttributes(Node){
	Node.SetAttributeAsInt(SourceNameAttributeName, -1, -1);
	Node.SetAttributeAsBool(IsPrimaryAttributeName, false, false);
	Node.SetAttributeAsBool(IsDefaultAttributeName, false, false);
	Node.SetAttributeAsInt(TypeAttributeName, -1, -1);
	Node.SetAttributeAsStr(ValueAttributeName, '', '');
	var EnumNode = Node.FindChildNode(EnumNodeName);
	if (Assigned(EnumNode)){
		Node.RemoveChildNode(EnumNode);
	}
}

function GetTableFieldByColumnNode(Node){
	var DestinationNode = Node.ParentNode.ParentNode;
	var TableCode = DestinationNode.GetAttributeAsStr(NameAttributeName, '');
	var Table = Services.GetSingleItemByUSI(TableCode);
	if (!Assigned(Table)){
		return null;
	}
	var FieldName = Node.GetAttributeAsStr(NameAttributeName, '');					
	return Table.Fields.ItemsByName(FieldName);
}

function GetTableFieldTypeByColumnNode(Node){
	var Type = -1;
	var Field = GetTableFieldByColumnNode(Node);
	if (Assigned(Field)){
		Type = Field.SQLDataType;
	}
	return Type;
}

function GetIsPrimaryKeysExists(Columns){
	var Column;
	var Exists = false;
	for (var i = 0; i < Columns.Count ; i++) {
		Column = Columns.Items(i);
		Exists = Column.GetAttributeAsBool(IsPrimaryAttributeName, false);
		if (Exists){
			break;
		}
	}
	return Exists;
}

function CheckRequiredFieldInDestination(Node, ResultArray){
	var BackRelations = Node.FindChildNode(BackRelationsNodeName);
	if (Assigned(BackRelations)){
		for (var i = 0; i < BackRelations.Count; i++){
			 CheckRequiredFieldInDestination(BackRelations.Items(i), 
			 	ResultArray);
		}
	}	
	var Columns = Node.FindChildNode(ColumnsNodeName);
	var NotAssignedFields = new Array();	
	if (Assigned(Columns)){
		var PrimaryKeysExists = GetIsPrimaryKeysExists(Columns);
		if (PrimaryKeysExists){
			var TableCode = Node.GetAttributeAsStr(NameAttributeName, '');
			var Table = Services.GetSingleItemByUSI(TableCode);
			var Fields = Table.Fields;
			var Field;
			var Column;
			for (var i = 0; i < Fields.Count ; i++) {
				Field = Fields.Items(i);
				if (Field.IsRequired && (Field.SQLName != 'ID')){
					Column = Columns.FindChildNodeByAttributeValue(ItemNodeName,
						NameAttributeName, Field.SQLName);
					if (!Assigned(Column)){
						NotAssignedFields.push(Field.SQLName);
					}
				}
			}
		}
		var DestinationNode;
		for (var i = 0; i < Columns.Count ; i++) {
			Column = Columns.Items(i);
			DestinationNode = Column.FindChildNode(DestinationNodeName);
			if (Assigned(DestinationNode)){
				CheckRequiredFieldInDestination(DestinationNode, ResultArray);
			}
		}
	}
	if (NotAssignedFields.length > 0){
		NotAssignedFields.Node = Columns;
		ResultArray.push(NotAssignedFields);
	}
}

function CheckRequiredFieldInDataflow(XMLStorage){
	var FullResult = new Array();
	var ItemsNode = XMLStorage.RootNode.GetChildNode(ItemsNodeName);
	var Item;
	var ItemResult;		
	for (var i = 0; i < ItemsNode.Count; i++) {
		Item = ItemsNode.Items(i).GetChildNode(DestinationNodeName);
		ItemResult = new Array();
		CheckRequiredFieldInDestination(Item, ItemResult);
		if (ItemResult.length > 0){
			ItemResult.Node = Item;
			FullResult.push(ItemResult);
		}
	}
	return FullResult;
}

function GetDataFieldByTableField(DataFields, TableField){
	var DataField;
	switch (TableField.SQLDataType){
		case sdtInteger:
			DataField = DataFields.CreateIntegerDataField();
			break;
		case sdtFloat:
			DataField = DataFields.CreateFloatDataField();
			DataField.Size = TableField.SQLSize;
			DataField.Precision = TableField.SQLPrecision;
			break;
		case sdtString:
		case sdtUnicodeString:
			DataField = DataFields.CreateStringDataField();
			DataField.TextLength = TableField.SQLSize;
			break;
		case sdtBlob:
			DataField = DataFields.CreateStringDataField();
			DataField.TextLength = 10000;			
			break;
		case sdtDateTime:
			DataField = DataFields.CreateDateTimeDataField();
			break;
		case sdtBoolean:
			DataField = DataFields.CreateBoolDataField();
			break;
		case sdtGUID:                                      
		case sdtEnum:	
		case sdtIdentity:
			DataField = DataFields.CreateStringDataField();
			break;
	}
	return DataField;
}

function BuildMemoryDatasetByDestinationNode(DestinationNode, MemoryDataset, AddColumns){
	if (!Assigned(MemoryDataset)){
		MemoryDataset = Services.CreateItem('MemoryDataset');
	}
	var TableName = DestinationNode.GetAttributeAsStr(NameAttributeName, '');
	if (IsEmptyValue(TableName)){
		return MemoryDataset;
	}
	var Table = Services.GetSingleItemByUSI(TableName);	
	var BackRelations = DestinationNode.FindChildNode(BackRelationsNodeName);
	if (Assigned(BackRelations)){
		for (var i = 0; i < BackRelations.Count; i++){
			MemoryDataset = BuildMemoryDatasetByDestinationNode(
				BackRelations.Items(i), MemoryDataset);
		}
	}					
	var Columns = DestinationNode.FindChildNode(ColumnsNodeName);
	if (Assigned(Columns)){
		var Column;
		var DestinationSubNode;
		var SourceName;
		var FieldName;
		var Field;
		var TableFieldName;
		var TableField;
		var FieldsCounter;
		var DataFields = MemoryDataset.DataFields;
		for (var i = 0; i < Columns.Count; i++){
			Column = Columns.Items(i);
			DestinationSubNode = Column.FindChildNode(DestinationNodeName);
			if (Assigned(DestinationSubNode)){
				MemoryDataset = BuildMemoryDatasetByDestinationNode(
					DestinationSubNode, MemoryDataset);
			}
			SourceName = Column.GetAttributeAsStr(SourceNameAttributeName, '');
			if (SourceName == ''){
				continue;
			}
		 	TableFieldName = Column.GetAttributeAsStr(NameAttributeName, false);
			TableField = Table.Fields.ItemsByName(TableFieldName);			
			FieldsCounter = MemoryDataset.Attributes('FieldsCounter') * 1;
			FieldsCounter++;
			MemoryDataset.Attributes('FieldsCounter') = FieldsCounter;
			FieldName = 'Field_' + FieldsCounter;
			Column.SetAttributeAsStr(
				TempFieldNameAttributeName, FieldName, '');
			Field = GetDataFieldByTableField(DataFields, TableField);
			Field.GroupName = SourceName;
			Field.Name = FieldName;
			DataFields.Add(Field);
		}
		if (AddColumns) {
			TableField = Table.Fields.ItemsByName('ID');
			for (i = 1; i <= AddColumns; i++) {
				Field = GetDataFieldByTableField(DataFields, TableField);
				Field.GroupName = i;
				Field.Name = 'AllFields_' + IntToLetter(i);
				DataFields.Add(Field);
			}
		}
	}
	return MemoryDataset;
}

function GetEnumInfoFromColumn(Column, ColumnObject, Field){
	ColumnObject.EnumDictionary = new Object();
	var Enum = Field.Enum;
	if (!Assigned(Enum)){
		return;
	}
	var EnumItem;		
	var EnumItemNode;
	var EnumItemID;
	var Value;
	var ValueArray;	
	var EnumNode = Column.GetChildNode(EnumNodeName);
	for (var i = 0; i < EnumNode.Count; i++) {
		EnumItemNode = EnumNode.Items(i);
		EnumItemID = EnumItemNode.GetAttributeAsStr(IDAttributeName, '');
		EnumItem = Enum.ItemsByID(EnumItemID);
		if (!Assigned(EnumItem)){
			continue;
		}
		Value = EnumItemNode.GetAttributeAsStr(ValueAttributeName, '');
		ValueArray = Value.split(EnumItemValueDelimiter);
		for (var j = 0; j < ValueArray.length; j++) {
			ColumnObject.EnumDictionary[ValueArray[j]] = EnumItemID;
		}
	}
}

function GetDefaultInfoFromColumn(Column, ColumnObject, Field){
	ColumnObject.DefaultType = 
		Column.GetAttributeAsInt(TypeAttributeName, -1);
	ColumnObject.DefaultIsCorrect = true;	
	var Value;
	switch (String(ColumnObject.DefaultType)) {
		case dvtValue:
			break;		
		case dvtFunction:
			ColumnObject.DefaultValue = Column.GetAttributeAsInt(
				ValueAttributeName, -1);
			ColumnObject.DefaultIsCorrect = (ColumnObject.DefaultValue > 0);
			return;
			break;
		default:
			ColumnObject.DefaultIsCorrect = false;
			return;				
	}
	switch(Field.SQLDataType){
		case sdtInteger:
			ColumnObject.DefaultValue = Column.GetAttributeAsInt(
				ValueAttributeName, 0);	
			break;
		case sdtFloat:
			ColumnObject.DefaultValue = Column.GetAttributeAsFloat(
				ValueAttributeName, 0);	
			break;
		case sdtBlob:
		case sdtString:
		case sdtUnicodeString:
		case sdtGUID:		
		case sdtEnum:
			ColumnObject.DefaultValue = Column.GetAttributeAsStr(
				ValueAttributeName, '');	
			break;
		case sdtDateTime:
			ColumnObject.DefaultValue = Column.GetAttributeAsDateTime(
				ValueAttributeName, 0);	
			break;
		case sdtBoolean:
			ColumnObject.DefaultValue = Column.GetAttributeAsBool(
				ValueAttributeName, false);	
			break;
		default:
			ColumnObject.DefaultIsCorrect = false;
			break;		
	}
}


function GetImportObjectByNode(Destination, Dataset, ImportObjects, UpdateRecords, 
	ScriptItem, DataflowID) {
	var ImportProgressObject = Connector.Attributes('ImportProgressObject');
	var ImportObject = new Object();
	ImportObject.Updated = 0;
	ImportObject.Inserted = 0;
	ImportObject.PrimaryKeys = new Array();
	ImportObject.PrimaryKeysIndexes = new Array();
	ImportObject.DefaultValues = new Array();
	ImportObject.MappedColumns = new Array();
	ImportObject.Records = new Object();
	ImportObject.ErrorList = new Array();
	Destination.SetAttributeAsInt(TempIndexAttributeName, ImportObjects.length,
		-1);	
	ImportObject.ImportObjects = ImportObjects;
ImportObject.IsPrimaryObject = !ImportObjects.length;
	ImportObject.Position = ImportObjects.length;
	ImportObjects.push(ImportObject);
	var ForeignKeyFieldName = 
		Destination.GetAttributeAsStr(ForeignKeyFieldAttributeName, '');		
	ImportObject.ForeignKeyFieldName = ForeignKeyFieldName;
	if (!IsEmptyStr(ForeignKeyFieldName)){
		var ForeignKeyNode = Destination.ParentNode.ParentNode;
		ImportObject.ForeignKeyIndex = 
			ForeignKeyNode.GetAttributeAsInt(TempIndexAttributeName, -1);
		ImportObject.ForeignKeyObject = 
			ImportObject.ImportObjects[ImportObject.ForeignKeyIndex];			
	}
	var TableName = Destination.GetAttributeAsStr(NameAttributeName, '');
	if (IsEmptyValue(TableName)){
		return ImportObject;
	}
	ImportObject.TableName = TableName;
	var Table = Services.GetSingleItemByUSI(TableName);
	var Columns = Destination.FindChildNode(ColumnsNodeName);
	if (!Assigned(Columns)){
		return ImportObject;
	}
	ImportObject.Table = Table;
	var Column;
	var DestinationSubNode;
	var TempIndex;
	var ColumnObject;
	var SourceName;
	var FieldName;
	var Field;
	var DataFieldName;
	var DataField;
	for (var i = 0; i < Columns.Count; i++){
		Column = Columns.Items(i);
		DestinationSubNode = Column.FindChildNode(DestinationNodeName);
		ColumnObject = new Object();
		SourceName = Column.GetAttributeAsStr(SourceNameAttributeName, '');
		FieldName = Column.GetAttributeAsStr(NameAttributeName, false)
		Field = Table.Fields.ItemsByName(FieldName);
		ColumnObject.Field = Field;
		ColumnObject.IsLookup = false;
		if (Assigned(DestinationSubNode)){
			ImportObjects = ImportDataByDestinationNode(DestinationSubNode, Dataset, 
				ImportObjects, UpdateRecords, ScriptItem, DataflowID);
			if (Assigned(ImportProgressObject) && 
				ImportProgressObject.CancelledByUser){
				return;
			}		
			if (SourceName != ''){
				ColumnObject.Index = DestinationSubNode.
					GetAttributeAsInt(TempIndexAttributeName, -1);
				ColumnObject.IsLookup = true;
				if ((ColumnObject.Index == -1)){
					ImportObject.ErrorList.push(FormatStr(
						msgLookupIsNotDefined, ColumnObject.Field.Caption))
				} else if (!(ImportObjects[ColumnObject.Index].Imported)){
					ImportObject.ErrorList.push(FormatStr(
						msgLookupWasNotImported, ColumnObject.Field.Caption));
				}
			}
		}
		if (SourceName == ''){
			ColumnObject.IsDefault = 
				Column.GetAttributeAsBool(IsDefaultAttributeName, false);	
			if (!ColumnObject.IsDefault){
				continue;
			}
			GetDefaultInfoFromColumn(Column, ColumnObject, Field);
			if (ColumnObject.DefaultIsCorrect){
				ImportObject.DefaultValues.push(ColumnObject);
				continue;
			} else {
				ImportObject.ErrorList.push(FormatStr(
					msgWrangDEfaultValue, ColumnObject.Field.Caption))	
			}
		} else {
			if (ColumnObject.IsLookup && (ColumnObject.Index == -1)){
				continue;
			}
			ColumnObject.SourceName  = SourceName;
			ColumnObject.IsPrimary = 
				Column.GetAttributeAsBool(IsPrimaryAttributeName, false);
			ColumnObject.IsEnum = (Field.SQLDataType == sdtEnum);
			DataFieldName = Column.GetAttributeAsStr(
				TempFieldNameAttributeName, '');
			DataField = Dataset.DataFields(DataFieldName);
			if (!Assigned(DataField)){
				ImportObject.ErrorList.push(FormatStr(
					msgDatafieldIsNotDefined, ColumnObject.Field.Caption));
				continue;				
			}
			ColumnObject.DataField = DataField;
			ColumnObject.FieldName = FieldName;
			if (ColumnObject.IsPrimary){
				ImportObject.PrimaryKeys.push(FieldName);
				ImportObject.PrimaryKeysIndexes.push(
					ImportObject.MappedColumns.length);
			}
			if (ColumnObject.IsEnum){
				GetEnumInfoFromColumn(Column, ColumnObject, Field);
			}
			ColumnObject.IsDefault = 
				Column.GetAttributeAsBool(IsDefaultAttributeName, false);	
			if (ColumnObject.IsDefault){
				GetDefaultInfoFromColumn(Column, ColumnObject, Field);
			}
		}
		ImportObject.MappedColumns.push(ColumnObject);
	}
	return ImportObject;
}

function GetPrimaryKeysStringForObject(Dataset, ImportObject){
	var Column;
	var Result = new Object();
	Result.Value = '';
	Result.DisplayValue = '';
	for (var i = 0; i < ImportObject.PrimaryKeys.length; i++){
		Column = ImportObject.MappedColumns[ImportObject.PrimaryKeysIndexes[i]];
		if (i > 0){
			Result.Value = Result.Value + '_';
			Result.DisplayValue = Result.DisplayValue + '  ';
		}
		Result.Value = Result.Value + Column.DataField.Value;
		Result.DisplayValue = Result.DisplayValue + FormatStr('%1 = %2', 
			Column.Field.Caption, Column.DataField.Value);
	}
	return Result;
}

function GetRecordID(ImportObject, Dataset){
	var PrimaryKeys = GetPrimaryKeysStringForObject(Dataset, ImportObject);
	var ID = ImportObject.Records[PrimaryKeys.Value];
	if (IsEmptyGUID(ID)){
		ID = null;
	}
	return ID;
}

function GetValueForColumn(ImportObjects, Column, Dataset){
	if (Column.IsLookup){
		var LookupObject = ImportObjects[Column.Index];
		return GetRecordID(LookupObject, Dataset);
	} else if (Column.IsEnum){
		return Column.EnumDictionary[Column.DataField.Value];
	} else {
		return Column.DataField.Value;
	}		
}

function ImportPreventEditingHandler(Message, IsHandled) {
	DataflowUtils.ImportErrorMessage = Message;
	IsHandled.Value = true;
}

function ImportRecord(Dataset, ImportObject, UpdateRecords){
	var PrimaryKeys = 
		GetPrimaryKeysStringForObject(Dataset, ImportObject);
	WriteMessageToFile(lmtInformation, FormatStr(msgImportRecord, 
		PrimaryKeys.DisplayValue));
	var ID = ImportObject.Records[PrimaryKeys.Value];
	if (!IsEmptyValue(ID)){
		WriteMessageToFile(lmtInformation, msgRecordIsAlreadyImported);
		return ID;
	}
	var ColumnObject;
	var PrimaryKeyValue;
	var Parameters = ImportObject.SelectQuery.Parameters;
	var ImportObjects = ImportObject.ImportObjects;
	for (var i = 0; i < ImportObject.PrimaryKeys.length; i++){
		ColumnObject =
			ImportObject.MappedColumns[ImportObject.PrimaryKeysIndexes[i]]
		PrimaryKeyValue = ColumnObject.DataField.Value;
		if (IsEmptyValue(PrimaryKeyValue)){
			WriteMessageToFile(lmtError, FormatStr(msgPrimaryKeyIsEmptySkip,
				ColumnObject.Field.Caption));
			return false;
		}
		Parameters(ImportObject.PrimaryKeys[i]).Value = 
			GetValueForColumn(ImportObjects, ColumnObject, Dataset);
	}
	if (Assigned(ImportObject.Dataset)){
		ImportObject.Dataset.Close();
		ImportObject.Dataset.Open();
	} else {
		ImportObject.Dataset = ImportObject.SelectQuery.Open();
	}
	var CustomPreventEditingHandlerOld = Connector.Attributes('CustomPreventEditingHandler');
	var IsShowCustomPreventEditingMessageOld = Connector.Attributes('IsShowCustomPreventEditingMessage');

	if ((ImportObject.Dataset.IsEmptyPage) || (!UpdateRecords)){
		ID = Connector.GenGUID();
		ImportObject.InsertQueryIDParam.Value = ID;
		for (var i = 0; i < ImportObject.MappedColumns.length; i++) {
			ColumnObject = ImportObject.MappedColumns[i];
			if (ColumnObject.Field.SQLDataType == sdtBlob){
				ColumnObject.InsertParam.ValAsRTF = 
					GetValueForColumn(ImportObjects, ColumnObject, Dataset);
			} else {
				ColumnObject.InsertParam.Value = 
					GetValueForColumn(ImportObjects, ColumnObject, Dataset);
				if (!ColumnObject.InsertParam.Value) {
					if (ColumnObject.IsDefault) {
						ColumnObject.InsertParam.Value = ColumnObject.DefaultValue;
					}					
				}
			}			
		}
		if (Assigned(ImportObject.ForeignKeyInsertParam)){		
			ImportObject.ForeignKeyInsertParam.Value = 
				GetRecordID(ImportObject.ForeignKeyObject, Dataset);			
		}
		try {
			Connector.Attributes('CustomPreventEditingHandler') = ImportPreventEditingHandler;
			Connector.Attributes('IsShowCustomPreventEditingMessage') = true;
			try {
				DataflowUtils.ImportErrorMessage = '';
				ImportObject.InsertQuery.Execute();
				if (IsEmptyValue(DataflowUtils.ImportErrorMessage)) {
					ImportObject.Inserted++;
					WriteMessageToFile(lmtInformation, msgInsertRecord);
				} else {
					WriteMessageToFile(lmtError, DataflowUtils.ImportErrorMessage);
				}
			} catch (e) {
				WriteMessageToFile(lmtError, e.message);
			}
		} finally {
			Connector.Attributes('CustomPreventEditingHandler') = CustomPreventEditingHandlerOld;
			Connector.Attributes('IsShowCustomPreventEditingMessage') = IsShowCustomPreventEditingMessageOld;
		}
	} else {
		ID = ImportObject.Dataset.Values('ID');
		if (ImportObject.CanUpdate){
			for (var i = 0; i < ImportObject.MappedColumns.length; i++) {
				ColumnObject = ImportObject.MappedColumns[i];
				if (ColumnObject.IsPrimary){
					continue;
				}
				if (ColumnObject.Field.SQLDataType == sdtBlob){
					ColumnObject.UpdateParam.ValAsRTF = 
						GetValueForColumn(ImportObjects, ColumnObject, Dataset);
				} else {
					ColumnObject.UpdateParam.Value = 
						GetValueForColumn(ImportObjects, ColumnObject, Dataset);
				}							
			}
			ImportObject.UpdateQueryIDParam.Value = ID;
			if (Assigned(ImportObject.ForeignKeyUpdateParam)){
				ImportObject.ForeignKeyUpdateParam.Value = 
					GetRecordID(ImportObject.ForeignKeyObject, Dataset);			
			}
			try {
				Connector.Attributes('CustomPreventEditingHandler') = ImportPreventEditingHandler;
				Connector.Attributes('IsShowCustomPreventEditingMessage') = true;
				try {
					DataflowUtils.ImportErrorMessage = '';
					ImportObject.UpdateQuery.Execute();
					if (IsEmptyValue(DataflowUtils.ImportErrorMessage)) {
						ImportObject.Updated++;
						WriteMessageToFile(lmtInformation, msgUpdateRecord);
					} else {
						WriteMessageToFile(lmtError, DataflowUtils.ImportErrorMessage);
					}
				} catch (e) {
					WriteMessageToFile(lmtError, e.message);
				}
			} finally {
				Connector.Attributes('CustomPreventEditingHandler') = CustomPreventEditingHandlerOld;
				Connector.Attributes('IsShowCustomPreventEditingMessage') = IsShowCustomPreventEditingMessageOld;
			}
		} else {
			WriteMessageToFile(lmtInformation, msgUpdateRecordIsNotNeed);
		}
	}
	ImportObject.Records[PrimaryKeys.Value] = ID;
	return ID;
}

function ImportDataByImportObject(Dataset, ImportObject, UpdateRecords, ScriptItem, DataflowID){
	if (!Assigned(ImportObject.Table)){
		WriteMessageToFile(lmtError, msgTableIsNotAssigned);	
		return;
	}
	var ImportProgressObject = Connector.Attributes('ImportProgressObject');
	var ImportProgressObjectAssigned = Assigned(ImportProgressObject);
	var Prompt;
	var RecordID;
	var PromptCaption;
	if (ImportProgressObjectAssigned){
		ImportProgressObject.TablesBar.Position++;
		ImportProgressObject.RecordsBar.Position = 0;
		Prompt = ImportProgressObject.Prompt;
		PromptCaption = Prompt.Caption;
		Prompt.Caption = PromptCaption + 
			' (' + ImportObject.Table.Caption + ')';
	}
	try {
		ImportObject.Imported = false;
		WriteMessageToFile(lmtInformation, FormatStr(msgImportDataToTable, 
			ImportObject.Table.Caption));	
		if (ImportObject.PrimaryKeys.length == 0){
			WriteMessageToFile(lmtInformation, msgPrimaryKeysDoesntExistsSkip);	
			return;
		}
		var ErrorList = ImportObject.ErrorList;
		if (ErrorList.length > 0){
			for (var i = 0; i < ErrorList.length; i++){
				WriteMessageToFile(lmtError, ErrorList[i]);
			}
			WriteMessageToFile(lmtError, msgCantImportTableSkip);
			return;
		}
		ImportObject.SelectQuery = scr_DB.CreateSelectQueryByTable(
			ImportObject.Table, null, ImportObject.PrimaryKeys, 
			null, null, -1,	false);
		InitRecordInsertQuery(ImportObject);
		InitRecordUpdateQuery(ImportObject)
		Dataset.GoToFirst();
		while (!Dataset.IsEOF){		
			//mk
			if (SafeExecScriptFunction(ScriptItem, 'OnBeforeRecordImport', 
				ImportObject, Dataset)) {
				//Continue
			} else {
				RecordID = ImportRecord(Dataset, ImportObject, UpdateRecords);
				SafeExecScriptFunction(ScriptItem, 'OnAfterRecordImport', 
					ImportObject, Dataset, RecordID);
			}
			System.ProcessMessages();
			if (Assigned(ImportProgressObject)){
				if (ImportProgressObject.CancelledByUser){
					return;
				} else {
					ImportProgressObject.RecordsBar.Position++;
				}
			}
			Dataset.GoToNext();
		}
		WriteMessageToFile(lmtInformation, FormatStr(msgImportDataToTableFinished, 
			ImportObject.Table.Caption, ImportObject.Inserted, 
			ImportObject.Updated));	

		var Param = new Object();
		Param.DataflowID = DataflowID;
		Param.InsertCount = ImportObject.Inserted;
		Param.UpdateCount = ImportObject.Updated;
		var InfoMessage = FormatStr("Импорт данных в таблицу '%1' завершен.", 
			ImportObject.Table.Caption);
		WriteHistory(dhtInfo, InfoMessage, Param);
		ImportObject.Imported = true;
	} finally {
		if (ImportProgressObjectAssigned){
			Prompt.Caption = PromptCaption;
		}	
	}
}

function ImportDataByDestinationNode(Destination, Dataset, ImportObjects, UpdateRecords, 
	ScriptItem, DataflowID) {
	var ImportProgressObject = Connector.Attributes('ImportProgressObject');
	if (!Assigned(ImportObjects)){
		ImportObjects = new Array();
	}	
	var ImportObject = 
		GetImportObjectByNode(Destination, Dataset, ImportObjects, UpdateRecords, 
			ScriptItem, DataflowID);
	if (Assigned(ImportProgressObject) && 
		ImportProgressObject.CancelledByUser){
		return;
	}							
	ImportDataByImportObject(Dataset, ImportObject, UpdateRecords, ScriptItem, DataflowID);
	if (Assigned(ImportProgressObject) && 
		ImportProgressObject.CancelledByUser){
		return;
	}					
	var BackRelations = Destination.FindChildNode(BackRelationsNodeName);
	if (Assigned(BackRelations)){
		for (var i = 0; i < BackRelations.Count; i++){
			ImportObjects = ImportDataByDestinationNode(BackRelations.Items(i), 
				Dataset, ImportObjects, UpdateRecords, ScriptItem, DataflowID);
			if (Assigned(ImportProgressObject) && 
				ImportProgressObject.CancelledByUser){
				return;
			}				
		}	
	}
	return ImportObjects;
}

function InitRecordInsertQuery(ImportObject) {
	ImportObject.InsertQuery = Services.CreateItem('InsertQuery');
	ImportObject.InsertQuery.Table = ImportObject.Table;
	var ColumnsValues = ImportObject.InsertQuery.ColumnsValues;
	var Field;
	var Column;
	for (var i = 0; i < ImportObject.MappedColumns.length; i++) {
		Column = ImportObject.MappedColumns[i];
		Field = Column.Field;
		Column.InsertParam = CreateParam(ColumnsValues, Field.SQLName, 
			GetParameterTypeBySQLDataType(Field.SQLDataType));
		if (Column.InsertParam.DataType == dftDateTime) {
			Column.InsertParam.DateTimeKind = Field.DateTimeKind;
		}
	}
	for (var i = 0; i < ImportObject.DefaultValues.length; i++) {
		Column = ImportObject.DefaultValues[i];
		if (!Column.DefaultIsCorrect){
			continue;
		}
		Field = Column.Field;
		if (String(Column.DefaultType) == dvtValue){
			Column.InsertParam = CreateParam(ColumnsValues, Field.SQLName, 
				GetParameterTypeBySQLDataType(Field.SQLDataType));
		} else {
			Column.InsertParam = CreateParam(ColumnsValues, Field.SQLName, 
				pdtFunction);
		}
		if (Column.Field.SQLDataType == sdtBlob){
			Column.InsertParam.ValAsRTF = Column.DefaultValue;
		} else {
			Column.InsertParam.Value = Column.DefaultValue;
		}
	}
	ImportObject.InsertQueryIDParam = CreateParam(ColumnsValues, 'ID', 
		sdtIdentity);
	var ForeignKey = ImportObject.ForeignKeyFieldName;
	if (IsEmptyStr(ForeignKey)){
		return;
	}
	if (!Assigned(ImportObject.ForeignKeyObject) ){
		return;
	}
	if (!ImportObject.ForeignKeyObject.Imported){
		return;
	}
	if (Assigned(ColumnsValues(ForeignKey))){
		return;
	}
	ImportObject.ForeignKeyInsertParam = CreateParam(ColumnsValues, ForeignKey, 
			pdtGUID);
}

function InitRecordUpdateQuery(ImportObject) {
	ImportObject.UpdateQuery = Services.CreateItem('UpdateQuery');
	ImportObject.UpdateQuery.Table = ImportObject.Table;
	var ColumnsValues = ImportObject.UpdateQuery.ColumnsValues;
	var Parameters = ImportObject.UpdateQuery.Parameters;
	var Field;
	var Column;
	for (var i = 0; i < ImportObject.MappedColumns.length; i++) {
		Column = ImportObject.MappedColumns[i];
		if (Column.IsPrimary){
			continue;
		}		
		Field = Column.Field;
		Column.UpdateParam = CreateParam(ColumnsValues, Field.SQLName, 
			GetParameterTypeBySQLDataType(Field.SQLDataType));
	}
	// TODO Нужно ли апдейтить значения по умолчанию
	/*for (var i = 0; i < ImportObject.DefaultValues.length; i++) {
		Column = ImportObject.DefaultValues[i];
		if (!Column.DefaultIsCorrect){
			continue;
		}
		Field = Column.Field;
		if (String(Column.DefaultType) == dvtValue){
			Column.UpdateParam = CreateParam(ColumnsValues, Field.SQLName, 
				GetParameterTypeBySQLDataType(Field.SQLDataType));			
		} else {
			Column.UpdateParam = CreateParam(ColumnsValues, Field.SQLName, 
				pdtFunction);
		}
		if (Column.Field.SQLDataType == sdtBlob){
			Column.UpdateParam.ValAsRTF = Column.DefaultValue;
		} else {
			Column.UpdateParam.Value = Column.DefaultValue;
		}
	}*/
	ImportObject.UpdateQueryIDParam = CreateParam(Parameters, 'ID',
		pdtIdentity);
	AddFieldParamCompareFilter(ImportObject.UpdateQuery.Filters, 
		ImportObject.Table.Fields('ID'), ImportObject.Table.SQLName, 
		ImportObject.UpdateQueryIDParam, cotEqual);
	ImportObject.CanUpdate = (ColumnsValues.Count > 0)
	var ForeignKey = ImportObject.ForeignKeyFieldName;
	if (IsEmptyStr(ForeignKey)){
		return;
	}
	if (!Assigned(ImportObject.ForeignKeyObject) ){
		return;
	}
	if (!ImportObject.ForeignKeyObject.Imported){
		return;
	}
	if (Assigned(ColumnsValues(ForeignKey))){
		return;
	}
	for (var i = 0; i < ImportObject.PrimaryKeys.length; i++){
		if (ImportObject.PrimaryKeys[i] == ForeignKey){
			return;
		}
	}
	ImportObject.ForeignKeyUpdateParam = CreateParam(ColumnsValues, ForeignKey, 
			pdtGUID);		
	ImportObject.CanUpdate = true;
}

function GetImportXMLStorage(ImportID) {
	var DataflowXMLDataset = 
		GetSingleItemByCode('ds_DataflowXMLData', 'DataflowsGridArea');
    ApplyDatasetIDFilter(DataflowXMLDataset, ImportID, true);
    var XMLStorage;
    DataflowXMLDataset.Open();
    if (DataflowXMLDataset.IsEmptyPage){
    	return null;
	}
    try {
	    XMLStorage = GetNewXMLStorage();
	    XMLStorage.LoadFromDataset(DataflowXMLDataset, 'XMLData');
	} finally {
		DataflowXMLDataset.Close();
	}
    return XMLStorage;
}

function ShowDataflowTuning(RecordID, Dictionary){
	if (!Assigned(Dictionary)){
		Dictionary = GetNewDictionary();
	}
    Dictionary('RecordID') = RecordID;
    ShowEditWindowEx('wnd_DataflowTuning', Dictionary, null, false, true);
}

function ExpandTreeGridAndLocateToRootNode(TreeGrid){
	TreeGrid.ExpandAll();
	TreeGrid.DatasetLink.Dataset.Locate(TreeGrid.ParentDatafieldName, null);
}

function GetTuningItemsByPageName(Window){
	var TuningItemsByPageName = Window.Attributes('TuningItemsByPageName');
	if (!Assigned(TuningItemsByPageName)){
		TuningItemsByPageName = GetNewDictionary();
		Window.Attributes('TuningItemsByPageName') = TuningItemsByPageName;
	}
	return TuningItemsByPageName;
}

function WriteMessageToFile(MessageType, Message){
	var LogFile = DataflowUtils.ImportLogFile;
	if (!Assigned(LogFile)){
		return;
	}
	switch (MessageType){
		case lmtError :
			LogFile.WriteLine(ErrorDelimiter);
			LogFile.Write(ErrorIndent);
			break;
		case lmtWarning :
			LogFile.Write(WarningIndent);
			break;			
		case lmtInformation :
			LogFile.Write(InformationIndent);
			break;						
	}
	LogFile.WriteLine(Message);
	switch (MessageType){
		case lmtError :
			LogFile.WriteLine(ErrorDelimiter);
			break;
	}	
}

function PromptToOpenTemplate(FileName) {
	var Message = "Открыть сохраненный файл шаблона импорта?";
	if (ShowConfirmationDialog(Message) != mrYes) {
		return false;
	}
	var IsOpenedSuccessfully = System.OpenFile(FileName, fatReadWrite);
	if (!IsOpenedSuccessfully) {
		var Message = FormatStr("Ошибка открытия файла %1", FileName);
		ShowWarningDialog(Message);
		return false;
	}
	return true;
}

function GetColumnsToNodeMapping(Node, Mapping){
	if (!Assigned(Mapping)){
		Mapping = new Object();
	}
	var ChildNode;
	var ColumnsNode = Node.FindChildNode(ColumnsNodeName);
	if (Assigned(ColumnsNode)){
		for (var i = 0; i < ColumnsNode.Count; i++){
			ChildNode = ColumnsNode.Items(i);
			SourceName = ChildNode.GetAttributeAsInt(SourceNameAttributeName, -1);
			if (SourceName > 0){
				ColumnMapping = Mapping['Column' + SourceName];
				if (!Assigned(ColumnMapping)){
					ColumnMapping = new Array();
					Mapping['Column' + SourceName] = ColumnMapping;
				}
				ColumnMapping.push(ChildNode);
			}
			var DestinationNode = ChildNode.FindChildNode(DestinationNodeName);
			if (Assigned(DestinationNode)){
				Mapping = GetColumnsToNodeMapping(DestinationNode, Mapping)
			}
		}	
	}
	var BackRelationsNode = Node.FindChildNode(BackRelationsNodeName);
	if (Assigned(BackRelationsNode)){
		for (var i = 0; i < BackRelationsNode.Count; i++){
			ChildNode = BackRelationsNode.Items(i);
			Mapping = GetColumnsToNodeMapping(ChildNode, Mapping)
		}		
	}
	return Mapping;
}

function GetSettingsNode(XMLStorage) {
	return XMLStorage.RootNode.GetChildNode(SettingsNodeName);
}

function GetXMLFileName(DataflowID) {
	return Connector.UserSettingsDirectory + 'Dataflow' + DataflowID + '.xml';
}

function GetXMLStorage(DataflowID) {
	var XMLStorage = GetNewXMLStorage();
	var IsUserXMLData = GetDatasetFieldValueByID('ds_Dataflow', 
		DataflowID, 'IsUserXMLData');
	if (IsUserXMLData) {
		var FileName = GetXMLFileName(DataflowID);
		if (CheckFileExists(FileName)) {
			XMLStorage.LoadFromFile(FileName);
		} else {
			ShowWarningDialog(
				FormatStr("Файл настроек интеграции не найден '%1'", FileName));
		}
	} else {	
		var Dataset = GetSingleItemByCode('ds_DataflowXMLData', 'LoadConnectParam');
		ApplyDatasetFilter(Dataset, 'ID', DataflowID, true);
		Dataset.Open();
		try {
			if (!IsDatasetEmpty(Dataset)) {
				XMLStorage.LoadFromDataset(Dataset, 'XMLData');
			}		
		} finally {
			Dataset.Close();
		}
	}
	XMLStorage.InitRootNode(DataflowNodeName);
	return XMLStorage;		
}

function BeginHistory(TypeID, DataflowID) {
	var Dataset = GetHistoryDataset();
	Dataset.Append();
	var ID = Connector.GenGUID();
	Dataset('ID') = ID;	
	Dataset('DataflowID') = Param.DataflowID;
	Dataset('BeginDate') = (new Date()).getVarDate();	
	Dataset.Post();
	return ID;
}

function EndHistory(ID, Message, Param) {
	var Dataset = GetHistoryDataset();
	ApplyDatasetFilter(Dataset, 'ID', ID, true);
	Dataset.Open();
	try {
		if (!IsDatasetEmpty(Dataset)) {
			Dataset.Edit();
			Dataset('EndDate') = (new Date()).getVarDate();	
			if (!IsEmptyValue(Param.InsertCount)) {
				Dataset('InsertCount') = Param.InsertCount;
			}
			if (!IsEmptyValue(Param.UpdateCount)) {
				Dataset('UpdateCount') = Param.UpdateCount;
			}
			Dataset('Message') = Message;
			Dataset('TypeID') = TypeID;			
			Dataset.Post();
		}
	} finally {
		Dataset.Close();
	}
	Dataset.Post();
}

function GetHistoryDataset() {
	var HistoryDataset = DataflowUtils.HistoryDataset;
	if (!Assigned(HistoryDataset)) {
		HistoryDataset = Services.GetNewItemByUSI('ds_DataflowHistory');
		DataflowUtils.HistoryDataset = HistoryDataset;
		HistoryDataset.DataFields('Details').IsEnabled = true;
		HistoryDataset.SelectQuery.Columns('Details').IsEnabled = true;
	}
	return HistoryDataset;
}

function WriteHistory(TypeID, Message, Param, BeginDate, FinishDate, IsMain,
	IsUpdate){
	var HistoryDataset = GetHistoryDataset();
	if (!IsUpdate || IsEmptyValue(Param.HistoryObjectID)) {
		HistoryDataset.Append();
	} else {
		ApplyDatasetIDFilter(HistoryDataset, Param.HistoryObjectID, true);
		HistoryDataset.Open()
		HistoryDataset.Edit();
		ApplyDatasetIDFilter(HistoryDataset, Param.HistoryObjectID, false);
	}
	HistoryDataset('Message') = Message;
	if (!IsEmptyValue(Param.ObjectID)) {
		HistoryDataset('ObjectID') = Param.ObjectID;
	}
	if (!IsEmptyValue(Param.DataflowID)) {
		HistoryDataset('DataflowID') = Param.DataflowID;
	}
	if (!IsEmptyValue(Param.InsertCount)) {
		HistoryDataset('InsertCount') = Param.InsertCount;
	}
	if (!IsEmptyValue(Param.UpdateCount)) {
		HistoryDataset('UpdateCount') = Param.UpdateCount;
	}
	if (!IsEmptyValue(Param.HistoryObjectID)) {
		if (IsMain) {
			HistoryDataset('ID') = Param.HistoryObjectID;
			if (!IsEmptyValue(Param.ErrorCount)) {
				HistoryDataset('ErrorCount') = Param.ErrorCount;
			}			
		} else {
			HistoryDataset('ParentID') = Param.HistoryObjectID;
		}
	}
		
	if (!IsEmptyValue(BeginDate)) {
		HistoryDataset('BeginDate') = BeginDate;
	} else {
		HistoryDataset('BeginDate') = new Date().getVarDate();
	}
	
	if (!IsEmptyValue(FinishDate)) {
		HistoryDataset('FinishDate') = FinishDate;
	} else {
		HistoryDataset('FinishDate') = new Date().getVarDate();
	}	
	
	if (!IsEmptyValue(Param.LogFileName)) {
		SaveFileToDataset(Param.LogFileName, HistoryDataset, 'Details');
	}
	HistoryDataset('Message') = Message;
	HistoryDataset('TypeID') = TypeID;
	HistoryDataset.Post();
	HistoryDataset.Close();
}

function DeleteRecords(Dataset, Dictionary) {
	var Error;
	try {
		if (!Assigned(Dataset)) {
			if (!IsEmptyValue(Dataset) && Assigned(Services.InformationsByUSI(Dataset))) {
				Dataset = Services.GetNewItemByUSI(Dataset);
			} else {
				return;
			}
		}
		if ('DBDataset' == Dataset.ServiceTypeCode) {
			var Table = Dataset.SelectQuery.Items(0).FromTable;
		} else
		if ('Table' == Dataset.ServiceTypeCode) {
			var Table = Dataset;
		} else {
			return;
		}
		var dq = Services.CreateItem('DeleteQuery');
		dq.Table = Table;
		var TableFields = Table.Fields;
		var Filters = dq.Filters;
		var Parameters = dq.Parameters;
	
		var TableField;
		var FilterFieldType;
		var CompareOperatorType = cotEqual;
		var Parameter;
		
		var Keys = new VBArray(Dictionary.Keys()).toArray();
		var KeysLength = Keys.length;
		for (var i = 0; i < KeysLength; i++) {
		    TableField = TableFields.ItemsByName(Keys[i]);
			FilterFieldType = GetParameterTypeBySQLDataType(TableField.SQLDataType);
			Parameter = AddQueryParameter(Parameters, Keys[i],
				FilterFieldType, Dictionary(Keys[i]));
			AddQueryCompareFilter(Filters, Keys[i], TableField,
				Parameter, CompareOperatorType);
		}
		dq.Execute();
	} catch(e) {
		Error = e;
	}
	return Error;
}

function GetLeetersFromGUID(GUID) {
	GUID = new String(GUID);
	var re = new RegExp("[{}-]","ig"); 		
	return GUID.replace(re, '');
}

function GetDatasetFieldValueByFieldValue(DatasetUSI, FilterName, IDValue, FieldName) {
	if (Assigned(DatasetUSI)) {
		var Dataset = DatasetUSI;
	} else {
		var Dataset = GetSingleItemByCode(DatasetUSI, DatasetUSI + FieldName);
	}
	ApplyDatasetFilter(Dataset, FilterName, IDValue, true);
	var Enabled = false;
	for (var i = 0; i < Dataset.DataFields.Count; i++) {
		DataField = Dataset.DataFields.Items(i);
		Enabled = (DataField.Name == FieldName || DataField.Name == FilterName);
		EnableDatasetField(Dataset, DataField, Enabled);
	}
	Dataset.Open();
	var Result = Dataset(FieldName);
	Dataset.Close();
	ApplyDatasetIDFilter(Dataset, null, false);
	return Result;
}

function CreateSelectQueryByTable(Table, FilterFieldNameArray, Top) {
	var CreatedQuery = Services.CreateItem('SelectQuery');
	var Select = CreatedQuery.CreateItem();
	if (IsEmptyValue(Top)){
		Select.Top = -1;
	} else {
       Select.Top = Top;
	}
	CreatedQuery.Add(Select);
	Select.FromTable = Table;
	var TableFields = Table.Fields;
	var Filters = Select.Filters;
	var Parameters = CreatedQuery.Parameters;
	for (var i = 0; i < TableFields.Count; i++) {
		scr_DB.AddGeneralColumn(Select.Columns, TableFields.Items(i), TableFields.Items(i).Name, true, false);
	}
	if (Assigned(FilterFieldNameArray)){
		for (i = 0; i < FilterFieldNameArray.length; i++){
			AddSelectQueryDefaultFilter(CreatedQuery, FilterFieldNameArray[i]);
		}	
	}
	return CreatedQuery;
}

function AddSelectQueryDefaultFilter(SelectQuery, FilterFieldName, CompareOperatorType) {
	var Select;
	for (var i = 0; i < SelectQuery.Count; i++) {
		Select = SelectQuery.Items(0);
		var TableFields = Select.FromTable.Fields;
		var Filters = Select.Filters;
		var Parameters = SelectQuery.Parameters;
		var Parameter = Parameters.ItemsByName(FilterFieldName);
	    var TableField = TableFields.ItemsByName(FilterFieldName.replace('S1CF', ''));
		if (!Assigned(TableField)) {
			return;
		}
		if (!Assigned(Parameter)) {
			var FilterFieldType = GetParameterTypeBySQLDataType(TableField.SQLDataType);
			var FilterFieldValue = null;
			if (IsEmptyValue(CompareOperatorType)) {
				CompareOperatorType = cotEqual;
			}
			Parameter = AddQueryParameter(Parameters, FilterFieldName,
				FilterFieldType, FilterFieldValue);
		}
		if (!Assigned(Filters.ItemsByCode(FilterFieldName))) {
			AddQueryCompareFilter(Filters, FilterFieldName, TableField,
				Parameter, CompareOperatorType, Select.FromTableAlias);
		}		
	}
}

function BuildFilteredDatasetByTable(Table, IsFakeSelectQuery) {
	var SelectQuery = Services.CreateItem('SelectQuery');
	var Select = SelectQuery.CreateItem();
	if (IsFakeSelectQuery != true) {
		Select.FromTable = Table;
	} else {
		Select.FromTable = System.EmptyValue;
	}
	var Column;
	SelectQuery.Add(Select);
	var FieldName;
	var FieldCaption;
	var Field;
	var DBDataset = Services.CreateItem('DBDataset');
	DBDataset.SelectQuery = SelectQuery;	
	var DataFields = DBDataset.DataFields;

    for (var i = 0; i < Table.Fields.Count; i++) {
    	Field = Table.Fields.Items(i);
	    FieldName = Field.SQLName;
//	    if ('ID' == FieldName) {			continue; 		}
	    FieldCaption = Field.Caption;
	    FieldType = Field.SQLDataType;
		Column = Select.Columns.CreateGeneralColumn();
		if (IsFakeSelectQuery != true) {
			Column.Field = Field;
		} else {
			Column.ColumnAlias = FieldName;
		}
		Select.Columns.Add(Column);
		switch (FieldType) {
		case sdtIdentity:
		case sdtGUID:
		case sdtEnum:
			AddStringDataField(DataFields, FieldName, FieldCaption, 38);
			break;
		case sdtString:
		case sdtUnicodeString:  
			AddStringDataField(DataFields, FieldName, FieldCaption, Field.SQLSize);
			//TODO Сделать лукап нормальный но это не всегда возможно
			break;
		case sdtInteger:
		case sdtFloat:
			AddFloatDataField(DataFields, FieldName, FieldCaption, 
				Field.SQLPrecision,	Field.SQLSize);
			break;
		case sdtBoolean:
			AddBoolDataField(DataFields, FieldName, FieldCaption);
			break;
		case sdtDateTime:
			AddDateTimeDataField(DataFields, FieldName, FieldCaption);
			break;
		}
	}
	DBDataset.KeyDataField = DataFields('ID');
	return DBDataset;
}

function AddFloatDataField(DataFields, DataFieldName, DataFieldCaption, 
	Precision, Size) {
	var FloatDataField = DataFields.CreateFloatDataField();
	FloatDataField.Name = DataFieldName;
	FloatDataField.Caption = DataFieldCaption;
	if (IsEmptyValue(Precision) || Precision == 0) {
		Precision = 4;
	}
	if (IsEmptyValue(Size) || Size == 0) {
		Size = 15;
	}	
	FloatDataField.Precision = Precision;	
	FloatDataField.Size = Size;
	DataFields.Add(FloatDataField);
	return FloatDataField;
}

//3.3.2
function PromptForSettingsFileName(FileName, IsSavingOperation) {
	if (!System.PromptForFileName(FileName, 
		"Файлы интеграции Terrasoft" + ' (*.xml)|*.xml|'+
		"Все файлы" + ' (*.*)|*.*', 'xml', '', '', IsSavingOperation)) {
		return false;
	}
	return true;
}

function DoImportFileOperation(ImportID, DataflowTypeID, FileNameStr, IsSavingOperation) {
	var FileName = GetNewValue();
	FileName.Value = ExtractFileNameWithoutExtension(FileNameStr);
	if (!PromptForSettingsFileName(FileName, IsSavingOperation)) {
		return;
	}	
	if (!IsSavingOperation) {
		var XMLStorage = GetNewXMLStorage();
		if (!CheckFileExists(FileName.Value)) {
			ShowWarningDialog(FormatStr("Не удается найти файл: '%1'", FileName.Value));
			return;
		}
		XMLStorage.LoadFromFile(FileName.Value);
		var RootNode = XMLStorage.RootNode;
		var DataflowTypeID = RootNode.GetAttributeAsStr('DataflowTypeID', EmptyStr);
	}
	if (DataflowTypeID == edt1C) {
		var Msg = EmptyStr;
		if (IsSavingOperation) {
			var XMLStorage = Save1CSettingsToFile(ImportID);
			XMLStorage.SaveToFile(FileName.Value);
			Msg = FormatStr("Настройки '%1' успешно сохранены.", FileNameStr);
		} else {
			Load1CSettingsFromFile(ImportID, XMLStorage);
			Msg = FormatStr("Настройки из '%1' успешно загружены.", FileName.Value);
		}	
		Log.Write(1, Msg);
		var Param = new Object();
		Param.DataflowID = ImportID;
		WriteHistory(dhtInfo, Msg, Param);
	} else {
		var DataflowXMLDataset = GetSingleItemByCode('ds_DataflowXMLData', 
			'DataflowsGridArea');
	    ApplyDatasetIDFilter(DataflowXMLDataset, ImportID, true);
	    DataflowXMLDataset.Open();
	    var DataFieldName = 'XMLData';
		try {
			if (IsSavingOperation) {
				LoadFileFromDataset(FileName.Value, DataflowXMLDataset,
					DataFieldName);	
			} else {
				DataflowXMLDataset.Edit();
				SaveFileToDataset(FileName.Value, DataflowXMLDataset, DataFieldName);
				DataflowXMLDataset.Post();
			}	
		} finally {
			DataflowXMLDataset.Close();
		}	
	}
}

//==============================================================================
//   1C Save/Load   Settings
//==============================================================================

function Save1CSettingsToFile(DataflowID) {
	var SaveConnectSettings = true;
	//Check	(mrYes == ShowConfirmationDialog("Сохранять данные по настройке соединения?"));
	var XMLStorage = GetNewXMLStorage();
	XMLStorage.InitRootNode('Dataflow');
	/* Script */
	var sq1CScript = GetSingleItemByCode('sq_1CScript', 'Extract1CScripts');
	ApplySelectQueryFilter(sq1CScript, 'DataflowID', DataflowID, true);
	XMLStorage.RootNode.SetAttributeAsStr('DataflowID', DataflowID, EmptyStr);
	XMLStorage.RootNode.SetAttributeAsStr('DataflowTypeID', edt1C, EmptyStr);
	var ScriptsNode = XMLStorage.RootNode.AddChildNode('Scripts');
    ds1CScript = sq1CScript.Open();
	while (!ds1CScript.IsEOF) {
		var ScriptNode = ScriptsNode.AddChildNode('Script')		
		var Service = Services.GetSingleItemByID(ds1CScript('ID'));
		Service.Serialize(ScriptNode);
		ds1CScript.GotoNext();		
	}	
	/* Data */
	var DataNode = XMLStorage.RootNode.AddChildNode('Data')			
	var USIs = new Array();	
	if (SaveConnectSettings) {
		USIs.push('sq_DataflowXMLData');	
	}
	USIs.push('sq_1CObject');
	USIs.push('sq_1CObjectFields');
	ProcessDataExtractionFromSelectQuery(DataNode, USIs, 'DataflowID', 
		DataflowID, 'ParentID');	
	return XMLStorage;
}

function Load1CSettingsFromFile(DataflowID, XMLStorage) {
	var RootNode = XMLStorage.RootNode;
	/* Dataflow */
	var SettingsFileDataflowID = RootNode.GetAttributeAsStr('DataflowID', EmptyStr);
	
	var DefaultValues = GetNewDictionary();
	var UpdateSettings = false;
	var UpdateData = true;
	if (IsEmptyValue(DataflowID)) {
		UpdateData = false;
		UpdateSettings = true;
	} else {
		UpdateData = true;
		if (SettingsFileDataflowID != DataflowID) {
			var dsDataflow = GetSingleItemByCode('ds_Dataflow', 'Load1CSettingsFromFile');
			ApplyDatasetIDFilter(dsDataflow, SettingsFileDataflowID, true);
			try {
				dsDataflow.Open();
				if (!dsDataflow.IsEmptyPage) {
					if(mrYes == ShowConfirmationDialog(
					"Идентификаторы в настройке и загружаемом файле отличаются."
					+ '\n' + "Загрузить данные в настройку " 
					+ dsDataflow('Name') + '?')) {
			 			UpdateData = true;
						UpdateSettings = (mrYes == 
							ShowConfirmationDialog("Обновлять настройки соединения?"));
					} else {
						return;
					}
				} else {
					if (mrYes == ShowConfirmationDialog(
					"Идентификаторы в настройке и загружаемом файле отличаются."
					+ '\n' + "Добавить новую настройку?")) {
			 			UpdateData = false;
	 					UpdateSettings = true;
					} else {
						return;
					}					 	
				}
			} finally {
				dsDataflow.Close();
			}
		} else {
			UpdateSettings = (mrYes == 
				ShowConfirmationDialog("Обновлять настройки соединения?"));
		}
	}
	/* Script */
	var ScriptsNode = RootNode.FindChildNode('Scripts');
	if (Assigned(ScriptsNode)) {
		for (var i = 0; i < ScriptsNode.Count; i++) {
			var ScriptNode = ScriptsNode.Items(i);
			var ScriptUID = ScriptNode.GetAttributeAsStr('UID', EmptyStr);
			if (IsEmptyStr(ScriptUID)) {
				continue;
			}
			if (ScriptUID.length == 32) {
				ScriptUID = '{'+ScriptUID.substr(0,8)+'-'+ScriptUID.substr(8,4)+'-'+ScriptUID.substr(12,4)+'-'+ScriptUID.substr(16,4)+'-'+ScriptUID.substr(20)+'}';
			}
			var Script;
			if (Assigned(Services.InformationsByID(ScriptUID))) {
				Script = Services.GetSingleItemByID(ScriptUID);
			} else {
				Script = Services.CreateItem('Script');
			}
			Script.Deserialize(ScriptNode);
			Services.SaveItem(Script, 1);
			Services.RemoveItemFromCache(Script.USI);
		}
	}
	/* Data */
	var DataNode = RootNode.FindChildNode('Data');
	if (Assigned(DataNode)) {
//		DefaultValues('DataflowID') = DataflowID;
//		DefaultValues('ID') = null;
		var DefaultFieldNames = new VBArray(DefaultValues.Keys()).toArray();
		ReplacedIDs = GetNewDictionary();
		UsedIDs1CObject = new Array();
		UsedIDs1CObjectFields = new Array();
		for (var i = 0; i < DataNode.Count; i++) {
			LoadDataByTableNode(DataNode.Items(i), DefaultFieldNames, 
				DefaultValues, UpdateSettings, UpdateData);
		}
		var ds1CObjectFields = GetSingleItemByCode('ds_1CObjectFields', 
			'Load1CSettingsFromFile');
		ApplyDatasetFilter(ds1CObjectFields, 'DataflowID', 
			SettingsFileDataflowID, true);
		ApplyDatasetIncludeFilter(ds1CObjectFields, 'NotIDs', 
			UsedIDs1CObjectFields, true);
		ApplyDatasetIncludeFilter(ds1CObjectFields, 'ObjectIDs', 
			UsedIDs1CObject, true);
		try {
			ds1CObjectFields.Open();
			if (!ds1CObjectFields.IsEmptyPage) {
				if (mrYes == ShowConfirmationDialog(
				"Набор полей синхронизации в загружаемом файле и настроеке отличаются." 
				+ '\n' + "Удалить поля из настройки?")) {
					while (!ds1CObjectFields.IsEOF) {
						ds1CObjectFields.Delete();
						ds1CObjectFields.GotoNext();
					}
				}
			}
		} finally {
			ds1CObjectFields.Close();			
		}
		
		var ds1CObject = GetSingleItemByCode('ds_1CObject', 
			'Load1CSettingsFromFile');
		ApplyDatasetFilter(ds1CObject, 'DataflowID', 
			SettingsFileDataflowID, true);
		ApplyDatasetIncludeFilter(ds1CObject, 'NotIDs', 
			UsedIDs1CObject, true);
		try {
			ds1CObject.Open();
			if (!ds1CObject.IsEmptyPage) {
				if (mrYes == ShowConfirmationDialog(
				"Набор объектов синхронизации в загружаемом файле и настроеке отличаются." 
				+ '\n' + "Удалить объекты из настройки?")) {
					while (!ds1CObject.IsEOF) {
						ds1CObject.Delete();
						ds1CObject.GotoNext();
					}
				}
			}
		} finally {
			ds1CObject.Close();			
		}
	}
}

function AddXMLNodeForSelectQuery(RootNode, SelectQuery, FilterName, FilterValue, 
	OrderByColumnName) {
	var TableNode = 
		RootNode.AddChildNode('TableNode');
	TableNode.SetAttributeAsStr('TableSQLName', 
		SelectQuery.Items(0).FromTable.SQLName, '');
	ApplySelectQueryFilter(SelectQuery, FilterName, FilterValue, true);
	if (!IsEmptyValue(OrderByColumnName) && 
	Assigned(SelectQuery.Items(0).Columns.ItemsByAlias(OrderByColumnName))) {
		SelectQuery.Items(0).Columns.ItemsByAlias(OrderByColumnName).OrderType = otAsc;
	}
	var Dataset = SelectQuery.Open();
	Dataset.DisableEvents();
	Dataset.Open();
	while (!Dataset.IsEOF) {
		AddDatasetRowDataToXMLNode(TableNode, Dataset);
	 	Dataset.GotoNext();
	}
	Dataset.EnableEvents();
}

function ProcessDataExtractionFromSelectQuery(RootNode, USIs, FilterName, 
	FilterValue, OrderByColumnName) {
	var Table;
	for (var i = 0; i < USIs.length; i++) {
		Table = GetSingleItemByCode(USIs[i], 'ProcessDataExtractionFromSelectQuery');
		AddXMLNodeForSelectQuery(RootNode, Table, FilterName, FilterValue,
			OrderByColumnName);
	}
}


function LoadDataByTableNode(TableNode, DefaultFieldNames, DefaultValues, 
	UpdateSettings, UpdateData) {
	var TableSQLName = TableNode.GetAttributeAsStr('TableSQLName', EmptyStr);
	if (TableSQLName == 'tbl_Dataflow' && !UpdateSettings) {
		return;
	}
	var Table = Services.GetNewItemByUSI(TableSQLName);
	var Dataset = GenerateDatasetByTable(Table);
	var DataRowNode;
	for (var i = 0; i < TableNode.Count; i++) {
		DataRowNode = TableNode.Items(i);
		LoadDataFromDataRowNodeToDataset(DataRowNode, Dataset, 
			DefaultFieldNames, DefaultValues, TableSQLName);
	}
}

function LoadDataFromDataRowNodeToDataset(DataRowNode, Dataset, 
	DefaultFieldNames, DefaultValues, TableSQLName) {
	var RecordID = null;
	if (!IsStringInArray('ID', DefaultFieldNames)) {
		RecordID = DataRowNode.GetAttributeAsStr('ID', '');
		ApplyDatasetIDFilter(Dataset, RecordID, true);
		RefreshDataset(Dataset);
		if (Dataset.IsEmptyPage) {
			Dataset.Append();
		} else {
			Dataset.Edit();
		}
		if (TableSQLName == 'tbl_1CObjectFields') {
			UsedIDs1CObjectFields.push(RecordID);
		} else
		if (TableSQLName == 'tbl_1CObject') {
			UsedIDs1CObject.push(RecordID);
		}
	} else {
		RefreshDataset(Dataset);	
		Dataset.Append();		
	}
	SetDatasetValuesByDataRowNode(DataRowNode, Dataset,
		DefaultFieldNames, DefaultValues);
	try {
		Dataset.Post();
	} catch(e) {
		if (TableSQLName == 'tbl_1CObjectFields') {
			Log.Write(2, FormatStr("Ошибка загрузки. [Info: Таблица=%2, NameTS=%3, "+
				"Name1C=%4, I1CObjectID=%5, E1CObjectID=%6, ObjectID=%7] %1", e.message, 
				TableSQLName, Dataset.ValAsStr('NameTS'), Dataset.ValAsStr('Name1C'),
				Dataset.ValAsStr('I1CObjectID'), Dataset.ValAsStr('E1CObjectID'), 
				Dataset.ValAsStr('ObjectID')));
		} else {
			Log.Write(2, FormatStr("Ошибка загрузки. [Info: Таблица=%2, Name=%3] %1", 
				e.message, TableSQLName, Dataset.ValAsStr('Name')));
		}
		Dataset.Close();
	}
}

function SetDatasetValuesByDataRowNode(DataRowNode, Dataset, DefaultFieldNames,
	 DefaultValues) {
	var DataField;
	var DataFieldName;
	var DefaultValue;
	var PreValue;
	for (var i = 0; i < Dataset.DataFields.Count; i++) {
		DataField = Dataset.DataFields.Items(i);
		DataFieldName = DataField.Name;
		if (IsStringInArray(DataFieldName, DefaultFieldNames)) {
			if (DataFieldName == 'ID') {
				DataField.Value = Connector.GenGUID();
				PreValue = DataRowNode.GetAttributeAsStr(DataFieldName, '');
				ReplacedIDs(PreValue) = DataField.Value;
			} else {
				DefaultValue = DefaultValues(DataFieldName);
				if (Assigned(DefaultValue)) {
					PreValue = DataRowNode.GetAttributeAsStr(DataFieldName, '');
					if (IsEmptyValue(DefaultValue(PreValue))) {
						DataField.Value = null;
					} else {
						DataField.Value = DefaultValue(PreValue);
					}
				} else {
					DataField.Value = DefaultValues(DataField.Name);
				}
			}
			continue;
		} else {
			
		}
		if (DataRowNode.GetAttributeAsStr(DataField.Name, '') == 'IsNull') {
			DataField.Value = null;
			continue;
		}
		switch (DataField.FieldType) {
			case dftCalc:
				continue;
			break;
			case dftString:
			case dftEnum:
			case dftLookup:
			case dftBlob:
				PreValue = DataRowNode.GetAttributeAsStr(DataFieldName, '');
				if (System.IsValidGUIDString(PreValue) && 
					!IsEmptyValue(ReplacedIDs(PreValue))) {
					DataField.Value = ReplacedIDs(PreValue);
				} else {
					DataField.Value = PreValue;
				}
			break;
			case dftInteger:
				DataField.Value = 
					DataRowNode.GetAttributeAsInt(DataFieldName, 0);
			break;
			case dftFloat:
				DataField.Value = 
					DataRowNode.GetAttributeAsFloat(DataFieldName, 0);
			break;
			case dftBool:
				DataField.Value = 
					DataRowNode.GetAttributeAsBool(DataFieldName, false);	
			break;
			case dftDateTime:
				DataField.Value = 
					DataRowNode.GetAttributeAsStr(DataFieldName, 0);
			break;
		}
	}	
}

function SafeExecScriptFunction(ScriptItem, FunctionName, Param1, Param2, Param3, Param4) {
	if (!Assigned(ScriptItem) || IsEmptyValue(FunctionName)) {
		return; 
	}
	var Result = ScriptItem.ScriptControl.Run(FunctionName, Param1, Param2, Param3, Param4);
	return Result;
}

function ConvertStringSimple(aString) {
	var Result = '';
	var Code;
	var Delta = 332;
	for (var i = 0, Count = aString.length; i < Count; i++) {
		Delta += aString.charCodeAt(i);
		Code = Delta + '';
		Result += (Code.length + 11) + '' + Code;
	}
	return Result;
}

function UnConvertStringSimple(aString) {
	var Result = '';
	var Code;
	var Delta = 332;
	var i = 0;
	var a,b,c;
	var Count = aString.length;
	while (true) {
		if (i >= Count) {
			break;
		}
		a = aString.substr(i,2)*1 - 11;
		b = aString.substr(i + 2,a)*1;
		Result += String.fromCharCode(b - Delta);
		Delta = b;
		i += a+2;
	}
	return Result;
}

function ShowWaitWindow(Msg) {
    if (Assigned(WindowUtils.WaitWindow)) {
        CloseWaitWindow();
    };
         var WaitWindow = GetSingleItemByCode('wnd_Wait', 'scr_WindowUtils');
    if (!IsEmptyValue(Msg)) {
		WaitWindow.ComponentsByName('edtWaitMessage').Caption = Msg;
		}
    WaitWindow.Show();
	System.BeginProcessing();
	System.ProcessMessages();
	WaitWindow.Prepare();
	WindowUtils.WaitWindow = WaitWindow;
}

function CloseWaitWindow() {
    System.EndProcessing();
    if (Assigned(WindowUtils.WaitWindow)) {
        var WaitWindow = WindowUtils.WaitWindow;
        System.ProcessMessages();
        System.EndProcessing();
        WaitWindow.Close();
        WindowUtils.WaitWindow = null;
        System.ProcessMessages();        
    };
}