public SubClassMapping(Type documentType, DocumentMapping parent, string alias = null)
{
DocumentType = documentType;
_inner = new DocumentMapping(documentType);
_parent = parent;
Alias = alias ?? documentType.GetTypeName().Replace(".", "_").SplitCamelCase().Replace(" ", "_").ToLowerInvariant();
}
static string CreateMessage(Type messageType, IEnumerable<Exception> exceptions)
{
SendException sendException = exceptions
.Where(x => x.GetType() == typeof(SendException))
.Cast<SendException>()
.FirstOrDefault();
if (sendException != null)
{
return $"At least one exception occurred publishing {sendException.MessageType.GetTypeName()} to {sendException.Uri}";
}
return $"At least one exception occurred publishing {messageType.GetTypeName()}";
}
private static string FormatInvalidTokenErrorMessage(IMemberAccessToken token, Type type)
{
string memberName;
string memberType;
PropertyToken propertyToken = token as PropertyToken;
if (propertyToken != null)
{
memberType = "property or field";
memberName = propertyToken.PropertyName;
}
else
{
memberType = "indexer with arguments";
var argumentsAsString = ((IndexerToken) token).Arguments.Where(a => a != null).Select(a => a.ToString());
memberName = string.Join(",", argumentsAsString.ToArray());
}
return string.Format(CultureInfo.CurrentCulture, "Invalid {0} - '{1}' for type: {2}", memberType, memberName, type.GetTypeName());
}
private IHydraTask CreateTask(Type taskType)
{
var task = taskType.CreateInstance<IHydraTask>();
var settings = new HydraTaskSettings
{
Id = Guid.NewGuid(),
WorkingFrom = TimeSpan.Zero,
WorkingTo = TimeHelper.LessOneDay,
IsDefault = true,
TaskType = taskType.GetTypeName(false),
};
_entityRegistry.TasksSettings.Add(settings);
_entityRegistry.TasksSettings.DelayAction.WaitFlush();
InitTask(task, settings);
var allSec = _entityRegistry.Securities.ReadById(Core.Extensions.AllSecurityId);
task.Settings.Securities.Add(task.ToTaskSecurity(allSec));
task.Settings.Securities.DelayAction.WaitFlush();
return task;
}
//Private
private EditorViewModel GetEditor(ViewModelConfig viewModelConfig, PropertyInfo prop, Type type)
{
var detailViewAttr = prop.GetCustomAttribute<DetailViewAttribute>();
var systemPropertyAttr = prop.GetCustomAttribute<SystemPropertyAttribute>();
if (detailViewAttr == null && systemPropertyAttr != null)
{
detailViewAttr = new DetailViewAttribute()
{
Name = prop.Name,
Visible = false
};
}
if (detailViewAttr != null)
{
var maxLengthAttr = prop.GetCustomAttribute<MaxLengthAttribute>();
var jsonIgnoreAttr = prop.GetCustomAttribute<JsonIgnoreAttribute>();
bool hideLabel = detailViewAttr.HideLabel;
if (!hideLabel)
hideLabel = String.IsNullOrEmpty(detailViewAttr.Name);
var editor = new EditorViewModel
{
Mnemonic = detailViewAttr.Mnemonic,
ParentViewModelConfig = viewModelConfig,
Title = detailViewAttr.Name ?? prop.Name,
Description = detailViewAttr.Description,
PropertyName = prop.Name,
PropertyType = prop.PropertyType,
IsLabelVisible = !hideLabel,
TabName = detailViewAttr.TabName ?? "[0]Основное",
GroupName = detailViewAttr.GroupName ?? Guid.NewGuid().ToString("N"),
IsReadOnly = !prop.CanWrite || detailViewAttr.ReadOnly,
IsRequired = detailViewAttr.Required,
Order = detailViewAttr.Order,
MaxLength = maxLengthAttr != null ? (int?)maxLengthAttr.Length : null,
DeferredLoading = detailViewAttr.DeferredLoading,
Width = detailViewAttr.Width != 0 ? (int?)detailViewAttr.Width : null,
Height = detailViewAttr.Height != 0 ? (int?)detailViewAttr.Height : null,
JsonIgnore = jsonIgnoreAttr != null,
IsSystemPropery = systemPropertyAttr != null,
Visible = detailViewAttr.Visible,
EditorType =
prop.PropertyType.IsBaseCollection()
? prop.PropertyType.GetGenericType().GenericTypeArguments[0]
: prop.PropertyType,
Relationship = GetRelationship(prop.PropertyType, type),
};
var dataTypeAttr = prop.GetCustomAttribute<PropertyDataTypeAttribute>();
if (dataTypeAttr == null)
{
if (editor.EditorType == typeof(string) && editor.MaxLength == null)
editor.EditorTemplate = "MultilineText";
else if (editor.EditorType == typeof(int) || editor.EditorType == typeof(int?))
editor.EditorTemplate = "Integer";
else if (editor.EditorType == typeof(decimal) || editor.EditorType == typeof(decimal?))
editor.EditorTemplate = "Currency";
else if (editor.EditorType == typeof(double) || editor.EditorType == typeof(double?))
editor.EditorTemplate = "Double";
else if (editor.EditorType == typeof(DateTime) || editor.EditorType == typeof(DateTime?))
editor.EditorTemplate = "Date";
else if (editor.EditorType.IsEnum())
editor.EditorTemplate = "Enum";
else if (editor.EditorType == typeof(Period))
editor.EditorTemplate = "Period";
else if (editor.EditorType == typeof(Icon))
editor.EditorTemplate = "Icon";
else if (typeof(MultilanguageText).IsAssignableFrom(editor.EditorType))
editor.EditorTemplate = "Multilanguage";
else if (editor.EditorType == typeof(Url))
editor.EditorTemplate = "ComplexUrl";
else if (editor.EditorType == typeof(UrlMultilanguageText))
editor.EditorTemplate = "UrlMultilanguageText";
else if (editor.EditorType == typeof(LinkBaseObject))
editor.EditorTemplate = "LinkBaseObject";
else if (editor.EditorType == typeof(MultiEnum))
editor.EditorTemplate = "MultiEnum";
//else if (editor.EditorType == typeof(ValidationObjectBinding))
// editor.EditorTemplate = "ValidationObjectBinding";
else
{
Type easyCollectionEntry =
prop.PropertyType.GetEntryOfUnboundedTypeOfCollection(typeof(EasyCollectionEntry<>));
if (easyCollectionEntry != null)
{
editor.EditorTemplate = "EasyCollection";
editor.ViewModelConfig = _viewModelConfigService.Get(easyCollectionEntry);
}
else
{
switch (editor.Relationship)
{
case Relationship.OneToMany:
if (typeof(FileData).IsAssignableFrom(editor.EditorType))
editor.EditorTemplate = "Files";
else if (typeof(Base.LinkedObjects.Entities.Link).IsAssignableFrom(editor.EditorType))
editor.EditorTemplate = "ListLinkedОbjects";
else
editor.EditorTemplate = "OneToMany";
break;
case Relationship.ManyToMany:
editor.EditorTemplate = "ManyToMany";
break;
case Relationship.One:
editor.EditorTemplate = "BaseObjectOne";
break;
case Relationship.None:
editor.EditorTemplate = editor.EditorType.Name;
break;
}
}
}
}
else
{
editor.EditorTemplate = dataTypeAttr.DataType != PropertyDataType.Custom
? dataTypeAttr.DataType.ToString()
: dataTypeAttr.CustomDataType;
editor.EditorTemplateParams = dataTypeAttr.Params;
}
var configEditor = viewModelConfig.DetailView.Editors.FirstOrDefault(m => m.PropertyName == editor.PropertyName);
if (configEditor != null)
{
if (configEditor.Mnemonic != null)
editor.Mnemonic = configEditor.Mnemonic;
if (configEditor.Title != null)
editor.Title = configEditor.Title;
if (configEditor.IsLabelVisible != null)
editor.IsLabelVisible = configEditor.IsLabelVisible.Value;
if (configEditor.EditorTemplate != null)
editor.EditorTemplate = configEditor.EditorTemplate;
if (configEditor.TabName != null)
editor.TabName = configEditor.TabName;
if (configEditor.IsReadOnly != null)
editor.IsReadOnly = configEditor.IsReadOnly.Value;
if (configEditor.IsRequired != null)
editor.IsRequired = configEditor.IsRequired.Value;
if (configEditor.Order != null)
editor.Order = configEditor.Order.Value;
if (configEditor.Visible != null)
editor.Visible = configEditor.Visible.Value;
}
if (editor.ViewModelConfig == null)
{
editor.ViewModelConfig = _viewModelConfigService.Get(editor.Mnemonic) ?? _viewModelConfigService.Get(editor.EditorType);
if (editor.ViewModelConfig == null && prop.PropertyType.IsAssignableFromBase())
throw new Exception(String.Format("The configuration file is not configured for type \"{0}\"", editor.EditorType.Name));
}
if (String.IsNullOrEmpty(editor.Mnemonic))
editor.Mnemonic = type.GetTypeName();
return editor;
}
return null;
}
private void SetType(Type enumType)
{
this.type = enumType.GetTypeName();
}
/// <summary>
/// Produces the Linq expression that represents a particular FilterDescriptor
/// </summary>
/// <param name="type">Entity type</param>
/// <param name="propertyPath">Left operand: Property on the entity type</param>
/// <param name="filterOperator">One of the FilterOperator enum value</param>
/// <param name="value">Right operand</param>
/// <param name="isCaseSensitive">Boolean that specifies if the string operations are case sensitive or not</param>
/// <returns>Resulting linq expression</returns>
/// <exception cref="ArgumentException">When a filter descriptor references a property that could not be found.</exception>
/// <exception cref="ArgumentException">When an exception occurs attempting to evaluate a filter descriptor.</exception>
/// <exception cref="ArgumentException">When the supplied filter value has a type that cannot be compared to the property type.</exception>
/// <exception cref="NotSupportedException">When attempting to use a property type/operator pair that is not supported.</exception>
public static Expression BuildFilterExpression(
Type type,
string propertyPath,
FilterOperator filterOperator,
object value,
bool isCaseSensitive)
{
Debug.Assert(type != null, "Unexpected null type");
Debug.Assert(propertyPath != null, "Unexpected null propertyPath");
Expression filterExpression = null;
PropertyInfo pi;
Expression propertyExpression;
Expression valueExpression;
try
{
pi = type.GetPropertyInfo(propertyPath);
if (pi == null)
{
throw new ArgumentException(string.Format(
CultureInfo.InvariantCulture,
CommonResources.PropertyNotFound,
propertyPath,
type.GetTypeName()));
}
// TODO: Remove this check.
// It's a duplicate of one done in the DDS, but it's still required for the BuildFilterExpressions Test.
else if (!IsSupportedOperator(pi.PropertyType, filterOperator))
{
throw new NotSupportedException(string.Format(
CultureInfo.InvariantCulture,
DomainDataSourceResources.FilterNotSupported,
propertyPath,
type.GetTypeName(),
pi.PropertyType.GetTypeName(),
filterOperator));
}
propertyExpression = GenerateProperty(type, propertyPath, Expression.Parameter(type, string.Empty));
valueExpression = GenerateConstant(value);
Debug.Assert(propertyExpression != null, "Unexpected null propertyExpression in LinqHelper.BuildFilterExpression");
}
catch (Exception ex)
{
if (ex.IsFatal())
{
throw;
}
throw new ArgumentException(
string.Format(
CultureInfo.InvariantCulture,
DomainDataSourceResources.CannotEvaluateDescriptor,
propertyPath),
ex);
}
try
{
bool isEquality = filterOperator == FilterOperator.IsEqualTo || filterOperator == FilterOperator.IsNotEqualTo;
if (isEquality && !propertyExpression.Type.IsValueType && !valueExpression.Type.IsValueType)
{
if (propertyExpression.Type != valueExpression.Type)
{
if (propertyExpression.Type.IsAssignableFrom(valueExpression.Type))
{
valueExpression = Expression.Convert(valueExpression, propertyExpression.Type);
}
else if (valueExpression.Type.IsAssignableFrom(propertyExpression.Type))
{
propertyExpression = Expression.Convert(propertyExpression, valueExpression.Type);
}
else
{
throw new ArgumentException(string.Format(
CultureInfo.InvariantCulture,
DomainDataSourceResources.IncompatibleOperands,
filterOperator.ToString(),
propertyExpression.Type.GetTypeName(),
valueExpression.Type.GetTypeName()));
}
}
}
else if (propertyExpression.Type.IsEnumType())
{
// Convert the value to compare to the underlying type of the enum,
// preserving nullable and following the same rules the C# compiler does.
// Examples:
// p.Enum > Enum.A => p.Enum > 1
// p.Enum > null => p.Enum > Convert(null, Nullable<int>)
// p.NullableEnum > Enum.A => p.Enum > Convert(Enum.A, Nullable<int>)
// p.NullableEnum > null => p.Enum > Convert(Enum.A, Nullable<int>)
Type underlyingType = Enum.GetUnderlyingType(TypeUtility.GetNonNullableType(propertyExpression.Type));
bool propertyIsNullable = propertyExpression.Type.IsNullableType();
if (propertyIsNullable)
{
underlyingType = typeof(Nullable<>).MakeGenericType(underlyingType);
}
if (valueExpression.Type != underlyingType)
{
if (value != null && !propertyIsNullable)
{
// convert to the underlying value and create a new constant
value = Convert.ChangeType(value, underlyingType, CultureInfo.InvariantCulture);
valueExpression = GenerateConstant(value);
}
else
{
// for nulls or comparisons against a nullable enum, we inject
// a conversion
valueExpression = Expression.Convert(valueExpression, underlyingType);
}
}
// Now that we've converted the enum value, we inject the appropriate conversion
// on the property expression
if (propertyExpression.Type != valueExpression.Type)
{
Expression e;
if ((e = PromoteExpression(propertyExpression, valueExpression.Type, true)) != null)
{
propertyExpression = e;
}
else
{
throw new ArgumentException(string.Format(
CultureInfo.InvariantCulture,
DomainDataSourceResources.IncompatibleOperands,
filterOperator.ToString(),
propertyExpression.Type.GetTypeName(),
valueExpression.Type.GetTypeName()));
}
}
}
else if (pi.PropertyType.IsNullableType() && propertyExpression.Type != valueExpression.Type)
{
ConstantExpression ce = valueExpression as ConstantExpression;
if (ce != null)
{
valueExpression = Expression.Constant(ce.Value, propertyExpression.Type);
}
}
filterExpression = BuildFilterExpression(propertyExpression, filterOperator, valueExpression, isCaseSensitive);
}
catch (Exception ex)
{
if (ex.IsFatal())
{
throw;
}
throw new ArgumentException(
string.Format(
CultureInfo.InvariantCulture,
DomainDataSourceResources.IncompatibleOperands,
filterOperator.ToString(),
propertyExpression.Type.GetTypeName(),
(valueExpression == nullLiteral) ? "null" : valueExpression.Type.GetTypeName()),
ex);
}
return filterExpression;
}
/// <summary>
/// Builds the Linq Expression for the provided propertyPath and type properties
/// </summary>
/// <param name="type">Type that exposes the property</param>
/// <param name="propertyPath">Public property. Can be nested.</param>
/// <returns>Resulting property expression</returns>
/// <exception cref="ArgumentException">When property is not found on the specified type.</exception>
public static Expression BuildPropertyExpression(Type type, string propertyPath)
{
Debug.Assert(type != null, "Unexpected null type");
Debug.Assert(propertyPath != null, "Unexpected null propertyPath");
Expression propertyExpression = GenerateProperty(type, propertyPath, Expression.Parameter(type, string.Empty));
if (propertyExpression == null)
{
throw new ArgumentException(string.Format(
CultureInfo.InvariantCulture,
CommonResources.PropertyNotFound,
propertyPath,
type.GetTypeName()));
}
return propertyExpression;
}
public void Instance(Type pluginType, Instance instance)
{
if (_instanceStack.Any() && _instanceStack.Peek() == instance) return;
if (_instanceStack.Contains(instance))
{
_writer.Line("Bi-Directional Relationship Detected w/ Instance {0}, PluginType {1}", instance.Description, pluginType.GetTypeName());
}
_instanceStack.Push(instance);
if (pluginType != null) _writer.Line("PluginType: " + pluginType.GetFullName());
var lifecycle = _pipeline.DetermineLifecycle(pluginType, instance);
_writer.Line("Lifecycle: " + lifecycle.Description);
var plan = instance.ResolveBuildPlan(pluginType ?? instance.ReturnedType, _pipeline.Policies);
plan.AcceptVisitor(this);
_instanceStack.Pop();
}
public ViewModelConfig CreateViewModelConfig(Type type)
{
if (!type.IsBaseObject() && !type.IsDefined(typeof(ComplexTypeAttribute))) return null;
string serviceName = "";
if (type.IsBaseObject())
{
if (type.IsAssignableFrom(typeof(HCategory)))
serviceName = typeof(IBaseCategoryService<>).GetTypeName();
else if (type.IsAssignableFrom(typeof(ICategorizedItem)))
serviceName = typeof(IBaseCategorizedItemService<>).GetTypeName();
else
serviceName = typeof(IBaseObjectService<>).GetTypeName();
}
return new ViewModelConfig(
mnemonic: type.GetTypeName(),
entity: type.GetTypeName(),
listView: new ListView(),
detailView: new DetailView(),
lookupProperty:
type.IsBaseObject()
? (type.GetProperty("Title") ?? type.GetProperty("Name") ?? type.GetProperty("ID")).Name
: "",
service: serviceName);
}
private void RegisterType(Type type)
{
if (types.ContainsKey(type))
return;
string alias = type.GetTypeName();
while (typeAliases.ContainsKey(alias))
{
alias = IncrementAlias(alias);
}
types.Add(type, alias);
typeAliases.Add(alias, type);
}
