internal static void Handle(IHandleRegistrations <BusinessItemList> regs)
{
//regs.CreateChildWithDependency((BusinessItemList bo, System.Tuple<IObjectPortal<IBusinessItem>, IMobileDependency<IObjectPortal<IBusinessItem>>> d)
// => bo.CreateChild(d.Item1, d.Item2));
// TODO : Discuss
// Hmmm...if this wasn't a static method would that be better??
// Could just send in the method signatures
// Would be even better if the types could be derived
//regs.HandleTrySomething((Action<Guid>)CreateChildGuid);
//regs.CreateChild((BusinessItemList bo, Guid criteria, IObjectPortal<IBusinessItem> d)
// => bo.CreateChildGuid(criteria, d));
// TODO Discuss - Cleaner then above
regs.CreateChild(nameof(CreateChild));
//regs.FetchChildDependency((BusinessItemList bo, System.Tuple<IObjectPortal<IBusinessItem>, IBusinessItemDal, IMobileDependency<IObjectPortal<IBusinessItem>>> d)
// => bo.FetchChild(d.Item1, d.Item2, d.Item3));
regs.FetchChild(nameof(FetchChild));
//regs.FetchChildCriteria((BusinessItemList bo, Criteria criteria, System.Tuple<IObjectPortal<IBusinessItem>, IBusinessItemDal, IMobileDependency<IObjectPortal<IBusinessItem>>> d)
// => bo.FetchChild(criteria, d.Item1, d.Item2, d.Item3));
regs.UpdateChildDependency((BusinessItemList bo, IObjectPortal <IBusinessItem> d) => bo.UpdateChild(d));
// TODO : Discuss - Same method. Assume this will be handled by the replacement for FieldManager.UpdateChildren() since it is a list
regs.InsertChildDependency((BusinessItemList bo, IObjectPortal <IBusinessItem> d) => bo.UpdateChild(d));
}
internal static void Handle(IHandleRegistrations <RootStatic> regs)
{
// Trying to come up with a way to define only the method name
// with no reflection or long type definition (ie <...,...>)
// So far NOT winning...
// This doens't work. 'Cannot infer type' Why not?!
//regs.CreateDependency(Create);
//regs.Create()
}
internal static void Handle(IHandleRegistrations <BusinessItem> reg)
{
reg.CreateChild(nameof(CreateChild));
reg.FetchChildCriteria((BusinessItem bo, BusinessItemDto d) => bo.FetchChild(d));
reg.FetchChildCriteria((BusinessItem bo, System.Tuple <CriteriaBase, BusinessItemDto> d) => bo.FetchChild(d.Item1, d.Item2));
reg.UpdateChild((BusinessItem bo, Guid criteria, IBusinessItemDal d) => bo.UpdateChild(criteria, d));
reg.InsertChild((BusinessItem bo, Guid criteria, IBusinessItemDal d) => bo.InsertChild(criteria, d));
}
internal static void Handle(IHandleRegistrations <Root> regs)
{
// TODO To Discuss
// I think it would be best for this method to be static
// but that would require sending the instance into each lambda
// If it stays instance should this method be an abstract on the base class
// with the attribute defined there or no attribute?
// Analysis
// This is breaking the principal of DI awareness
// The class should not be making any decision of where the dependency
// is coming from, simiply state that it needs a dependency
// 1. Get rid of explicit IOC reference
// 2. What is the dicoverability of this
// - Fairly clean. The type C makes generic methods that work.
// 3. Is it type specific or can change each instance?
// + With interfaces the ObjectPortal methods cannot be private
// + Fluent api for .RunLocal()
// + Both Create and CreateChild can call a child method
// Same - still use Tuples for the dependencies and criteria
// regs.Create(nameof(Create)).RunLocal();
// regs.Create<Guid>(nameof(Create));
//regs.Create<Guid>((c, s) => Create(c, s.Resolve<IObjectPortal<IBusinessItemList>>()));
//regs.Create(s => Create(s.Resolve<IObjectPortal<IBusinessItemList>>()));
regs.Create <Root, Guid, IObjectPortal <IBusinessItemList> >((bo, c, d) => bo.Create(c, d));
regs.CreateDependency <Root, IObjectPortal <IBusinessItemList> >((bo, d) => bo.Create(d));
regs.FetchDependency((Root bo, IObjectPortal <IBusinessItemList> d) => bo.Fetch(d));
regs.Fetch((Root bo, Guid criteria, IObjectPortal <IBusinessItemList> d) => bo.Fetch(criteria, d));
regs.UpdateDependency((Root bo, IObjectPortal <IBusinessItemList> d) => bo.Update(d));
regs.InsertDependency((Root bo, IObjectPortal <IBusinessItemList> d) => bo.Insert(d));
}
public static void FetchDependency <T, D>(this IHandleRegistrations <T> regs, Action <T, D> a)
{
regs.AddDependency(Operation.Fetch, a);
}
public static void CreateCriteria <T, C>(this IHandleRegistrations <T> regs, Func <C, T> func)
{
}
public static void InsertChildCriteria <T, C>(this IHandleRegistrations <T> regs, Action <T, C> a)
{
regs.AddCriteria(Operation.InsertChild, a);
}
public static void InsertChild <T, C, D>(this IHandleRegistrations <T> regs, Action <T, C, D> a)
{
regs.Add(Operation.InsertChild, a);
}
public static void Fetch <T, C, D>(this IHandleRegistrations <T> regs, Action <T, C, D> a)
{
regs.Add(Operation.Fetch, a);
}
public static void InsertChildDependency <T, D>(this IHandleRegistrations <T> regs, Action <T, D> a)
{
regs.AddDependency(Operation.InsertChild, a);
}
public static void Create <T, C, D>(this IHandleRegistrations <T> regs, Action <T, C, D> a)
{
regs.Add(Operation.Create, a);
}
public static void Fetch <T>(this IHandleRegistrations <T> regs, string methodName)
{
regs.Add(Operation.Fetch, methodName);
}
public static void UpdateDependency <T, D>(this IHandleRegistrations <T> regs, Action <T, D> a)
{
regs.AddDependency(Operation.Update, a);
}
public static void UpdateCriteria <T, C>(this IHandleRegistrations <T> regs, Action <T, C> a)
{
regs.AddCriteria(Operation.Update, a);
}
public static void Update <T>(this IHandleRegistrations <T> regs, Action <T> a)
{
regs.Add(Operation.Update, a);
}
public static void Update <T>(this IHandleRegistrations <T> regs, string methodName)
{
regs.Add(Operation.Update, methodName);
}
public static void FetchChild <T>(this IHandleRegistrations <T> regs, Action <T> a)
{
regs.Add(Operation.FetchChild, a);
}
public static void CreateDependency <T, D>(this IHandleRegistrations <T> regs, Func <D, T> func)
{
}
public static void Insert <T>(this IHandleRegistrations <T> regs, Action <T> a)
{
regs.Add(Operation.Insert, a);
}
public static void Create <T, C, D>(this IHandleRegistrations <T> regs, Func <C, D, T> func)
{
}
public static void InsertChild <T>(this IHandleRegistrations <T> regs, string methodName)
{
regs.Add(Operation.InsertChild, methodName);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T">Business object type</typeparam>
/// <typeparam name="CD">If registered in the container it is considered a dependency, if not it is considered a criteria</typeparam>
/// <param name="regs"></param>
/// <param name="a"></param>
public static void UpdateChild <T, CD>(this IHandleRegistrations <T> regs, Action <T, CD> a)
{
regs.Add(Operation.UpdateChild, a);
}
public static void FetchCriteria <T, C>(this IHandleRegistrations <T> regs, Action <T, C> a)
{
regs.AddCriteria(Operation.Fetch, a);
}
