/// <summary>
/// Method invoked <i>instead</i> of the <c>Get</c> semantic of the field or property to which the current aspect is applied,
/// i.e. when the value of this field or property is retrieved.
/// </summary>
/// <param name="args">Advice arguments.</param>
public override void OnGetValue(LocationInterceptionArgs args)
{
args.ProceedGetValue();
if (args.Value == null)
{
if (string.IsNullOrEmpty(this.Token))
{
if (string.IsNullOrEmpty(this.TokenProperty))
{
args.Value = IoC.Get(args.Location.LocationType);
}
else
{
object value = ObjectProxyFactory.Get(args.Instance).GetValue(args.Instance, this.TokenProperty);
if (value == null)
{
args.Value = IoC.Get(args.Location.LocationType);
}
else
{
args.Value = IoC.Get(args.Location.LocationType, value.ToString());
}
}
}
else
{
args.Value = IoC.Get(args.Location.LocationType, this.Token);
}
args.ProceedSetValue();
}
}
public void TestObjectProxyFactoryFromMap()
{
// Normal Test
Dictionary <string, object> map = new Dictionary <string, object>();
map.Add("Id", 7L);
map.Add("Name", "test");
TestClass1 instance = ObjectProxyFactory.FromMap <TestClass1>(map);
Assert.AreEqual(7L, instance.Id);
Assert.AreEqual("test", instance.Name);
// Lower case test
map = new Dictionary <string, object>();
map.Add("id", 7L);
map.Add("name", "test");
instance = ObjectProxyFactory.FromMap <TestClass1>(map);
Assert.AreEqual(7L, instance.Id);
Assert.AreEqual("test", instance.Name);
// Convert types test
map = new Dictionary <string, object>();
map.Add("id", "7");
map.Add("name", "test");
instance = ObjectProxyFactory.FromMap <TestClass1>(map);
Assert.AreEqual(7L, instance.Id);
Assert.AreEqual("test", instance.Name);
}
public Message Get(Message message)
{
MessageInformation information = new MessageInformation(message);
try
{
string sessionToken = this.GetSessionToken(information);
MessagePath path = new MessagePath(information);
ISecurityManager securityManager = IoC.Get <ISecurityManager>();
object response;
if (path.IsByParent)
{
MessagePath parentPath = new MessagePath(information, true);
if (!parentPath.HasKeyParameter)
{
throw new ArgumentException("A link to a parent must have parameter key");
}
dynamic bo = securityManager.DynamicGetBO(parentPath.DtoType, sessionToken);
object parent = bo.GetOne(string.Empty, parentPath.QueryInfo);
IObjectProxy proxy = ObjectProxyFactory.Get(parent);
object value = proxy.GetValue(parent, path.ParentKeyParameter);
QueryInfo query = new QueryInfo();
query.Equal(path.KeyParameterName, value.ToString());
bo = securityManager.DynamicGetBO(path.DtoType, sessionToken);
response = bo.GetOne(string.Empty, query);
}
else
{
dynamic bo = securityManager.DynamicGetBO(path.DtoType, sessionToken);
if (path.HasKeyParameter)
{
response = bo.GetOne(string.Empty, path.QueryInfo);
}
else
{
response = bo.GetAll(path.QueryInfo);
}
}
IServiceConfiguration configuration = IoC.Get <IServiceConfiguration>();
JsonSerializerSettings settings = IoC.Get <JsonSerializerSettings>();
if (configuration.IsHateoas)
{
response = this.ConvertToHateoas(response, configuration, path);
}
return(response.ToJsonMessage(settings, configuration.Indented));
}
catch (Exception ex)
{
if (ex is TargetInvocationException)
{
return(ex.InnerException.Message.ToJsonMessage());
}
else
{
return(ex.Message.ToJsonMessage());
}
}
}
public void TestObjectProxyFactoryToStringMap()
{
TestClass1 instance = new TestClass1(7L, "test");
Dictionary <string, string> map = ObjectProxyFactory.ToStringMap(instance);
Assert.IsNotNull(map);
Assert.AreEqual(2, map.Count);
Assert.AreEqual("7", map["Id"]);
Assert.AreEqual("test", map["Name"]);
}
/// <summary>
/// Fills target object from source object, taking into account th fields to be avoided.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="target">The target.</param>
public void FillUpdate(object source, object target)
{
IObjectProxy proxy = ObjectProxyFactory.GetByType(this.EntityType);
foreach (IMetamodelField field in this.Fields)
{
if (!field.AvoidUpdate)
{
proxy.SetValue(target, field.Name, proxy.GetValue(source, field.Name));
}
}
}
public static void ClassInit(TestContext context)
{
ObjectProxyFactory.ConfigureMappers();
IList <string> sourceNames = new List <string>();
IList <string> targetNames = new List <string>();
sourceNames.Add("Id");
sourceNames.Add("Name");
targetNames.Add("ObjectId");
targetNames.Add("NameTxt");
ObjectProxyFactory.CreateMap(typeof(TestClass1), typeof(TestClass3), sourceNames, targetNames);
}
public void TestObjectProxyFactoryMap()
{
TestClass1 source = new TestClass1(7L, "hola");
TestClass3 target = ObjectProxyFactory.MapTo <TestClass3>(source);
Assert.AreEqual(source.Id, target.ObjectId);
Assert.AreEqual(source.Name, target.NameTxt);
TestClass1 newSource = ObjectProxyFactory.MapTo <TestClass1>(target);
Assert.AreEqual(source.Id, newSource.Id);
Assert.AreEqual(source.Name, newSource.Name);
}
public void FactoryCreatesAnObjectOfTheOnlineProxyType()
{
Request request = new Request();
request.OnlineProxyType = typeof(MockProxy);
ObjectProxyFactory factory = new ObjectProxyFactory();
object proxy = factory.GetOnlineProxy(request, "Network");
Assert.IsNotNull(proxy);
Assert.AreEqual(typeof(MockProxy), proxy.GetType());
}
/// <summary>
/// Gets one DTO.
/// </summary>
/// <param name="pk">The pk.</param>
/// <param name="info"></param>
/// <returns></returns>
public TDto GetOne(string pk, QueryInfo info)
{
if (this.BeforeGetOne != null)
{
this.BeforeGetOne(this, new BOEventArgs <TDto>(pk, info, default(TDto), default(TDto), null, null));
}
TDto result = ObjectProxyFactory.MapTo <TDto>(this.GetEntityOne(pk, info));
if (this.AfterGetOne != null)
{
this.AfterGetOne(this, new BOEventArgs <TDto>(pk, info, default(TDto), result, null, null));
}
return(result);
}
/// <summary>
/// Given a source type, clones the type but only the common type properties.
/// </summary>
/// <param name="sourceType">Type of the source.</param>
/// <param name="domain">The domain.</param>
/// <param name="assemblyNameStr">The assembly name string.</param>
/// <param name="dynamicModuleName">Name of the dynamic module.</param>
/// <param name="typeName">Name of the type.</param>
/// <returns></returns>
public static Type CloneCommonType(Type sourceType, AppDomain domain, string assemblyNameStr, string dynamicModuleName, string typeName)
{
TypeBuilder typeBuilder = TypeBuilderHelper.GetClassTypeBuilder(domain, assemblyNameStr, dynamicModuleName, typeName);
IObjectProxy entityProxy = ObjectProxyFactory.GetByType(sourceType);
foreach (PropertyInfo propertyInfo in entityProxy.Properties)
{
if (TypesManager.IsCommonType(propertyInfo.PropertyType))
{
TypeBuilderHelper.AddProperty(typeBuilder, propertyInfo.Name, propertyInfo.PropertyType);
}
}
return(typeBuilder.CreateType());
}
/// <summary>
/// Gets all the DTOs.
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
public IList <TDto> GetAll(QueryInfo info)
{
if (this.BeforeGetAll != null)
{
this.BeforeGetAll(this, new BOEventArgs <TDto>(null, info, default(TDto), default(TDto), null, null));
}
IList <TDto> result = ObjectProxyFactory.MapToList <TDto>(this.GetEntityAll(info));
if (this.AfterGetAll != null)
{
this.AfterGetAll(this, new BOEventArgs <TDto>(null, info, default(TDto), default(TDto), result, null));
}
return(result);
}
/// <summary>
/// Gets the object key.
/// </summary>
/// <param name="entity">The entity.</param>
/// <returns></returns>
public ObjectKey GetObjectKey(object entity)
{
List <KeyValuePair <string, object> > keyPairs = new List <KeyValuePair <string, object> >();
IObjectProxy proxy = ObjectProxyFactory.GetByType(this.EntityType);
foreach (IMetamodelField field in this.Fields)
{
if (field.IsPrimaryKey)
{
keyPairs.Add(new KeyValuePair <string, object>(field.Name, proxy.GetValue(entity, field.Name)));
}
}
return(new ObjectKey(this.EntityType.Name, keyPairs));
}
public void TestObjectProxyFactoryGetProxy()
{
IObjectProxy proxy1 = ObjectProxyFactory.Get <TestClass1>();
Assert.IsNotNull(proxy1);
Assert.AreEqual(typeof(TestClass1), proxy1.ProxyType);
IObjectProxy proxy2 = ObjectProxyFactory.GetByType(typeof(TestClass1));
Assert.AreSame(proxy1, proxy2);
TestClass1 instance = new TestClass1();
IObjectProxy proxy3 = ObjectProxyFactory.Get(instance);
Assert.AreSame(proxy1, proxy3);
}
/// <summary>
/// Adds from object.
/// </summary>
/// <param name="instance">The instance.</param>
public void AddFromObject(object instance)
{
if (instance != null)
{
IObjectProxy proxy = ObjectProxyFactory.Get(instance);
foreach (string propertyName in proxy.PropertyNames)
{
object value = proxy.GetValue(instance, propertyName);
if (value != null)
{
this.AddAttribute(propertyName, value);
}
}
}
}
/// <summary>
/// Updates one DTO.
/// </summary>
/// <param name="src">The source.</param>
/// <returns></returns>
public TDto Update(TDto src)
{
object entity = ObjectProxyFactory.MapTo(this.EntityType, src);
if (this.BeforeUpdate != null)
{
this.BeforeUpdate(this, new BOEventArgs <TDto>(null, null, src, default(TDto), null, entity));
}
TDto result = ObjectProxyFactory.MapTo <TDto>(this.UpdateEntity(entity));
if (this.AfterUpdate != null)
{
this.AfterUpdate(this, new BOEventArgs <TDto>(null, null, src, result, null, entity));
}
return(result);
}
/// <summary>
/// Registers a pair entity and dto.
/// </summary>
/// <param name="entityType">Type of the entity.</param>
/// <param name="dtoType">Type of the dto.</param>
public IMetamodelEntity RegisterEntity(Type entityType, Type dtoType)
{
IMetamodelEntity metamodelEntity = this.GetEntity(entityType);
if (metamodelEntity == null)
{
metamodelEntity = new MetamodelEntity(entityType);
this.RegisterEntity(metamodelEntity);
}
metamodelEntity.AddDto(dtoType);
if (this.dtoMap.ContainsKey(dtoType))
{
this.dtoMap[dtoType] = metamodelEntity;
}
else
{
this.dtoMap.Add(dtoType, metamodelEntity);
}
string lowname = dtoType.Name.ToLower();
if (this.dtoNameMap.ContainsKey(lowname))
{
this.dtoNameMap[lowname] = metamodelEntity;
}
else
{
this.dtoNameMap.Add(lowname, metamodelEntity);
}
IObjectProxy proxy = ObjectProxyFactory.GetByType(dtoType);
IList <string> sourceNames = new List <string>();
IList <string> targetNames = new List <string>();
foreach (PropertyInfo property in proxy.Properties)
{
DtoFieldAttribute attribute = property.GetCustomAttribute <DtoFieldAttribute>();
if (attribute != null)
{
metamodelEntity.AddFieldMap(dtoType, attribute.Name, property.Name);
sourceNames.Add(attribute.Name);
targetNames.Add(property.Name);
}
}
ObjectProxyFactory.CreateMap(entityType, dtoType, sourceNames, targetNames);
return(metamodelEntity);
}
/// <summary>
/// Logins a user into the system.
/// </summary>
/// <param name="login">The login.</param>
/// <param name="password">The password.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentException">Login invalid</exception>
public IUserDto Login(string login, string password)
{
using (OpenAccessContext context = this.NewContext())
{
object user = this.GetUserByLoginPass(context, login, password);
if (user == null)
{
throw new ArgumentException("Login invalid");
}
IUserDto result = (IUserDto)ObjectProxyFactory.MapTo(this.UserDtoType, user);
result.Password = null;
result.SessionToken = this.SessionManager.NewSessionToken();
this.SessionManager.AddSessionForUser(context, result.UserId.Value, result.SessionToken);
context.SaveChanges();
return(result);
}
}
public void FactoryCallTheSpecifiedMethod()
{
Request request = new Request();
request.MethodName = "CalledMethod";
request.OnlineProxyType = typeof(MockProxy);
ObjectProxyFactory factory = new ObjectProxyFactory();
MockProxy proxy = (MockProxy)factory.GetOnlineProxy(request, "Network");
Exception exception = null;
factory.CallOnlineProxyMethod(proxy, request, ref exception);
Assert.IsTrue(proxy.MethodCalled);
}
public void TestObjectProxyFactoryToListStringMap()
{
IList <TestClass1> list1 = new List <TestClass1>();
list1.Add(new TestClass1(1L, "name1"));
list1.Add(new TestClass1(2L, "name2"));
list1.Add(new TestClass1(3L, "name3"));
IList <Dictionary <string, string> > table = ObjectProxyFactory.ToListStringMap(list1);
Assert.IsNotNull(table);
for (int i = 1; i <= 3; i++)
{
Dictionary <string, string> row = table[i - 1];
Assert.IsNotNull(row);
Assert.AreEqual(2, row.Count);
Assert.AreEqual(i.ToString(), row["Id"]);
Assert.AreEqual("name" + i.ToString(), row["Name"]);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BaseSecurityManager"/> class.
/// </summary>
/// <param name="contextType">Type of the context.</param>
/// <param name="userDtoType">Type of the user dto.</param>
/// <param name="fileName">Name of the file.</param>
public BaseSecurityManager(Type contextType, Type userDtoType, Type entityType)
{
this.ContextType = contextType;
this.UserDtoType = userDtoType;
ObjectProxyFactory.CreateMap(userDtoType, entityType);
this.SessionManager = IoC.Get <ISessionManager>();
if (this.SessionManager == null)
{
this.SessionManager = new MemorySessionManager();
IoC.Register <ISessionManager>(this.SessionManager);
}
this.AuditManager = IoC.Get <IAuditManager>();
if (this.AuditManager == null)
{
this.AuditManager = new EmptyAuditManager();
IoC.Register <IAuditManager>(this.AuditManager);
}
this.BOManager = new BOManager();
this.MetamodelManager = new MetamodelManager();
}
/// <summary>
/// Gets the string key.
/// </summary>
/// <param name="entity">The entity.</param>
/// <returns></returns>
public string GetStringKey(object entity)
{
IObjectProxy proxy = ObjectProxyFactory.GetByType(this.EntityType);
int i = 0;
StringBuilder sb = new StringBuilder();
foreach (IMetamodelField field in this.Fields)
{
if (field.IsPrimaryKey)
{
if (i > 0)
{
sb.Append("!");
}
sb.Append(proxy.GetValue(entity, field.Name).ToString());
i++;
}
}
return(sb.ToString());
}
/// <summary>
/// Gets the user information.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="sessionToken">The session token.</param>
/// <returns></returns>
protected virtual IUserDto GetUserInfo(OpenAccessContext context, string sessionToken)
{
ISessionDto sessionData = this.SessionManager.GetSessionData(context, sessionToken);
if (sessionData == null)
{
return(null);
}
object user = this.GetUserById(context, sessionData.UserId);
if (user == null)
{
this.SessionManager.RemoveSession(context, sessionToken);
context.SaveChanges();
return(null);
}
IUserDto result = (IUserDto)ObjectProxyFactory.MapTo(this.UserDtoType, user);
result.Password = null;
result.SessionToken = sessionData.SessionToken;
return(result);
}
/// <summary>
/// Configures the Security Manager from a file.
/// </summary>
/// <param name="fileName">Name of the file.</param>
public virtual void Configure(string fileName)
{
MetadataContainer metadata = this.GetOpenAccessMetadata();
Dictionary <string, MetaPersistentType> metatables = this.GetMetaTables(metadata);
XmlDocument document = null;
if (!string.IsNullOrEmpty(fileName))
{
document = XmlResources.GetFromResource(fileName);
if (document == null)
{
document = XmlResources.GetFromEmbeddedResource(fileName);
}
}
if (document != null)
{
ObjectProxyFactory.ConfigureMappers(document);
XmlNode rootNode = document.SelectSingleNode("configuration/entities");
if (rootNode != null)
{
this.ConfigureEntities(rootNode, metatables);
}
}
else
{
this.Scanner = new SecurityScanner(this);
this.Scanner.EntityPreffix = string.Empty;
this.Scanner.EntitySuffix = string.Empty;
this.Scanner.DtoPreffix = string.Empty;
this.Scanner.DtoSuffix = "Dto";
this.Scanner.FilterPreffix = string.Empty;
this.Scanner.FilterSuffix = "Filter";
this.Scanner.BOPreffix = string.Empty;
this.Scanner.BOSuffix = "BO";
this.Scanner.Metatables = metatables;
this.Scanner.ScanNamespace(string.Empty);
}
}
public void ShoulInterceptOnlyPrivateMethod()
{
var privateMethodName = ObjectProxyHelper.GetMethodNames <IPrivateMethod>(i => i.SaveChanges())[0];
var proxy = ObjectProxyFactory
.Configure <IPrivateMethod>(new DbFileContext()) //initialize fluent config, with given interface and instance
.FilterMethods(privateMethodName) //only intercept methods with the given name
.AddPreDecoration(ctx =>
{
Debug.Assert(ctx.CallCtx.MethodName == privateMethodName);
Console.Write("Saving Changes");
})
.AddPostDecoration(ctx =>
{
Console.Write("Saved Changes");
Debug.Assert(ctx.CallCtx.MethodName == privateMethodName);
})
//.SetParameters(new object())
.CreateProxy(); //finally create and return the proxy
proxy.SaveChanges();
}
/// <summary>
/// Gets the object key by pk.
/// </summary>
/// <param name="pk">The pk.</param>
/// <returns></returns>
public ObjectKey GetObjectKeyByPk(string pk)
{
string[] tokens = pk.Split('!');
if (tokens.Length == 1)
{
return(new ObjectKey(this.EntityType.Name, pk));
}
else
{
List <KeyValuePair <string, object> > keyPairs = new List <KeyValuePair <string, object> >();
int i = 0;
IObjectProxy proxy = ObjectProxyFactory.GetByType(this.EntityType);
foreach (IMetamodelField field in this.Fields)
{
if (field.IsPrimaryKey)
{
keyPairs.Add(new KeyValuePair <string, object>(field.Name, this.ChangeType(tokens[i], proxy.GetPropertyType(field.Name))));
i++;
}
}
return(new ObjectKey(this.EntityType.Name, keyPairs));
}
}
private static void Main()
{
IEmployee employee = new Employee(1, "John", "Smith", new DateTime(1990, 4, 1));
var tpCheckRight = ObjectProxyFactory.CreateProxy(
employee, new[] { "Salary" }, new Decoration(UserRightCheck), null);
var tpLogCheckRight = ObjectProxyFactory.CreateProxy(
tpCheckRight, new[] { "Salary", "FullName" }, new Decoration(EnterLog), new Decoration(ExitLog));
// Используем отражение для декорации всех методов: var ifaceMethods = typeof (IEmployee).GetMethods().Select(info => info.Name);
try
{
tpLogCheckRight.FullName();
Console.WriteLine();
tpLogCheckRight.Salary();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.Read();
}
public void RunLoopProxyfied()
{
var dbContext = new DbFileContext();
var privateMethodName = ObjectProxyHelper.GetMethodNames <IPrivateMethod>(j => j.SaveChanges())[0];
var proxy = ObjectProxyFactory
.Configure <IPrivateMethod>(dbContext) //initialize fluent config, with given interface and instance
.FilterMethods(privateMethodName) //only intercept methods with the given name
.CreateProxy(); //finally create and return the proxy
var sw = Stopwatch.StartNew();
for (int i = 0; i < 1000; i++)
{
int i1 = i;
Console.Write(i1);
proxy.SaveChanges();
}
Console.WriteLine("took {0}", sw.Elapsed.ToString("g"));
Console.ReadLine();
}
public void TestObjectProxyFactoryFromListStringMap()
{
IList <Dictionary <string, string> > table = new List <Dictionary <string, string> >();
for (int i = 1; i <= 3; i++)
{
Dictionary <string, string> item = new Dictionary <string, string>();
item.Add("Id", i.ToString());
item.Add("Name", "name" + i.ToString());
table.Add(item);
}
IList <TestClass1> list = ObjectProxyFactory.FromListStringMap <TestClass1>(table);
Assert.IsNotNull(list);
Assert.AreEqual(3, list.Count);
for (int i = 1; i <= 3; i++)
{
TestClass1 item = list[i - 1];
Assert.IsNotNull(item);
Assert.AreEqual(i, item.Id);
Assert.AreEqual("name" + i.ToString(), item.Name);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BaseSessionManager"/> class.
/// </summary>
/// <param name="entityType">Type of the entity.</param>
/// <param name="sessionDtoType">Type of the session dto.</param>
public BaseSessionManager(Type entityType, Type sessionDtoType)
{
this.sessionDtoType = sessionDtoType;
ObjectProxyFactory.CreateMap(entityType, this.sessionDtoType);
}
/// <summary>
/// Gets the session data.
/// </summary>
/// <param name="context">The database context.</param>
/// <param name="sessionToken">The session token.</param>
/// <returns></returns>
/// <exception cref="System.NotImplementedException"></exception>
public ISessionDto GetSessionData(OpenAccessContext context, string sessionToken)
{
object session = this.GetSessionByToken(context, sessionToken);
return(session == null ? null : (ISessionDto)ObjectProxyFactory.MapTo(this.sessionDtoType, session));
}
