private void EmitTableSections(ClassGenerationContext classContext, string tableSectionsName,
ConfigurationItemDescriptor descriptor)
{
var tableSections = ComHelpers.GetProperty(classContext.comObject, tableSectionsName);
foreach (var tableSection in (IEnumerable)tableSections)
{
var tableSectionName = Call.Имя(tableSection);
var nestedClassContext = new ClassGenerationContext
{
comObject = tableSection,
descriptor = descriptor,
generationContext = classContext.generationContext,
target = new ClassModel
{
Name = "ТабличнаяЧасть" + tableSectionName
}
};
EmitClass(nestedClassContext);
classContext.EmitNestedClass(nestedClassContext.target);
classContext.EmitProperty(new PropertyModel
{
Type = string.Format("List<{0}>", nestedClassContext.target.Name),
PropertyName = tableSectionName
});
}
}
private int?GetMaxLength(object attribute)
{
var type = ComHelpers.GetProperty(attribute, "Тип");
var typesObject = ComHelpers.Invoke(type, "Типы");
var typesCount = Call.Количество(typesObject);
if (typesCount != 1)
{
return(null);
}
var typeObject = Call.Получить(typesObject, 0);
var stringPresentation = globalContext.String(typeObject);
if (stringPresentation != "Строка")
{
return(null);
}
var квалификаторыСтроки = ComHelpers.GetProperty(type, "КвалификаторыСтроки");
var result = Call.IntProp(квалификаторыСтроки, "Длина");
if (result == 0)
{
return(null);
}
return(result);
}
private string[] GetPropertyTypes(object a)
{
var type = ComHelpers.GetProperty(a, "Тип");
var typesObject = ComHelpers.Invoke(type, "Типы");
var typesCount = Call.Количество(typesObject);
if (typesCount == 0)
{
throw new InvalidOperationException("assertion failure");
}
var types = new string[typesCount];
for (var i = 0; i < typesCount; i++)
{
var typeObject = Call.Получить(typesObject, i);
var stringPresentation = globalContext.String(typeObject);
if (MetadataHelpers.simpleTypesMap.ContainsKey(stringPresentation))
{
return(null);
}
var propertyComObject = Call.НайтиПоТипу(globalContext.Metadata, typeObject);
if (propertyComObject == null)
{
return(null);
}
types[i] = Call.ПолноеИмя(propertyComObject);
}
return(types);
}
private void EmitConstants(GenerationContext context)
{
var constants = ComHelpers.GetProperty(globalContext.Metadata, "Константы");
var constantsCount = Call.Количество(constants);
for (var i = 0; i < constantsCount; i++)
{
var constant = Call.Получить(constants, i);
var typeDescriptor = ExtractType(constant, context);
if (!typeDescriptor.HasValue)
{
continue;
}
var configurationName = new ConfigurationName(ConfigurationScope.Константы,
Call.Имя(constant));
var template = new ConstantFileTemplate
{
Model = new ConstantFileModel
{
Type = typeDescriptor.Value.name,
Name = configurationName.Name,
Synonym = GenerateHelpers.EscapeString(Call.Синоним(constant)),
Namespace = GetNamespaceName(configurationName.Scope),
MaxLength = typeDescriptor.Value.maxLength
}
};
context.Write(configurationName, template.TransformText());
}
}
private void EmitEnum(ConfigurationItem item, GenerationContext context)
{
var model = new EnumFileModel
{
Name = item.Name.Name,
Namespace = GetNamespaceName(item.Name.Scope)
};
var values = ComHelpers.GetProperty(item.ComObject, "ЗначенияПеречисления");
var count = Call.Количество(values);
for (var i = 0; i < count; i++)
{
var value = Call.Получить(values, i);
model.Items.Add(new EnumItemModel
{
Name = Call.Имя(value),
Synonym = GenerateHelpers.EscapeString(Call.Синоним(value))
});
}
var enumFileTemplate = new EnumFileTemplate {
Model = model
};
context.Write(item.Name, enumFileTemplate.TransformText());
}
public static IEnumerable <object> GetAttributes(object comObject, ConfigurationItemDescriptor descriptor)
{
var standardAttributes = ComHelpers.GetProperty(comObject, "СтандартныеРеквизиты");
var isChartOfAccounts = Call.Имя(comObject) == "Хозрасчетный";
foreach (var attr in (IEnumerable)standardAttributes)
{
var name = Call.Имя(attr);
if (isChartOfAccounts && name != "Код" && name != "Наименование")
{
continue;
}
if (standardPropertiesToExclude.Contains(name))
{
continue;
}
yield return(attr);
}
foreach (var propertyName in descriptor.AttributePropertyNames)
{
var attributes = ComHelpers.GetProperty(comObject, propertyName);
var attributesCount = Call.Количество(attributes);
for (var i = 0; i < attributesCount; ++i)
{
yield return(Call.Получить(attributes, i));
}
}
}
private void Write(object comObject, ConfigurationName name, bool?posting)
{
object argument;
string argumentString;
if (name.Scope == ConfigurationScope.егистрыСведений)
{
argument = true;
argumentString = argument.ToString();
}
else
{
var writeModeName = posting.HasValue ? (posting.Value ? "Проведение" : "ОтменаПроведения") : "Запись";
var writeMode = globalContext.ежимЗаписиДокумента();
argument = ComHelpers.GetProperty(writeMode, writeModeName);
argumentString = "РежимЗаписиДокумента." + writeModeName;
}
try
{
ComHelpers.Invoke(comObject, "Write", argument);
}
catch (TargetInvocationException e)
{
const string messageFormat = "error writing document [{0}] with argument [{1}]";
throw new InvalidOperationException(string.Format(messageFormat, name.Fullname, argumentString),
e.InnerException);
}
}
private dynamic EnumValue(string enumName, string enumValue)
{
var enumsObject = ComObject().Перечисления;
var enumObject = ComHelpers.GetProperty(enumsObject, enumName);
return(ComHelpers.GetProperty(enumObject, enumValue));
}
private IEnumerable Execute(BuiltQuery builtQuery)
{
if (EntityHelpers.IsConstant(builtQuery.EntityType))
{
var constantWrapType = builtQuery.EntityType.BaseType;
if (constantWrapType == null)
{
throw new InvalidOperationException("assertion failure");
}
var constantWrap = (Constant)FormatterServices.GetUninitializedObject(builtQuery.EntityType);
var constants = ComHelpers.GetProperty(globalContext.ComObject(), "Константы");
var constant = ComHelpers.GetProperty(constants, builtQuery.EntityType.Name);
var value = ComHelpers.Invoke(constant, "Получить");
constantWrap.ЗначениеНетипизированное = comObjectMapper.MapFrom1C(value,
constantWrapType.GetGenericArguments()[0]);
yield return(constantWrap);
yield break;
}
var queryText = builtQuery.QueryText;
var parameters = builtQuery.Parameters;
parametersConverter.ConvertParametersTo1C(parameters);
var hasReference = ConfigurationName.Get(builtQuery.EntityType).HasReference;
var queryResult = globalContext.Execute(queryText, parameters);
if (hasReference || builtQuery.Projection != null)
{
var projection = builtQuery.Projection != null
? ProjectionMapperFactory.GetMapper(builtQuery.Projection, comObjectMapper)
: null;
var selection = queryResult.Select();
while (selection.Next())
{
if (projection != null)
{
yield return(projection(selection.ComObject));
}
else if (builtQuery.IsCount)
{
yield return(comObjectMapper.MapFrom1C(selection["src_Count"], typeof(int)));
}
else
{
yield return(comObjectMapper.MapFrom1C(selection["Ссылка"], builtQuery.EntityType));
}
}
}
else
{
var valueTable = queryResult.Unload();
foreach (var r in valueTable)
{
yield return(comObjectMapper.MapFrom1C(r.ComObject(), builtQuery.EntityType));
}
}
}
bool IValueSource.TryLoadValue(string name, Type type, out object result)
{
var isUniqueIdentifier = name == EntityHelpers.idPropertyName && type == typeof(Guid?);
var propertyValue = isUniqueIdentifier
? ComHelpers.Invoke(comObject, name)
: ComHelpers.GetProperty(comObject, name);
result = comObjectMapper.MapFrom1C(propertyValue, type);
return(true);
}
private static void UpdateIfExists(Abstract1CEntity target, object source, string propertyName)
{
var property = target.GetType().GetProperty(propertyName);
if (property == null)
{
return;
}
SetValueWithoutTracking(target, property, ComHelpers.GetProperty(source, propertyName));
}
public object GetValue(object queryResultRow)
{
var result = ComHelpers.GetProperty(queryResultRow, Alias);
if (isUniqueIdentifier)
{
result = result == null || result == DBNull.Value
? null
: ComHelpers.Invoke(result, EntityHelpers.idPropertyName);
}
return(result);
}
private EnumMapItem[] GetMappings(Type enumType)
{
var enumeration = ComHelpers.GetProperty(enumerations, enumType.Name);
return(Enum.GetValues(enumType)
.Cast <object>()
.Select(v => new EnumMapItem
{
value = v,
index = Convert.ToInt32(ComHelpers.Invoke(enumeration, "IndexOf",
ComHelpers.GetProperty(enumeration, v.ToString())))
})
.ToArray());
}
private object MapEnumFrom1C(Type enumType, object value1C)
{
var enumeration = ComHelpers.GetProperty(enumerations, enumType.Name);
var valueIndex = Convert.ToInt32(ComHelpers.Invoke(enumeration, "IndexOf", value1C));
var result = mappingSource.EnumMappingsCache.GetOrAdd(enumType, GetMappings)
.SingleOrDefault(x => x.index == valueIndex);
if (result == null)
{
const string messageFormat = "can't map value [{0}] to enum [{1}]";
throw new InvalidOperationException(string.Format(messageFormat,
globalContext.String(value1C), enumType.Name));
}
return(result.value);
}
private EnumMapping[] ExtractEnumMappingsFromCom()
{
var enumsManager = ComHelpers.GetProperty(globalContext.ComObject(), "Перечисления");
var enumsMeta = ComHelpers.GetProperty(globalContext.Metadata, "Перечисления");
var enumsCount = Call.Количество(enumsMeta);
var result = new List <EnumMapping>();
for (var i = 0; i < enumsCount; i++)
{
var enumMeta = Call.Получить(enumsMeta, i);
var enumName = Call.Имя(enumMeta);
var enumManager = ComHelpers.GetProperty(enumsManager, enumName);
var enumValuesMeta = ComHelpers.GetProperty(enumMeta, "ЗначенияПеречисления");
var valuesCount = Call.Количество(enumValuesMeta);
for (var j = 0; j < valuesCount; j++)
{
var enumValueMeta = Call.Получить(enumValuesMeta, j);
var enumValueName = Call.Имя(enumValueMeta);
object enumValue = null;
try
{
enumValue = ComHelpers.GetProperty(enumManager, enumValueName);
}
catch
{
//сраный 1С куда-то проебывает (DISP_E_MEMBERNOTFOUND)
//УсловияПримененияТребованийЗаконодательства.ЕстьТранспортныеСредства
//и только это значения этого енума, остальные на месте
}
if (enumValue != null)
{
var order = Convert.ToInt32(ComHelpers.Invoke(enumManager, "Индекс", enumValue));
result.Add(new EnumMapping
{
enumName = enumName.ToLower(),
enumValueName = enumValueName.ToLower(),
orderIndex = order
});
}
}
}
return(result.ToArray());
}
public void ChangeMustBeStrongerThanTracking()
{
var counterpart = new Counterpart
{
Inn = "7711223344",
Kpp = "771101001",
FullName = "Test counterparty",
Name = "Test counterparty"
};
dynamic counterpartyAccessObject = testObjectsManager.CreateCounterparty(counterpart);
var counterpartContractAccessObject = testObjectsManager.CreateCounterpartContract(counterpartyAccessObject.Ссылка,
new CounterpartyContract
{
CurrencyCode = "643",
Name = "test-contract",
Kind = CounterpartContractKind.Incoming
});
string counterpartyContractCode = counterpartContractAccessObject.Code;
var contract = dataContext.Select <ДоговорыКонтрагентов>()
.Single(x => x.Код == counterpartyContractCode);
if (contract.Владелец.ИНН == "7711223344")
{
contract.Владелец.ИНН = "7711223345";
contract.Владелец = new Контрагенты
{
ИНН = "7711223355",
Наименование = "Test counterparty 2",
НаименованиеПолное = "Test counterparty 2"
};
}
dataContext.Save(contract);
var valueTable = globalContext.Execute("ВЫБРАТЬ * ИЗ Справочник.ДоговорыКонтрагентов ГДЕ Код=&Code",
new Dictionary <string, object>
{
{ "Code", contract.Код }
}).Unload();
Assert.That(valueTable.Count, Is.EqualTo(1));
Assert.That(ComHelpers.GetProperty(valueTable[0]["Владелец"], "Наименование"), Is.EqualTo("Test counterparty 2"));
}
private static TypeInfo?GetTypeInfoOrNull(GlobalContext globalContext, object typeDescriptor, object type)
{
var typeAsString = globalContext.String(type);
if (typeAsString == "Число" || typeAsString == "Number")
{
var квалификаторыЧисла = ComHelpers.GetProperty(typeDescriptor, "КвалификаторыЧисла");
var floatLength = Convert.ToInt32(ComHelpers.GetProperty(квалификаторыЧисла, "РазрядностьДробнойЧасти"));
var digits = Convert.ToInt32(ComHelpers.GetProperty(квалификаторыЧисла, "Разрядность"));
return(TypeInfo.Simple(floatLength == 0 ? (digits < 10 ? "int" : "long") : "decimal"));
}
if (typeAsString == "Строка" || typeAsString == "String")
{
var квалификаторыСтроки = ComHelpers.GetProperty(typeDescriptor, "КвалификаторыСтроки");
var maxLength = Call.IntProp(квалификаторыСтроки, "Длина");
return(TypeInfo.Simple("string", maxLength == 0 ? (int?)null : maxLength));
}
if (typeAsString == "Хранилище значения" || typeAsString == "Value storage")
{
return(null);
}
string typeName;
if (simpleTypesMap.TryGetValue(typeAsString, out typeName))
{
return(TypeInfo.Simple(typeName));
}
var comObject = GetMetaByType(globalContext, type);
var fullName = Call.ПолноеИмя(comObject);
var name = ConfigurationName.ParseOrNull(fullName);
if (!name.HasValue)
{
return(null);
}
return(new TypeInfo {
configurationItem = new ConfigurationItem(name.Value, comObject)
});
}
public static List <TypeInfo> GetTypesOrNull(this GlobalContext globalContext, object item)
{
var typeDescriptor = ComHelpers.GetProperty(item, "Тип");
var types = ComHelpers.Invoke(typeDescriptor, "Типы");
var typesCount = Call.Количество(types);
if (typesCount == 0)
{
throw new InvalidOperationException("assertion failure");
}
var result = new List <TypeInfo>();
for (var i = 0; i < typesCount; i++)
{
var typeObject = Call.Получить(types, i);
var typeInfo = GetTypeInfoOrNull(globalContext, typeDescriptor, typeObject);
if (typeInfo.HasValue)
{
result.Add(typeInfo.Value);
}
}
return(result.Count == 0 ? null : result);
}
private void Save(Abstract1CEntity source, object comObject, Stack <object> pending)
{
if (!source.Controller.IsDirty)
{
return;
}
if (pending.Contains(source))
{
const string messageFormat = "cycle detected for entity type [{0}]: [{1}]";
throw new InvalidOperationException(string.Format(messageFormat, source.GetType().FormatName(),
pending
.Reverse()
.Select(x => x is Abstract1CEntity ? x.GetType().FormatName() : x)
.JoinStrings("->")));
}
pending.Push(source);
Metadata metadata;
ConfigurationName?configurationName;
if (comObject == null)
{
configurationName = ConfigurationName.Get(source.GetType());
metadata = metadataAccessor.GetMetadata(configurationName.Value);
comObject = GetComObjectForEditing(configurationName.Value, source);
}
else
{
metadata = null;
configurationName = null;
}
bool?newPostingValue = null;
var changeLog = source.Controller.Changed;
if (changeLog != null)
{
foreach (var p in changeLog)
{
var value = p.Value;
if (p.Key == "Проведен" && configurationName.HasValue &&
configurationName.Value.Scope == ConfigurationScope.Документы)
{
newPostingValue = (bool?)value;
continue;
}
pending.Push(p.Key);
SaveProperty(p.Key, p.Value, comObject, pending, metadata);
pending.Pop();
}
}
var needPatchWithOriginalValues = configurationName.HasValue &&
configurationName.Value.Scope == ConfigurationScope.егистрыСведений &&
source.Controller.ValueSource != null &&
!source.Controller.ValueSource.Writable &&
changeLog != null;
if (needPatchWithOriginalValues)
{
var backingStorage = source.Controller.ValueSource.GetBackingStorage();
foreach (var r in metadata.Requisites)
{
if (!changeLog.ContainsKey(r.Name))
{
pending.Push(r);
var value = ComHelpers.GetProperty(backingStorage, r.Name);
SaveProperty(r.Name, value, comObject, pending, metadata);
pending.Pop();
}
}
}
object valueSourceComObject;
if (configurationName.HasValue)
{
if (!newPostingValue.HasValue && configurationName.Value.Scope == ConfigurationScope.Документы)
{
var oldPostingValue = Convert.ToBoolean(ComHelpers.GetProperty(comObject, "Проведен"));
if (oldPostingValue)
{
Write(comObject, configurationName.Value, false);
newPostingValue = true;
}
}
Write(comObject, configurationName.Value, newPostingValue);
switch (configurationName.Value.Scope)
{
case ConfigurationScope.Справочники:
UpdateIfExists(source, comObject, "Код");
break;
case ConfigurationScope.Документы:
UpdateIfExists(source, comObject, "Номер");
break;
}
if (configurationName.Value.HasReference)
{
valueSourceComObject = ComHelpers.GetProperty(comObject, "Ссылка");
UpdateId(valueSourceComObject, source, configurationName.Value);
}
else
{
valueSourceComObject = comObject;
}
}
else
{
UpdateIfExists(source, comObject, "НомерСтроки");
valueSourceComObject = comObject;
}
var valueSourceIsWriteable = configurationName.HasValue &&
configurationName.Value.Scope == ConfigurationScope.егистрыСведений;
source.Controller.ResetDirty(new ComValueSource(valueSourceComObject, comObjectMapper,
valueSourceIsWriteable));
pending.Pop();
}
public string GetString(string name)
{
return(Convert.ToString(ComHelpers.GetProperty(comObject, name)));
}
public object this[string name]
{
get { return(ComHelpers.GetProperty(comObject, name)); }
}
public static int IntProp(object comObject, string name)
{
return(Convert.ToInt32(ComHelpers.GetProperty(comObject, name)));
}
public static string StringProp(object comObject, string name)
{
return(Convert.ToString(ComHelpers.GetProperty(comObject, name)));
}
private TypeDescriptor?GetTypeDescriptor(object metadataItem, string fullname, GenerationContext context)
{
var type = ComHelpers.GetProperty(metadataItem, "Тип");
var typesObject = ComHelpers.Invoke(type, "Типы");
var typesCount = Call.Количество(typesObject);
if (typesCount == 0)
{
const string messageFormat = "no types for [{0}]";
throw new InvalidOperationException(string.Format(messageFormat, fullname));
}
object typeObject;
string stringPresentation;
if (typesCount > 1)
{
for (var i = 0; i < typesCount; i++)
{
typeObject = Call.Получить(typesObject, i);
stringPresentation = globalContext.String(typeObject);
if (stringPresentation != "Число" && !MetadataHelpers.simpleTypesMap.ContainsKey(stringPresentation))
{
var configurationItem = FindByType(typeObject);
if (configurationItem != null)
{
context.EnqueueIfNeeded(configurationItem);
}
}
}
return(new TypeDescriptor {
dotnetType = "object"
});
}
typeObject = Call.Получить(typesObject, 0);
stringPresentation = globalContext.String(typeObject);
string typeName;
if (MetadataHelpers.simpleTypesMap.TryGetValue(stringPresentation, out typeName))
{
if (typeName == null)
{
return(null);
}
int?maxLength;
if (typeName == "string")
{
var квалификаторыСтроки = ComHelpers.GetProperty(type, "КвалификаторыСтроки");
maxLength = Call.IntProp(квалификаторыСтроки, "Длина");
if (maxLength == 0)
{
maxLength = null;
}
}
else
{
maxLength = null;
}
return(new TypeDescriptor {
dotnetType = typeName, maxLength = maxLength
});
}
if (stringPresentation == "Число")
{
var квалификаторыЧисла = ComHelpers.GetProperty(type, "КвалификаторыЧисла");
var floatLength = Convert.ToInt32(ComHelpers.GetProperty(квалификаторыЧисла, "РазрядностьДробнойЧасти"));
var digits = Convert.ToInt32(ComHelpers.GetProperty(квалификаторыЧисла, "Разрядность"));
return(new TypeDescriptor
{
dotnetType = floatLength == 0 ? (digits < 10 ? "int" : "long") : "decimal"
});
}
var propertyItem = FindByType(typeObject);
if (propertyItem == null)
{
return(null);
}
context.EnqueueIfNeeded(propertyItem);
typeName = FormatClassName(propertyItem.Name);
if (propertyItem.Name.Scope == ConfigurationScope.Перечисления)
{
typeName = typeName + "?";
}
return(new TypeDescriptor {
dotnetType = typeName
});
}
public object MapEnumTo1C(object value)
{
var enumeration = ComHelpers.GetProperty(enumerations, value.GetType().Name);
return(ComHelpers.GetProperty(enumeration, value.ToString()));
}
public ComObjectMapper(MappingSource mappingSource, GlobalContext globalContext)
{
this.mappingSource = mappingSource;
this.globalContext = globalContext;
enumerations = ComHelpers.GetProperty(globalContext.ComObject(), "Перечисления");
}
public object GetManager(ConfigurationName name)
{
var scopeManager = Get(name.Scope.ToString());
return(ComHelpers.GetProperty(scopeManager, name.Name));
}
private void SaveProperty(string name, object value, object comObject, Stack <object> pending, Metadata metadata)
{
var list = value as IList;
if (list != null)
{
var tableSection = ComHelpers.GetProperty(comObject, name);
ComHelpers.Invoke(tableSection, "Очистить");
foreach (Abstract1CEntity item in (IList)value)
{
Save(item, ComHelpers.Invoke(tableSection, "Добавить"), pending);
}
return;
}
var syncList = value as SyncList;
if (syncList != null)
{
var tableSection = ComHelpers.GetProperty(comObject, name);
foreach (var cmd in syncList.Commands)
{
switch (cmd.CommandType)
{
case SyncList.CommandType.Delete:
var deleteCommand = (SyncList.DeleteCommand)cmd;
ComHelpers.Invoke(tableSection, "Удалить", deleteCommand.index);
break;
case SyncList.CommandType.Insert:
var insertCommand = (SyncList.InsertCommand)cmd;
var newItemComObject = ComHelpers.Invoke(tableSection, "Вставить", insertCommand.index);
pending.Push(insertCommand.index);
Save(insertCommand.item, newItemComObject, pending);
pending.Pop();
break;
case SyncList.CommandType.Move:
var moveCommand = (SyncList.MoveCommand)cmd;
ComHelpers.Invoke(tableSection, "Сдвинуть", moveCommand.from, moveCommand.delta);
break;
case SyncList.CommandType.Update:
var updateCommand = (SyncList.UpdateCommand)cmd;
pending.Push(updateCommand.index);
Save(updateCommand.item, Call.Получить(tableSection, updateCommand.index), pending);
pending.Pop();
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return;
}
object valueToSet;
var abstractEntity = value as Abstract1CEntity;
if (abstractEntity != null)
{
Save(abstractEntity, null, pending);
valueToSet = abstractEntity.Controller.ValueSource.GetBackingStorage();
}
else
{
if (metadata != null && value != null)
{
metadata.Validate(name, value);
}
valueToSet = comObjectMapper.MapTo1C(value);
}
ComHelpers.SetProperty(comObject, name, valueToSet);
}
