Comparer le texte

Encuentra la diferencia entre dos archivos de texto

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

Outils

Diffchecker Desktop The most secure way to run Diffchecker. Get the Diffchecker Desktop app: your diffs never leave your computer!Get Desktop

Untitled diff

Created 10 years agoDiff never expires

20 removals

762 lines

29 additions

772 lines

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

// 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

Les différences enregistrées

Texte d'origine

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 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 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 GetRecordID(ImportObject, Dataset){
	var PrimaryKeys = GetPrimaryKeysStringForObject(Dataset, ImportObject);
	var ID = ImportObject.Records[PrimaryKeys.Value];
	if (IsEmptyGUID(ID)){
		ID = null;
	}
	return ID;
}

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

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 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 GetSettingsNode(XMLStorage) {
	return XMLStorage.RootNode.GetChildNode(SettingsNodeName);
}

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

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 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 GetLeetersFromGUID(GUID) {
	GUID = new String(GUID);
	var re = new RegExp("[{}-]","ig"); 		
	return GUID.replace(re, '');
}

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;
}

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

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 GetCustomLogFileName(LogName) {
	CreateFolder(Connector.LogsDirectory);
	return Connector.LogsDirectory + LogName+ '_' + 
			DateToStr(new Date(System.Now()), '') + '_' +TimeToStr(new Date(System.Now()), '')  + '.log';
}

Texte modifié

Open file

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

var DataflowUtils = new Object();

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 GetTableFieldTypeByColumnNode(Node){
	var Type = -1;
	var Field = GetTableFieldByColumnNode(Node);
	if (Assigned(Field)){
		Type = Field.SQLDataType;
	}
	return Type;
}

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 ImportPreventEditingHandler(Message, IsHandled) {
	DataflowUtils.ImportErrorMessage = Message;
	IsHandled.Value = true;
}

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;
}

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 ExpandTreeGridAndLocateToRootNode(TreeGrid){
	TreeGrid.ExpandAll();
	TreeGrid.DatasetLink.Dataset.Locate(TreeGrid.ParentDatafieldName, null);
}

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

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

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

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;
}

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

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

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 CloseWaitWindow() {
    System.EndProcessing();
    if (Assigned(WindowUtils.WaitWindow)) {
        var WaitWindow = WindowUtils.WaitWindow;
        System.ProcessMessages();
        System.EndProcessing();
        WaitWindow.Close();
        WindowUtils.WaitWindow = null;
        System.ProcessMessages();        
    };
}