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

Comparing sensitive data, confidential files or internal emails?

Most legal and privacy policies prohibit uploading sensitive data online. Diffchecker Desktop ensures your confidential information never leaves your computer. Work offline and compare documents securely.

Download Diffchecker Desktop Learn more

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