public void Apply_RemovesAllPropertiesThatAreNotDataMembers()
{
// Arrange
Mock<Type> clrType = new Mock<Type>();
clrType.Setup(t => t.GetCustomAttributes(It.IsAny<bool>())).Returns(new[] { new DataContractAttribute() });
Mock<IStructuralTypeConfiguration> type = new Mock<IStructuralTypeConfiguration>(MockBehavior.Strict);
type.Setup(t => t.ClrType).Returns(clrType.Object);
PropertyConfiguration[] mockProperties = new PropertyConfiguration[]
{
CreateMockProperty(new DataMemberAttribute()),
CreateMockProperty(new DataMemberAttribute()),
CreateMockProperty()
};
type.Setup(t => t.Properties).Returns(mockProperties);
type.Setup(t => t.RemoveProperty(mockProperties[2].PropertyInfo)).Verifiable();
// Act
_convention.Apply(type.Object, new Mock<ODataModelBuilder>().Object);
// Assert
type.Verify();
}
/// <summary>
/// Figures out the key properties and marks them as Keys in the EDM model.
/// </summary>
/// <param name="entity">The entity type being configured.</param>
/// <param name="model">The <see cref="ODataModelBuilder"/>.</param>
public override void Apply(EntityTypeConfiguration entity, ODataConventionModelBuilder model)
{
if (entity == null)
{
throw Error.ArgumentNull("entity");
}
// Suppress the EntityKeyConvention if there is any key in EntityTypeConfiguration.
if (entity.Keys.Any() || entity.EnumKeys.Any())
{
return;
}
// Suppress the EntityKeyConvention if base type has any key.
if (entity.BaseType != null && entity.BaseType.Keys().Any())
{
return;
}
PropertyConfiguration key = GetKeyProperty(entity);
if (key != null)
{
entity.HasKey(key.PropertyInfo);
}
}
public override void StartParagraphRendering(PropertyConfiguration textProperty)
{
string opt;
if (PropertyChain.CurrentContextConfiguration != null &&
PropertyChain.CurrentContextConfiguration.TryGetProperty(MarkdownRenderSetting.MD_REGION, out opt))
{
if (opt == MarkdownRenderSetting.MD_REGION_LIST)
{
RenderOut.Append("+ ");
}
else if (opt == MarkdownRenderSetting.MD_REGION_LIST_ORDER)
{
RenderOut.Append("1. ");
}
else if (opt == MarkdownRenderSetting.MD_REGION_LIST_CB)
{
RenderOut.Append("- [ ] ");
}
else if (opt == MarkdownRenderSetting.MD_REGION_QUOTE)
{
RenderOut.Append("> ");
}
}
base.StartParagraphRendering(textProperty);
}
public void Apply_RemovesAllPropertiesThatAreNotDataMembers()
{
// Arrange
Mock <Type> clrType = new Mock <Type>();
clrType.Setup(t => t.GetCustomAttributes(It.IsAny <bool>())).Returns(new[] { new DataContractAttribute() });
Mock <IStructuralTypeConfiguration> type = new Mock <IStructuralTypeConfiguration>(MockBehavior.Strict);
type.Setup(t => t.ClrType).Returns(clrType.Object);
PropertyConfiguration[] mockProperties = new PropertyConfiguration[]
{
CreateMockProperty(new DataMemberAttribute()),
CreateMockProperty(new DataMemberAttribute()),
CreateMockProperty()
};
type.Setup(t => t.Properties).Returns(mockProperties);
type.Setup(t => t.RemoveProperty(mockProperties[2].PropertyInfo)).Verifiable();
// Act
_convention.Apply(type.Object, new Mock <ODataModelBuilder>().Object);
// Assert
type.Verify();
}
/// <summary>
/// Set command parameters for each entity in the given entity collection.
/// </summary>
/// <param name="setAction">Action that will execute for each entity in the collection.</param>
/// <param name="idPropertyConfig">Optional property configuration for
/// entity id property (database generated) that will be populated.</param>
public void SetParametersForEach <TEntity>(Action <IDbParameterCollection, TEntity> setAction,
PropertyConfiguration idPropertyConfig = null)
where TEntity : IEntity
{
ThrowIfDisposed();
_setForEach = new Action <IDbParameterCollection, IEntity>((collection, entity) =>
{
setAction(collection, (TEntity)entity);
});
// For last inserted id
if (idPropertyConfig != null)
{
if (!idPropertyConfig.IsKey)
{
throw new ArgumentException(
"Passed property configuration is not the configuration of a key property");
}
_idPropInfo = typeof(TEntity).GetProperty(idPropertyConfig.PropertyName);
_readLastInsertedId = _command.CommandText.IndexOf("INSERT",
StringComparison.OrdinalIgnoreCase) >= 0 &&
idPropertyConfig.IsIntegerKey;
}
}
public void HasOptionalBinding_AddBindindToNavigationSource()
{
// Assert
ODataModelBuilder builder = new ODataModelBuilder();
var customerType = builder.EntityType <BindingCustomer>();
var navigationSource = builder.EntitySet <BindingCustomer>("Customers");
StructuralTypeConfiguration addressType = builder.StructuralTypes.FirstOrDefault(c => c.Name == "BindingAddress");
Assert.Null(addressType); // Guard
Assert.Empty(customerType.Properties); // Guard
Assert.Null(builder.EntitySets.FirstOrDefault(e => e.Name == "Cities_C")); // Guard
// Act
new BindingPathConfiguration <BindingCustomer>(builder, customerType, navigationSource.Configuration)
.HasSinglePath(c => c.Location)
.HasOptionalBinding(a => a.City, "Cities_C");
// Assert
addressType = builder.StructuralTypes.FirstOrDefault(c => c.Name == "BindingAddress");
Assert.NotNull(addressType);
PropertyConfiguration citiesProperty = Assert.Single(addressType.Properties);
Assert.Equal("City", citiesProperty.Name);
NavigationPropertyConfiguration navigationProperty = Assert.IsType <NavigationPropertyConfiguration>(citiesProperty);
Assert.Equal(EdmMultiplicity.ZeroOrOne, navigationProperty.Multiplicity);
var bindings = navigationSource.FindBinding(navigationProperty);
var binding = Assert.Single(bindings);
Assert.Equal("Cities_C", binding.TargetNavigationSource.Name);
Assert.Equal("Location/City", binding.BindingPath);
}
private static object MapValue(object value, Type valueType, PropertyConfiguration configuration)
{
var globalHandler = PatchEngineCore.Config.GlobalMappingHandler;
var typeHandler = PatchEngineCore.Config.GetMappingHandlerForType(valueType);
var propertyHandler = configuration.MappingHandler;
if (globalHandler != null)
{
var globalHandlerResult = globalHandler(value);
if (!globalHandlerResult.Skipped)
{
value = globalHandlerResult.Value;
}
}
if (typeHandler != null)
{
var typeHandlerResult = typeHandler(value);
if (!typeHandlerResult.Skipped)
{
value = typeHandlerResult.Value;
}
}
if (propertyHandler != null)
{
var propertyHandlerResult = propertyHandler(value);
if (!propertyHandlerResult.Skipped)
{
value = propertyHandlerResult.Value;
}
}
return(value);
}
/// <summary>
/// Get delete SQL query.
/// </summary>
/// <returns>Returns sql query.</returns>
public virtual string GetDeleteSql()
{
StringBuilder sql = new StringBuilder("DELETE FROM ");
StringBuilder whereClause = new StringBuilder("WHERE ");
ReadOnlyCollection <PropertyConfiguration> keyPropConfigs = _configuration.KeyPropertyConfigurations;
PropertyConfiguration cfg = null;
sql.Append(GetQuotedIdentifier(_configuration.TableName) + " ");
for (int i = 0; i < keyPropConfigs.Count; ++i)
{
cfg = keyPropConfigs[i];
if (i != keyPropConfigs.Count - 1)
{
whereClause.Append(GetQuotedIdentifier(cfg.ColumnName) + " = " + "@" + cfg.PropertyName + " AND ");
}
else
{
whereClause.Append(GetQuotedIdentifier(cfg.ColumnName) + " = " + "@" + cfg.PropertyName + ";");
}
}
sql.Append(whereClause);
return(sql.ToString());
}
public PropertyConfigurator(TabConfigurator parent, string @alias)
{
this.parent = parent;
Configuration = new PropertyConfiguration(alias);
parent.Properties.Add(alias, this);
parent.Configuration.Properties.Add(alias, Configuration);
}
public override void AddPropertyFacetsConfiguration([NotNull] PropertyConfiguration propertyConfiguration)
{
Check.NotNull(propertyConfiguration, nameof(propertyConfiguration));
base.AddPropertyFacetsConfiguration(propertyConfiguration);
AddUseIdentityFacetConfiguration(propertyConfiguration);
}
/// <summary>
/// Initializes a new instance of the <see cref="QueryableRestrictions"/> class.
/// </summary>
/// <param name="propertyConfiguration">The PropertyConfiguration containing queryable restrictions.</param>
public QueryableRestrictions(PropertyConfiguration propertyConfiguration)
{
NonFilterable = propertyConfiguration.NonFilterable;
Unsortable = propertyConfiguration.Unsortable;
NotNavigable = propertyConfiguration.NotNavigable;
NotExpandable = propertyConfiguration.NotExpandable;
}
public virtual void AddValueGeneratedFacetConfiguration(
[NotNull] PropertyConfiguration propertyConfiguration)
{
Check.NotNull(propertyConfiguration, nameof(propertyConfiguration));
var valueGenerated = propertyConfiguration.Property.ValueGenerated;
switch (valueGenerated)
{
case ValueGenerated.OnAdd:
// If this property is the single integer primary key on the EntityType then
// KeyConvention assumes ValueGeneratedOnAdd() so there is no need to add it.
if (_keyConvention.ValueGeneratedOnAddProperty(
new List <Property> {
(Property)propertyConfiguration.Property
},
(EntityType)propertyConfiguration.EntityConfiguration.EntityType) == null)
{
propertyConfiguration.AddFacetConfiguration(
new FacetConfiguration("ValueGeneratedOnAdd()"));
}
break;
case ValueGenerated.OnAddOrUpdate:
propertyConfiguration.AddFacetConfiguration(new FacetConfiguration("ValueGeneratedOnAddOrUpdate()"));
break;
}
}
// remove the base type properties from the derived types.
internal void RemoveBaseTypeProperties(StructuralTypeConfiguration derivedStructrualType,
StructuralTypeConfiguration baseStructuralType)
{
IEnumerable <StructuralTypeConfiguration> typesToLift = new[] { derivedStructrualType }
.Concat(this.DerivedTypes(derivedStructrualType));
foreach (PropertyConfiguration property in baseStructuralType.Properties
.Concat(baseStructuralType.DerivedProperties()))
{
foreach (StructuralTypeConfiguration structuralType in typesToLift)
{
PropertyConfiguration derivedPropertyToRemove = structuralType.Properties.SingleOrDefault(
p => p.PropertyInfo.Name == property.PropertyInfo.Name);
if (derivedPropertyToRemove != null)
{
structuralType.RemoveProperty(derivedPropertyToRemove.PropertyInfo);
}
}
}
foreach (PropertyInfo ignoredProperty in baseStructuralType.IgnoredProperties())
{
foreach (StructuralTypeConfiguration structuralType in typesToLift)
{
PropertyConfiguration derivedPropertyToRemove = structuralType.Properties.SingleOrDefault(
p => p.PropertyInfo.Name == ignoredProperty.Name);
if (derivedPropertyToRemove != null)
{
structuralType.RemoveProperty(derivedPropertyToRemove.PropertyInfo);
}
}
}
}
public IPropertyConfigurationQueryOptions <TContext, TEntity, TProperty> ConfigureProperty <TProperty>(Expression <Func <TEntity, TProperty> > propertyExpression)
{
var propertyConfiguration = new PropertyConfiguration((MemberExpression)propertyExpression.Body);
((List <IPropertyConfiguration>)_dbSetConfiguration.PropertyConfigurations).Add(propertyConfiguration);
return(new PropertyConfigurationQueryOptions <TContext, TEntity, TProperty>(this, _dbSetConfiguration, propertyConfiguration));
}
public void Ignore_SetToTrue(bool ignoreValue)
{
PropertyConfiguration pc = new PropertyConfiguration();
pc.Ignore(ignoreValue);
Assert.AreEqual(ignoreValue, pc.IsIgnored);
}
private void ReapplyPropertyConvention(PropertyConfiguration property,
StructuralTypeConfiguration edmTypeConfiguration)
{
foreach (IEdmPropertyConvention propertyConvention in _conventions.OfType <IEdmPropertyConvention>())
{
propertyConvention.Apply(property, edmTypeConfiguration, this);
}
}
protected PonyTextContext(AbstractTextElement textElement, IProcessorFactory processorFactory)
{
this.textElement = textElement;
ProcessorFactory = processorFactory;
MacroTable = new MacroTable();
ContextProperty = new PropertyConfiguration();
Metadata = new ContextMetadata();
}
/// <summary>
/// Find a list of role names by user id.
/// </summary>
/// <param name="userId">Target user id.</param>
/// <returns>Returns a list of roles if found; otherwise, returns empty list.</returns>
public IList <string> FindRoleNamesByUserId(TKey userId)
{
EntityConfiguration <TUserRole> userRoleCfg = StorageContext.GetEntityConfiguration <TUserRole>();
PropertyConfiguration userIdPropCfg = userRoleCfg.Property(p => p.UserId);
PropertyConfiguration roleNamePropCfg = Configuration.Property(p => p.Name);
DbCommand command = StorageContext.CreateCommand();
command.CommandText = String.Format(
@"SELECT {2} FROM {0} INNER JOIN {1} ON ({0}.{3} = {1}.{4}) WHERE {5} = @{6};",
QueryBuilder.GetQuotedIdentifier(Configuration.TableName),
QueryBuilder.GetQuotedIdentifier(userRoleCfg.TableName),
// Configured field names
QueryBuilder.GetQuotedIdentifier(roleNamePropCfg.ColumnName),
QueryBuilder.GetQuotedIdentifier(Configuration.Property(p => p.Id).ColumnName),
QueryBuilder.GetQuotedIdentifier(userRoleCfg.Property(p => p.RoleId).ColumnName),
QueryBuilder.GetQuotedIdentifier(userIdPropCfg.ColumnName),
// Parameter names
userIdPropCfg.PropertyName);
DbCommandContext cmdContext = new DbCommandContext(command);
cmdContext.Parameters[userIdPropCfg.PropertyName].Value = userId;
DbDataReader reader = null;
List <string> list = new List <string>();
string roleName = null;
StorageContext.Open();
try
{
reader = cmdContext.ExecuteReader();
while (reader.Read())
{
roleName = reader.GetSafeString(roleNamePropCfg.ColumnName);
list.Add(roleName);
}
}
catch (Exception)
{
throw;
}
finally
{
if (reader != null)
{
reader.Close();
}
cmdContext.Dispose();
StorageContext.Close();
}
return(list);
}
/// <summary>
/// Initializes a new instance of the <see cref="QueryableRestrictions"/> class.
/// </summary>
/// <param name="propertyConfiguration">The PropertyConfiguration containing queryable restrictions.</param>
public QueryableRestrictions(PropertyConfiguration propertyConfiguration)
{
NotFilterable = propertyConfiguration.NotFilterable;
NotSortable = propertyConfiguration.NotSortable;
NotNavigable = propertyConfiguration.NotNavigable;
NotExpandable = propertyConfiguration.NotExpandable;
NotCountable = propertyConfiguration.NotCountable;
_autoExpand = propertyConfiguration.AutoExpand;
}
public void HasName_NameAccepted()
{
string mappedName = "test";
PropertyConfiguration pc = new PropertyConfiguration();
pc.HasName(mappedName);
Assert.AreEqual(mappedName, pc.Name);
}
private PropertyConfiguration ParsePropertyConfig(XElement propertyElement)
{
var property = new PropertyConfiguration();
property.Name = GetAttributeValue(propertyElement, "name");
property.Selector = GetAttributeValue(propertyElement, "selector");
return property;
}
/// <summary>
/// Create the default ABI set.
/// </summary>
public AndroidAbis()
{
lock (typeof(AndroidAbis)) {
if (propertyConfiguration == null)
{
propertyConfiguration = new PropertyConfiguration();
}
}
abis = new HashSet <string>(Supported);
}
/// <summary>
/// Initializes a new instance of the <see cref="QueryableRestrictions"/> class.
/// </summary>
/// <param name="propertyConfiguration">The PropertyConfiguration containing queryable restrictions.</param>
public QueryableRestrictions(PropertyConfiguration propertyConfiguration)
{
this.NotFilterable = propertyConfiguration.NotFilterable;
this.NotSortable = propertyConfiguration.NotSortable;
this.NotNavigable = propertyConfiguration.NotNavigable;
this.NotExpandable = propertyConfiguration.NotExpandable;
this.NotCountable = propertyConfiguration.NotCountable;
this.DisableAutoExpandWhenSelectIsPresent = propertyConfiguration.DisableAutoExpandWhenSelectIsPresent;
this._autoExpand = propertyConfiguration.AutoExpand;
}
public void HasSinglePath_AddBindindPath(bool required, bool contained)
{
// Assert
ODataModelBuilder builder = new ODataModelBuilder();
var customerType = builder.EntityType <BindingCustomer>();
var navigationSource = builder.EntitySet <BindingCustomer>("Customers");
StructuralTypeConfiguration addressType = builder.StructuralTypes.FirstOrDefault(c => c.Name == "BindingAddress");
Assert.Null(addressType); // Guard
Assert.Empty(customerType.Properties); // Guard
// Act
var binding = new BindingPathConfiguration <BindingCustomer>(builder, customerType, navigationSource.Configuration);
var newBinding = binding.HasSinglePath(c => c.Location, required, contained);
// Assert
addressType = builder.StructuralTypes.FirstOrDefault(c => c.Name == "BindingAddress");
Assert.NotNull(addressType);
PropertyConfiguration locationProperty = Assert.Single(customerType.Properties);
Assert.Equal("Location", locationProperty.Name);
if (contained)
{
Assert.Equal(EdmTypeKind.Entity, addressType.Kind);
Assert.Equal(PropertyKind.Navigation, locationProperty.Kind);
NavigationPropertyConfiguration navigationProperty = Assert.IsType <NavigationPropertyConfiguration>(locationProperty);
if (required)
{
Assert.Equal(EdmMultiplicity.One, navigationProperty.Multiplicity);
}
else
{
Assert.Equal(EdmMultiplicity.ZeroOrOne, navigationProperty.Multiplicity);
}
Assert.True(navigationProperty.ContainsTarget);
}
else
{
Assert.Equal(EdmTypeKind.Complex, addressType.Kind);
Assert.Equal(PropertyKind.Complex, locationProperty.Kind);
ComplexPropertyConfiguration complexProperty = Assert.IsType <ComplexPropertyConfiguration>(locationProperty);
Assert.Equal(!required, complexProperty.OptionalProperty);
Assert.Equal(typeof(BindingAddress), complexProperty.RelatedClrType);
}
// different bindings
Assert.NotSame(binding, newBinding);
Assert.Equal("", binding.BindingPath);
Assert.IsType <BindingPathConfiguration <BindingAddress> >(newBinding);
Assert.Equal("Location", newBinding.BindingPath);
}
public void Convert(Metadata data, PropertyConfiguration configuration)
{
if (data == null) throw new ArgumentNullException("data");
if (configuration == null) throw new ArgumentNullException("configuration");
Configuration = configuration;
ConvertToConfiguration(data);
if (adapter != null)
{
adapter.Convert(data, configuration);
}
}
protected PropertyConfiguration AddOrGetPropertyConfiguration(MemberInfo memberInfo)
{
if (this.propertiesMapping.TryGetValue(memberInfo, out var pc))
{
return(pc);
}
pc = new PropertyConfiguration();
this.propertiesMapping.Add(memberInfo, pc);
return(pc);
}
public virtual void AddPropertyFacetsConfiguration([NotNull] PropertyConfiguration propertyConfiguration)
{
Check.NotNull(propertyConfiguration, nameof(propertyConfiguration));
AddRequiredFacetConfiguration(propertyConfiguration);
AddMaxLengthFacetConfiguration(propertyConfiguration);
AddStoreGeneratedPatternFacetConfiguration(propertyConfiguration);
AddColumnNameFacetConfiguration(propertyConfiguration);
AddColumnTypeFacetConfiguration(propertyConfiguration);
AddDefaultValueFacetConfiguration(propertyConfiguration);
AddDefaultExpressionFacetConfiguration(propertyConfiguration);
}
/// <summary>
/// Check whether the user belongs to the given role.
/// </summary>
/// <param name="userId">Target user id.</param>
/// <param name="roleName">Target role name.</param>
/// <returns>Returns true if belongs; otherwise, returns false.</returns>
public bool IsInRole(TKey userId, string roleName)
{
EntityConfiguration <TUserRole> userRoleCfg = StorageContext.GetEntityConfiguration <TUserRole>();
PropertyConfiguration userIdPropCfg = userRoleCfg.Property(p => p.UserId);
PropertyConfiguration roleNamePropCfg = Configuration.Property(p => p.Name);
DbCommand command = StorageContext.CreateCommand();
command.CommandText = String.Format(
@"SELECT {2} FROM {0} INNER JOIN {1} ON ({0}.{2} = {1}.{3})
WHERE {4} = @{6} AND LOWER({5}) = LOWER(@{7});",
QueryBuilder.GetQuotedIdentifier(Configuration.TableName),
QueryBuilder.GetQuotedIdentifier(userRoleCfg.TableName),
// Configured field names
QueryBuilder.GetQuotedIdentifier(Configuration.Property(p => p.Id).ColumnName),
QueryBuilder.GetQuotedIdentifier(userRoleCfg.Property(p => p.RoleId).ColumnName),
QueryBuilder.GetQuotedIdentifier(userIdPropCfg.ColumnName),
QueryBuilder.GetQuotedIdentifier(roleNamePropCfg.ColumnName),
// Parameter names
userIdPropCfg.PropertyName,
roleNamePropCfg.PropertyName);
DbCommandContext cmdContext = new DbCommandContext(command);
cmdContext.Parameters[userIdPropCfg.PropertyName].Value = userId;
cmdContext.Parameters[roleNamePropCfg.PropertyName].Value = roleName;
DbDataReader reader = null;
bool inRole = false;
StorageContext.Open();
try
{
reader = cmdContext.ExecuteReader();
inRole = reader.Read();
}
catch (Exception)
{
throw;
}
finally
{
if (reader != null)
{
reader.Close();
}
StorageContext.Close();
}
return(inRole);
}
/// <summary>
/// Find all user claims by user id and the given claim.
/// </summary>
/// <param name="userId">Target user id.</param>
/// <param name="claim">Target claim.</param>
/// <returns>Returns a list of user claims if found; otherwise, returns empty list.</returns>
public ICollection <TUserClaim> FindAllByUserId(TKey userId, Claim claim)
{
PropertyConfiguration userIdPropCfg = Configuration.Property(p => p.UserId);
PropertyConfiguration claimTypePropCfg = Configuration.Property(p => p.ClaimType);
PropertyConfiguration claimValuePropCfg = Configuration.Property(p => p.ClaimValue);
DbCommand command = StorageContext.CreateCommand();
command.CommandText = String.Format(
@"SELECT * FROM {0} WHERE {1} = @{4} AND {2} = @{5} AND {3} = @{6};",
QueryBuilder.GetQuotedIdentifier(Configuration.TableName),
// Configured field names
QueryBuilder.GetQuotedIdentifier(userIdPropCfg.ColumnName),
QueryBuilder.GetQuotedIdentifier(claimTypePropCfg.ColumnName),
QueryBuilder.GetQuotedIdentifier(claimValuePropCfg.ColumnName),
// Parameter names
userIdPropCfg.PropertyName,
claimTypePropCfg.PropertyName,
claimValuePropCfg.PropertyName);
DbCommandContext cmdContext = new DbCommandContext(command);
cmdContext.Parameters[userIdPropCfg.PropertyName].Value = userId;
cmdContext.Parameters[claimTypePropCfg.PropertyName].Value = claim.Type;
cmdContext.Parameters[claimValuePropCfg.PropertyName].Value = claim.Value;
DbDataReader reader = null;
ICollection <TUserClaim> list = null;
StorageContext.Open();
try
{
reader = cmdContext.ExecuteReader();
list = EntityBuilder.BuildAll(reader);
}
catch (Exception)
{
throw;
}
finally
{
if (reader != null)
{
reader.Close();
}
cmdContext.Dispose();
StorageContext.Close();
}
return(list);
}
public SqlGenerator()
{
Type t = typeof(T);
CrudAccessTableNameAttribute atrTableName = t.GetCustomAttribute <CrudAccessTableNameAttribute>(false); //get the table name attribute for the DTO
if (atrTableName == null || string.IsNullOrWhiteSpace(atrTableName.Name)) //if there is no table name for DTO
{
throw new DbAccessException($"There is no CrudAccessTableName attribute set for '{typeof(T).Name}'"); //throw an exception
}
//else get the table name
else
{
_TableName = atrTableName.Name;
}
//get the property names for this DTO
PropertyInfo[] props = t.GetProperties();
//_PropertyNameList = new List<string>();
_PropertyConfiguration = new List <PropertyConfiguration>();
foreach (PropertyInfo pi in props)
{
CrudAccessKeyAttribute keyAtr = pi.GetCustomAttribute <CrudAccessKeyAttribute>();
CrudAccessPropertySettingsAttribute settingAtr = pi.GetCustomAttribute <CrudAccessPropertySettingsAttribute>();
PropertyConfiguration cfg = new PropertyConfiguration();
cfg.Name = pi.Name;
if (keyAtr != null)
{
//TODO: create support for multiple (composite) keys?
if (_PropertyConfiguration.Where(x => x.isKey).SingleOrDefault() != null)
{
throw new DbAccessException($"Multiple keys specified on crud model. ");
}
cfg.isKey = true;
cfg.Insert = keyAtr.Insert;
cfg.Update = keyAtr.Update;
}
if (settingAtr != null)
{
//settings attribute overrides key attribute (wouldn't usually expect these on the same property!)
cfg.Insert = settingAtr.Insert;
cfg.Update = settingAtr.Update;
cfg.Select = settingAtr.Select;
cfg.DoBy = settingAtr.DoBy;
}
_PropertyConfiguration.Add(cfg);
}
}
/// <summary>
/// Find user login by login information and user id.
/// </summary>
/// <param name="userId">Target user.</param>
/// <param name="loginInfo">User login information.</param>
/// <returns>Returns the user login if found; otherwise, returns null.</returns>
public TUserLogin Find(TKey userId, UserLoginInfo loginInfo)
{
PropertyConfiguration loginProviderPropCfg = Configuration.Property(p => p.LoginProvider);
PropertyConfiguration providerKeyPropCfg = Configuration.Property(p => p.ProviderKey);
PropertyConfiguration userIdPropCfg = Configuration.Property(p => p.UserId);
DbCommand command = StorageContext.CreateCommand();
command.CommandText = String.Format(
@"SELECT * FROM {0} WHERE {1} = @{4} AND {2} = @{5} AND {3} = @{6};",
QueryBuilder.GetQuotedIdentifier(Configuration.TableName),
// Configured field names
QueryBuilder.GetQuotedIdentifier(loginProviderPropCfg.ColumnName),
QueryBuilder.GetQuotedIdentifier(providerKeyPropCfg.ColumnName),
QueryBuilder.GetQuotedIdentifier(userIdPropCfg.ColumnName),
// Parameter names
loginProviderPropCfg.PropertyName,
providerKeyPropCfg.PropertyName,
userIdPropCfg.PropertyName);
DbCommandContext cmdContext = new DbCommandContext(command);
cmdContext.Parameters[loginProviderPropCfg.PropertyName].Value = loginInfo.LoginProvider;
cmdContext.Parameters[providerKeyPropCfg.PropertyName].Value = loginInfo.ProviderKey;
cmdContext.Parameters[userIdPropCfg.PropertyName].Value = userId;
DbDataReader reader = null;
TUserLogin userLogin = default(TUserLogin);
StorageContext.Open();
try
{
reader = cmdContext.ExecuteReader();
userLogin = EntityBuilder.Build(reader);
}
catch (Exception)
{
throw;
}
finally
{
if (reader != null)
{
reader.Close();
}
cmdContext.Dispose();
StorageContext.Close();
}
return(userLogin);
}
public override void RenderText(string text, PropertyConfiguration textProperty)
{
if (textProperty == null)
{
RenderOut.Append(text);
}
else
{
EnterRenderContext(textProperty);
renderStrategyChain.TryRenderFromStart(text, this);
LeaveRenderContext();
}
}
public static MapBuilder <TSource, TResult> MapField <TSource, TResult>(
this MapBuilder <TSource, TResult> builder,
string from)
{
var prop = new PropertyConfiguration <TSource, TResult>
{
SourcePropertyName = from,
TargetPropertyName = from
};
builder.AddProperty(prop);
return(builder);
}
public ConfigurationAdapter Create(PropertyConfiguration configuration)
{
Type type = configuration.GetType();
do
{
if (adapters.ContainsKey(type))
{
return (ConfigurationAdapter) Activator.CreateInstance(adapters[type]);
}
type = type.BaseType;
} while (type != null && type != typeof (object));
throw new InvalidOperationException("unknown configuration " + configuration.GetType().Name);
}
public static List<ModelConfiguration> GetModelConfigurationData()
{
List<ModelConfiguration> dataList = new List<ModelConfiguration>();
Dictionary<string, PropertyConfiguration> properties = new Dictionary<string, PropertyConfiguration>();
//Property Configuration
List<ValidationBase> validators1 = new List<ValidationBase>();
validators1.Add(new RequiredValidator(new Dictionary<string, string>() { { "Validate", "true" }, { "MessageKey", "LoginInputView_UserName_Required" } }));
PropertyConfiguration usernameProperty = new PropertyConfiguration("UserName", validators1, accessPolicyCode: "UN_ACCESS_POLICY");
List<ValidationBase> validators2 = new List<ValidationBase>();
validators2.Add(new RequiredValidator(new Dictionary<string, string>() { { "Validate", "true" }, { "MessageKey", "LoginInputView_Password_Required" } }));
PropertyConfiguration passwordProperty = new PropertyConfiguration("Password", validators2, accessPolicyCode: "PWD_ACCESS_POLICY");
List<ValidationBase> validators3 = new List<ValidationBase>();
validators3.Add(new RequiredValidator(new Dictionary<string, string>() { { "Validate", "true" }, { "MessageKey", "AddPlayerModel_PostalCode_Required" } }));
properties.Add(usernameProperty.Key, usernameProperty);
properties.Add(passwordProperty.Key, passwordProperty);
//Model Property Configuration
List<IModelPropertyConfiguration> mlist = new List<IModelPropertyConfiguration>();
mlist.Add(new ModelPropertyConfiguration("UserName", "UserName", "LoginInputView_UserName", properties["UserName"]));
mlist.Add(new ModelPropertyConfiguration("Password", "Password", "LoginInputView_Password", properties["Password"]));
ModelConfiguration mConfig = new ModelConfiguration("LoginInputView", mlist);
dataList.Add(mConfig);
//**************************************************** Add player Model Configuration ************************************************************************
List<IModelPropertyConfiguration> playerModelPropertyList = new List<IModelPropertyConfiguration>();
Dictionary<string, string> adb = new Dictionary<string, string>() { { "ActionName", "process" }, { "ControllerName", "ControlLibrary_PostalCode_Get" }, { "ActionURL", "ControlLibrary_PostalCode_Get/process" } };
AutoCompleteBehaviourPropertyBag abag = new AutoCompleteBehaviourPropertyBag(adb);
Dictionary<string, object> bd = new Dictionary<string, object>() { { "AutoCompleteBehaviourPropertyBag", abag } };
playerModelPropertyList.Add(new ModelPropertyConfiguration("PostalCode", "HomeAddress.PostalCode", "AddPlayerModel_HomeAddress_PostalCode",
new PropertyConfiguration("PostalCode", new List<ValidationBase>() {
new RequiredValidator(new Dictionary<string, string>() { { "Validate", "true" }, { "MessageKey", "AddPlayerModel_PostalCode_Required" } })
}, behaviourDtls: bd)));
playerModelPropertyList.Add(new ModelPropertyConfiguration("AccountNumber", "AccountNumber", "AddPlayerModel_AccountNumber",
new PropertyConfiguration("AccountNumber", new List<ValidationBase>() {
new RequiredValidator(new Dictionary<string, string>() { { "Validate", "true" }, { "MessageKey", "AddPlayerModel_AccountNumber_Required" } })
})));
playerModelPropertyList.Add(new ModelPropertyConfiguration("FirstName", "FirstName", "AddPlayerModel_FirstName",
new PropertyConfiguration("FirstName", new List<ValidationBase>() {
new RequiredValidator(new Dictionary<string, string>() { { "Validate", "true" }, { "MessageKey", "AddPlayerModel_FirstName_Required" } })
})));
playerModelPropertyList.Add(new ModelPropertyConfiguration("LastName", "LastName", "AddPlayerModel_LastName",
new PropertyConfiguration("LastName", new List<ValidationBase>() {
new RequiredValidator(new Dictionary<string, string>() { { "Validate", "true" }, { "MessageKey", "AddPlayerModel_LastName_Required" } })
})));
playerModelPropertyList.Add(new ModelPropertyConfiguration("PhoneNumber", "PhoneNumber", "AddPlayerModel_PhoneNumber",
new PropertyConfiguration("PhoneNumber", new List<ValidationBase>() {
new RequiredValidator(new Dictionary<string, string>() { { "Validate", "true" }, { "MessageKey", "AddPlayerModel_PhoneNumber_Required" } }),
new CustomValidators(new Dictionary<string, string>() { { "Validate", "true" }, { "MessageKey", "AddPlayerModel_PhoneNumber_Invalid" },{"ValidationType","Phone"} })
})));
playerModelPropertyList.Add(new ModelPropertyConfiguration("SSN", "SSN", "AddPlayerModel_SSN",
new PropertyConfiguration("SSN", new List<ValidationBase>() {
new RequiredValidator(new Dictionary<string, string>() { { "Validate", "true" }, { "MessageKey", "AddPlayerModel_SSN_Required" } }),
//new SpecialCharValidator(new Dictionary<string, string>() { { "Validate", "true" }, { "MessageKey", "AddPlayerModel_SSN_SpecialCharNotAllowed" },{"Expression",""},{"Restriction","Allow"} })
new CustomValidators(new Dictionary<string, string>() { { "Validate", "true" }, { "MessageKey", "AddPlayerModel_SSN_Invalid" },{"ValidationType","SSN"} })
})));
ModelConfiguration playerAddConfig = new ModelConfiguration("AddPlayerModel", playerModelPropertyList);
dataList.Add(playerAddConfig);
//**************************************************** END of Add player Model Configuration ************************************************************************
/*Control Library Controls Test Validators*/
List<ValidationBase> fn_ReqValidator = new List<ValidationBase>();
fn_ReqValidator.Add(new RequiredValidator(new Dictionary<string, string>() { { "Validate", "true" }, { "MessageKey", "AllControlModel_UserName_Required" } }));
fn_ReqValidator.Add(new LengthValidator(new Dictionary<string, string>() { { "MinLength", "2" }, { "MaxLength", "18" }, { "Validate", "true" }, { "MessageKey", "AllControlModel_UserName_Length" } }));
fn_ReqValidator.Add(new SpecialCharValidator(new Dictionary<string, string>() { { "Expression", "#$" }, { "Restriction", RestrictionType.Restrict.ToString() }, { "Validate", "true" }, { "MessageKey", "AllControlModel_UserName_SpecialChar" } }));
//fn_ReqValidator.Add(new RangeValidator(new Dictionary<string, string>() { { "MinLength", "2" }, { "MaxLength", "5" }, { "Validate", "true" }, { "MessageKey", "AllControlModel_UserName_Range" } }));
//PropertyConfiguration firstNameProperty = new PropertyConfiguration("FirstName", fn_ReqValidator, accessPolicyCode: "UN_ACCESS_POLICY");
//PropertyConfiguration firstNameProperty = new PropertyConfiguration("FirstName", fn_ReqValidator, accessPolicyCode: "UN_ACCESS_POLICY",);
Dictionary<string, string> dic = new Dictionary<string, string>();
dic.Add("ActionURL", @"ControlLibrary_AutoComplete_load");
AutoCompleteBehaviourPropertyBag autoCompleteBhBag = new AutoCompleteBehaviourPropertyBag(dic);
Dictionary<string, object> behaviourDtls = new Dictionary<string, object>();
behaviourDtls.Add("AutoCompleteBehaviourPropertyBag", autoCompleteBhBag);
/*Masking Property Configuration*/
Dictionary<string, string> Maskingdic = new Dictionary<string, string>();
Maskingdic.Add("MaskingChar", "X");
Maskingdic.Add("MaskingType", MaskingType.Partial.ToString());
Maskingdic.Add("MaskCharLength", 4.ToString());
Maskingdic.Add("MaskingPosition", MaskingPosition.Last.ToString());
MaskingBehaviourPropertyBag maskingBag = new MaskingBehaviourPropertyBag(Maskingdic);
behaviourDtls.Add("MaskingBehaviourPropertyBag", maskingBag);
PropertyConfiguration firstNameProperty = new PropertyConfiguration("FirstName", fn_ReqValidator, accessPolicyCode: "FN_ACCESS_POLICY",
behaviourDtls: behaviourDtls);
properties.Add(firstNameProperty.Key, firstNameProperty);
List<IModelPropertyConfiguration> modelList = new List<IModelPropertyConfiguration>();
modelList.Add(new ModelPropertyConfiguration("FirstName", "FirstName", "AllControlModel_FirstName", properties["FirstName"]));
ModelConfiguration modelConfig = new ModelConfiguration("AllControlModel", modelList);
dataList.Add(modelConfig);
return dataList;
}
private IObjectConfiguration ConfigureObject(XmlNode configNode, IContainer container)
{
string objectName = configNode.Attributes["name"].Value;
IObjectConfiguration objectConfig = GetObjectConfiguration(objectName, container);
objectConfig.Name = objectName;
if (configNode.Attributes["aop-config"] != null)
{
string sectionName = configNode.Attributes["aop-config"].Value;
IEngine engine = NAspect.Framework.ApplicationContext.ConfigureFromSection(sectionName);
objectConfig.AopEngine = engine;
}
if (configNode.Attributes["type"] != null)
{
string objectTypeString = configNode.Attributes["type"].Value;
Type objectType = ResolveType(objectTypeString);
objectConfig.Type = objectType;
}
if (configNode.Attributes["factory"] != null)
{
string factoryName = configNode.Attributes["factory"].Value;
IFactoryConfiguration factoryConfig = GetFactoryConfiguration(factoryName, container);
objectConfig.InstanceValue = factoryConfig;
}
//done
if (configNode.Attributes["instance-mode"] != null)
{
string instanceModeString = configNode.Attributes["instance-mode"].Value;
objectConfig.InstanceMode = (InstanceMode) InstanceMode.Parse(typeof (InstanceMode), instanceModeString);
}
container.Configuration.AddObjectConfiguration(objectConfig);
foreach (XmlNode objectNode in configNode)
{
#region property
if (objectNode.Name == "property")
{
PropertyConfiguration propertyConfig = new PropertyConfiguration();
propertyConfig.Name = objectNode.Attributes["name"].Value;
ConfigureElement(objectNode, propertyConfig, container, null);
if (objectNode.Attributes["action"] != null)
{
string action = objectNode.Attributes["action"].Value;
if (action == "Add")
propertyConfig.ListAction = ListAction.Add;
if (action == "Replace")
propertyConfig.ListAction = ListAction.Replace;
}
objectConfig.PropertyConfigurations.Add(propertyConfig);
}
#endregion
#region Ctor Parameter
if (objectNode.Name == "ctor-parameter")
{
ParameterConfiguration parameterConfig = new ParameterConfiguration();
parameterConfig.Index = Convert.ToInt32(objectNode.Attributes["index"].Value);
ConfigureElement(objectNode, parameterConfig, container, null);
objectConfig.CtorParameterConfigurations.Add(parameterConfig);
}
#endregion
}
return objectConfig;
}
