/// <summary>
/// Get context object associated with the service of the specified type.
/// </summary>
/// <param name="typeFullName"></param>
/// <returns></returns>
public IActionContext GetContext(string typeFullName)
{
EntityRegistrationContext ctx = EntityRegistration.GetRegistrationContext(typeFullName);
IActionContext actionContext = Activator.CreateInstance(ctx.ActionContextType) as IActionContext;
return(actionContext);
}
/// <summary>
/// Initialize the service, repository creators.
/// </summary>
/// <param name="serviceCreator">The service creator.</param>
/// <param name="repoCreator">The repository creator.</param>
/// <param name="configureRepository">Whether or not to configure the reposiory.</param>
public static void Init(Func <IEntityService <T> > serviceCreator, Func <IRepository <T> > repoCreator, Func <IEntityValidator> validatorCreator,
IEntitySettings settings, IEntityResources resources, bool configureRepository, string connId)
{
EntityRegistration.Register <T>(serviceCreator, repoCreator, validatorCreator, settings, resources, configureRepository, connId);
var ctx = EntityRegistration.GetRegistrationContext(typeof(T).FullName);
MethodInfo callback = typeof(T).GetMethod("OnAfterInit");
if (callback != null)
{
callback.Invoke(null, null);
}
// Setup flags for entity life-cycle callbacks.
ctx.HasOnBeforeValidate = HasMethod("OnBeforeValidate");
ctx.HasOnBeforeValidateCreate = HasMethod("OnBeforeValidateCreate");
ctx.HasOnBeforeValidateUpdate = HasMethod("OnBeforeValidateUpdate");
ctx.HasOnBeforeCreate = HasMethod("OnBeforeCreate");
ctx.HasOnBeforeUpdate = HasMethod("OnBeforeUpdate");
ctx.HasOnBeforeSave = HasMethod("OnBeforeSave");
ctx.HasOnBeforeDelete = HasMethod("OnBeforeDelete");
ctx.HasOnAfterValidate = HasMethod("OnAfterValidate");
ctx.HasOnAfterValidateCreate = HasMethod("OnAfterValidateCreate");
ctx.HasOnAfterValidateUpdate = HasMethod("OnAfterValidateUpdate");
ctx.HasOnAfterCreate = HasMethod("OnAfterCreate");
ctx.HasOnAfterUpdate = HasMethod("OnAfterUpdate");
ctx.HasOnAfterSave = HasMethod("OnAfterSave");
ctx.HasOnAfterDelete = HasMethod("OnAfterDelete");
}
/// <summary>
/// Get a new entity of the specified type.
/// </summary>
/// <param name="typeFullName"></param>
/// <returns></returns>
public object GetEntity(string typeFullName)
{
EntityRegistrationContext ctx = EntityRegistration.GetRegistrationContext(typeFullName);
object entity = Activator.CreateInstance(ctx.EntityType);
return(entity);
}
/// <summary>
/// Get the entity Service(supporting CRUD operations).
/// </summary>
/// <param name="typeFullName"></param>
/// <returns></returns>
public object GetService(string typeFullName)
{
EntityRegistrationContext ctx = EntityRegistration.GetRegistrationContext(typeFullName);
string serviceName = ctx.Name + EntityRegistrationConstants.SuffixService;
object obj = Ioc.GetObject <object>(serviceName);
return(obj);
}
/// <summary>
/// Get an object from the IocContainer using the type's full name and a suffix.
/// </summary>
/// <param name="typeFullName"></param>
/// <param name="suffix"></param>
/// <returns></returns>
public object GetObject(string typeFullName, string suffix)
{
EntityRegistrationContext ctx = EntityRegistration.GetRegistrationContext(typeFullName);
string entryName = ctx.Name + suffix;
object obj = Ioc.GetObject <object>(entryName);
return(obj);
}
/// <summary>
/// Deletes the model from the repository.
/// </summary>
/// <param name="ctx"></param>
/// <returns></returns>
public virtual void Delete(IActionContext ctx)
{
var entityCtx = EntityRegistration.GetRegistrationContext(typeof(T).FullName);
T entity = default(T);
if (ctx.Item != null)
{
entity = (T)ctx.Item;
}
else
{
entity = Get(ctx.Id);
ctx.Item = entity;
}
// already deleted
if (entity == null)
{
return;
}
var result = PerformAction(ctx, delegate(IActionContext context)
{
if (entityCtx.HasOnBeforeDelete)
{
entity.OnBeforeDelete(ctx);
}
if (context.Item == null)
{
_repository.Delete(context.Id);
}
else
{
_repository.Delete((T)context.Item);
}
if (entityCtx.HasOnAfterDelete)
{
entity.OnAfterDelete();
}
},
EntityAction.Delete);
}
/// <summary>
/// Updates the model in the repository.
/// </summary>
/// <param name="ctx"></param>
/// <param name="executor">The action to execute</param>
/// <returns></returns>
protected virtual void InternalUpdate(IActionContext ctx, Action <IActionContext> executor)
{
var entityCtx = EntityRegistration.GetRegistrationContext(typeof(T).FullName);
IEntity entity = ctx.Item as IEntity;
// Do the action(create)
var result = PerformAction(ctx, context =>
{
// 1. Clear errors first?
if (entityCtx.IsEntityErrorCollectionClearedBeforePopulation)
{
entity.Errors.Clear();
}
// 2. Life-cycle callbacks before validation.
if (entityCtx.HasOnBeforeValidate)
{
entity.OnBeforeValidate(ctx);
}
if (entityCtx.HasOnBeforeValidateUpdate)
{
entity.OnBeforeValidateUpdate(ctx);
}
// 3: Validate the entity.
var validResult = PerformValidation(ctx, EntityAction.Update);
if (!validResult.Success)
{
return;
}
// 4. Life-cycle callbacks after validation.
if (entityCtx.HasOnAfterValidateUpdate)
{
entity.OnAfterValidateUpdate();
}
if (entityCtx.HasOnAfterValidate)
{
entity.OnAfterValidate();
}
if (entityCtx.HasOnBeforeSave)
{
entity.OnBeforeSave(ctx);
}
if (entityCtx.HasOnBeforeUpdate)
{
entity.OnBeforeUpdate(ctx);
}
// 5. Persist the entity.
if (executor == null)
{
_repository.Update((T)context.Item);
}
else
{
executor(context);
}
// 6. Life-cycle callbacks after persistance.
if (entityCtx.HasOnAfterUpdate)
{
entity.OnAfterUpdate();
}
if (entityCtx.HasOnAfterSave)
{
entity.OnAfterSave();
}
}, EntityAction.Update);
}
/// <summary>
/// Creates the entity.
/// </summary>
/// <param name="ctx"></param>
/// <param name="executor">The executor to call to create the entity.
/// If empty, _repository.Create(entity) is automatically called.</param>
/// <returns></returns>
protected virtual void InternalCreate(IActionContext ctx, Action <IActionContext> executor)
{
// If the ctx errors are null, then use the errors from the entity.errors collection.
// This is used for the following use cases:
// 1. Error collecting into separate unified error collection.
// 2. Import / Export
// 3. Batch processing
var entityCtx = EntityRegistration.GetRegistrationContext(typeof(T).FullName);
IEntity entity = ctx.Item as IEntity;
// Do the action(create)
var result = PerformAction(ctx, context =>
{
// 1. Clear errors first?
if (entityCtx.IsEntityErrorCollectionClearedBeforePopulation)
{
entity.Errors.Clear();
}
// 2. Life-cycle callbacks before validation.
if (entityCtx.HasOnBeforeValidate)
{
entity.OnBeforeValidate(ctx);
}
if (entityCtx.HasOnBeforeValidateCreate)
{
entity.OnBeforeValidateCreate(ctx);
}
// 3: Validate the entity.
var validResult = PerformValidation(ctx, EntityAction.Create);
if (!validResult.Success)
{
return;
}
// 4. Life-cycle callbacks after validation.
if (entityCtx.HasOnAfterValidateCreate)
{
entity.OnAfterValidateCreate();
}
if (entityCtx.HasOnAfterValidate)
{
entity.OnAfterValidate();
}
if (entityCtx.HasOnBeforeSave)
{
entity.OnBeforeSave(ctx);
}
if (entityCtx.HasOnBeforeCreate)
{
entity.OnBeforeCreate(ctx);
}
// 5. Persist the entity.
if (executor == null)
{
_repository.Create((T)context.Item);
}
else
{
executor(context);
}
// 6. Life-cycle callbacks after persistance.
if (entityCtx.HasOnAfterCreate)
{
entity.OnAfterCreate();
}
if (entityCtx.HasOnAfterSave)
{
entity.OnAfterSave();
}
}, EntityAction.Create);
}
