public MessageAmalgamator(IAmalgamator <MessageHeader> headerAmalgamator, IAmalgamator <MessageLearner> learnerAmalgamator, IAmalgamator <MessageLearnerDestinationandProgression> learnerDestinationandProgressionAmalgamator, IAmalgamationErrorHandler amalgamationErrorHandler)
: base(Entity.Message, (x) => null, amalgamationErrorHandler)
{
_headerAmalgamator = headerAmalgamator;
_learnerAmalgamator = learnerAmalgamator;
_learnerDestinationandProgressionAmalgamator = learnerDestinationandProgressionAmalgamator;
}
public LearnerAmalgamator(
IAmalgamator <MessageLearnerProviderSpecLearnerMonitoring> providerSpecLearnerMonitoringAmalgamator,
IAmalgamator <MessageLearnerLearnerEmploymentStatus> learnerEmploymentStatusAmalgamator,
IAmalgamator <MessageLearnerLearnerHE> learnerHEAmalgamator,
IRuleProvider ruleProvider,
IAmalgamationErrorHandler amalgamationErrorHandler)
: base(Entity.Learner, (x) => x.LearnRefNumber, amalgamationErrorHandler)
{
_providerSpecLearnerMonitoringAmalgamator = providerSpecLearnerMonitoringAmalgamator;
_learnerEmploymentStatusAmalgamator = learnerEmploymentStatusAmalgamator;
_learnerHEAmalgamator = learnerHEAmalgamator;
_standardRuleString = ruleProvider.BuildStandardRule <string>();
_standardRuleStringFirstItem = ruleProvider.BuildStandardRuleFirstItem <string>();
_standardRuleLong = ruleProvider.BuildStandardRule <long?>();
_standardRuleDateTime = ruleProvider.BuildStandardRule <DateTime?>();
_addressRule = ruleProvider.BuildAddressRule();
_ulnRule = ruleProvider.BuildUlnRule();
_alsCostrule = ruleProvider.BuildAlsCostRule();
_postCodeRule = ruleProvider.BuildPostCodeRule();
_learnerContactPreferenceCollectionRule = ruleProvider.BuildLearnerContactPreferenceCollectionRule();
_lLDDandHealthProblemCollectionRule = ruleProvider.BuildLLDDandHealthProblemCollectionRule();
_learnerFAMAmalgamationRule = ruleProvider.BuildLearnerFAMAmalgamationRule();
_learningDeliveryRule = ruleProvider.BuildLearningDeliveryRule();
}
public LearnerHEAmalgamator(IAmalgamator <MessageLearnerLearnerHELearnerHEFinancialSupport> learnerHEFinancialSupportAmalgamator, IRuleProvider ruleProvider, IAmalgamationErrorHandler amalgamationErrorHandler)
: base(Entity.LearnerHE, (x) => x.LearnRefNumber.ToString(), amalgamationErrorHandler)
{
_learnerHEFinancialSupportAmalgamator = learnerHEFinancialSupportAmalgamator;
_standardRuleString = ruleProvider.BuildStandardRule <string>();
_standardRuleLong = ruleProvider.BuildStandardRule <long?>();
}
public LearnerEmploymentStatusAmalgamator(IAmalgamator <MessageLearnerLearnerEmploymentStatusEmploymentStatusMonitoring> learnerEmploymentStatusMonitoringAmalgamator, IRuleProvider ruleProvider, IAmalgamationErrorHandler amalgamationErrorHandler)
: base(Entity.LearnerEmploymentStatus, (x) => x.DateEmpStatApp.ToString(), amalgamationErrorHandler)
{
_learnerEmploymentStatusMonitoringAmalgamator = learnerEmploymentStatusMonitoringAmalgamator;
_standardRuleString = ruleProvider.BuildStandardRule <string>();
_standardRuleLong = ruleProvider.BuildStandardRule <long?>();
_standardRuleDateTime = ruleProvider.BuildStandardRule <DateTime?>();
}
/// <summary>
/// Retrieves the amalgam for an amalgamator. This method uses a cache to prevent multiple amalgam instances.
/// </summary>
/// <param name="amalgamator">The amalgamator.</param>
/// <returns>The amalgam.</returns>
public static object GetAmalgam(this IAmalgamator amalgamator)
{
var property = amalgamator.TryGetConnectedProperty <object, AmalgamationTag>();
if (property != null)
{
return(property.GetOrCreate(amalgamator.CreateAmalgam));
}
return(amalgamator.CreateAmalgam());
}
public LearnerAmalgamator BuildAmalgamator(
IAmalgamator <MessageLearnerLearnerEmploymentStatus> learnerEmploymentStatusAmalgamator = null,
IAmalgamator <MessageLearnerLearnerHE> learnerHEAmalgamator = null,
IRuleProvider ruleProvider = null,
IAmalgamationErrorHandler amalgamationErrorHandler = null)
{
return(null);
//new LearnerAmalgamator(
//learnerEmploymentStatusAmalgamator ?? Mock.Of<IAmalgamator<MessageLearnerLearnerEmploymentStatus>>(),
//learnerHEAmalgamator ?? Mock.Of<IAmalgamator<MessageLearnerLearnerHE>>(),
//ruleProvider ?? Mock.Of<IRuleProvider>(),
//amalgamationErrorHandler ?? Mock.Of<IAmalgamationErrorHandler>());
}
protected T ApplyChildRule <TValue>(Expression <Func <T, TValue> > selector, IAmalgamator <TValue> amalgamator, IEnumerable <T> inputEntities, T entity)
{
var selectorFunc = selector.Compile();
var inputValues = inputEntities.Where(e => e != null).Select(e => selectorFunc.Invoke(e)).ToList();
if (inputValues.Any())
{
var value = amalgamator.Amalgamate(inputValues);
var prop = (PropertyInfo)((MemberExpression)selector.Body).Member;
prop.SetValue(entity, value);
}
return(entity);
}
public HeaderAmalgamator(IAmalgamator <MessageHeaderSource> sourceAmalgamator, IAmalgamator <MessageHeaderCollectionDetails> collectionDetailsAmalgamator, IAmalgamationErrorHandler amalgamationErrorHandler)
: base(Entity.Header, (x) => x.SourceFileName, amalgamationErrorHandler)
{
_sourceAmalgamator = sourceAmalgamator;
_collectionDetailsAmalgamator = collectionDetailsAmalgamator;
}
public TValue TestAmalgamatorSuccess <T, TValue>(Expression <Func <T, TValue> > propertySelector, TValue value, Func <T> constructor, IAmalgamator <T> amalgamator)
{
var selectorFunc = propertySelector.Compile();
var inputModels = GetInputModels(propertySelector, value, constructor);
var amalgamatedModel = amalgamator.Amalgamate(inputModels);
var result = amalgamatedModel.GetType().GetProperty(((MemberExpression)propertySelector.Body).Member.Name).GetValue(amalgamatedModel);
return((TValue)result);
}
public T ApplyGroupedChildCollectionRuleCaller <TValue, TGroupBy>(Expression <Func <T, IEnumerable <TValue> > > selector, Expression <Func <TValue, TGroupBy> > groupBySelector, IAmalgamator <TValue> amalgamator, IEnumerable <T> inputEntities, T entity)
{
return(ApplyGroupedChildCollectionRule(selector, groupBySelector, amalgamator, inputEntities, entity));
}
public T ApplyChildRuleCaller <TValue>(Expression <Func <T, TValue> > selector, IAmalgamator <TValue> amalgamator, IEnumerable <T> inputEntities, T entity)
{
return(ApplyChildRule(selector, amalgamator, inputEntities, entity));
}
public AmalgamationService(IAmalgamator <Message> messageAmalgamator, IAmalgamationErrorHandler amalgamationErrorHandler)
{
_messageAmalgamator = messageAmalgamator;
_amalgamationErrorHandler = amalgamationErrorHandler;
}
/// <summary>
/// Retrieves the amalgam for an amalgamator, as-casted to an instance type. This method calls <see cref="GetAmalgam"/>, which provides an amalgam cache.
/// </summary>
/// <typeparam name="T">The instance type to which to cast the amalgam.</typeparam>
/// <param name="amalgamator">The amalgamator.</param>
/// <returns>The amalgam.</returns>
public static T As <T>(this IAmalgamator amalgamator) where T : class
{
return(amalgamator.GetAmalgam() as T);
}
protected T ApplyGroupedChildCollectionRule <TValue, TGroupBy>(Expression <Func <T, IEnumerable <TValue> > > selector, Expression <Func <TValue, TGroupBy> > groupBySelector, IAmalgamator <TValue> amalgamator, IEnumerable <T> inputEntities, T entity)
{
if (inputEntities == null || inputEntities.Count() < 1)
{
return(default(T));
}
var selectorFunc = selector.Compile();
var groupByFunc = groupBySelector.Compile();
if (!inputEntities.Any(e => e != null && selectorFunc.Invoke(e) != null))
{
return(default(T));
}
var amalgamatedGroups = inputEntities
.Where(e => e != null)
.Select(selectorFunc)
.Where(x => x != null)
.SelectMany(x => x)
.GroupBy(groupByFunc)
.Select(amalgamator.Amalgamate)
.ToList();
if (amalgamatedGroups.Any())
{
var prop = (PropertyInfo)((MemberExpression)selector.Body).Member;
prop.SetValue(entity, amalgamatedGroups);
}
return(entity);
}
