public static List <Structures.ResponsibilitiesReport.ResponsibilitiesReportTableLine> AppendResponsibilitiesReportResult(
List <Structures.ResponsibilitiesReport.ResponsibilitiesReportTableLine> source,
System.Collections.Generic.IDictionary <IEntity, string> entitiesWithPresentation,
string moduleName,
int responsibilityPriority,
string sectionName,
IEntity mainEntity = null)
{
if (!entitiesWithPresentation.Any())
{
var emptyTableLine = Company.PublicFunctions.Module.CreateResponsibilitiesReportTableLine(moduleName, string.Empty, string.Empty, null);
emptyTableLine.Responsibility = sectionName;
emptyTableLine.Priority = responsibilityPriority;
source.Add(emptyTableLine);
}
foreach (var entityWithPresentation in entitiesWithPresentation)
{
var entityName = entityWithPresentation.Value;
var entityPriority = entitiesWithPresentation.Count > 1 ? responsibilityPriority + 1 : responsibilityPriority;
if (Equals(entityWithPresentation.Key, mainEntity) && entitiesWithPresentation.Count > 1)
{
entityName = string.Format("<b>{0}</b>", entityWithPresentation.Value);
entityPriority = responsibilityPriority;
}
var newTableLineRecord = Company.PublicFunctions.Module.CreateResponsibilitiesReportTableLine(moduleName,
sectionName,
entityName,
entityWithPresentation.Key);
newTableLineRecord.Priority = entityPriority;
source.Add(newTableLineRecord);
}
return(source);
}
private Expression ConvertDestinationExpressionToSourceExpression(Expression expression)
{
// call beforevisitors
expression = _beforeVisitors.Aggregate(expression, (current, before) => before.Visit(current));
var typeMap = _mapper.ConfigurationProvider.FindTypeMapFor(typeof(TDestination), typeof(TSource));
var visitor = new ExpressionMapper.MappingVisitor(_mapper.ConfigurationProvider, typeMap, _destQuery.Expression, _dataSource.Expression, null,
new[] { typeof(TSource) });
var sourceExpression = visitor.Visit(expression);
// apply parameters
if (_parameters != null && _parameters.Any())
{
var constantVisitor = new ExpressionBuilder.ConstantExpressionReplacementVisitor(_parameters);
sourceExpression = constantVisitor.Visit(sourceExpression);
}
// apply null guards in case the feature is enabled
if (_mapper.ConfigurationProvider.EnableNullPropagationForQueryMapping)
{
var nullGuardVisitor = new ExpressionBuilder.NullsafeQueryRewriter();
sourceExpression = nullGuardVisitor.Visit(sourceExpression);
}
// call aftervisitors
sourceExpression = _afterVisitors.Aggregate(sourceExpression, (current, after) => after.Visit(current));
return(sourceExpression);
}
public Expression CreateMapExpression(Type sourceType, Type destinationType, System.Collections.Generic.IDictionary <string, object> parameters = null, params MemberInfo[] membersToExpand)
{
parameters = parameters ?? new Dictionary <string, object>();
var cachedExpression =
_expressionCache.GetOrAdd(new ExpressionRequest(sourceType, destinationType, membersToExpand),
tp => CreateMapExpression(tp, new ConcurrentDictionary <ExpressionRequest, int>()));
if (!parameters.Any())
{
return(cachedExpression);
}
var visitor = new ConstantExpressionReplacementVisitor(parameters);
return(visitor.Visit(cachedExpression));
}
/// <summary>
/// Create an expression tree representing a mapping from the <typeparamref name="TSource"/> type to <typeparamref name="TDestination"/> type
/// Includes flattening and expressions inside MapFrom member configuration
/// </summary>
/// <typeparam name="TSource">Source Type</typeparam>
/// <typeparam name="TDestination">Destination Type</typeparam>
/// <param name="mappingEngine">Mapping engine instance</param>
/// <param name="parameters">Optional parameter object for parameterized mapping expressions</param>
/// <param name="membersToExpand">Expand members explicitly previously marked as members to explicitly expand</param>
/// <returns>Expression tree mapping source to destination type</returns>
public static Expression <Func <TSource, TDestination> > CreateMapExpression <TSource, TDestination>(
this IMappingEngine mappingEngine, System.Collections.Generic.IDictionary <string, object> parameters = null, params string[] membersToExpand)
{
//Expression.const
parameters = parameters ?? new Dictionary <string, object>();
var cachedExpression = (Expression <Func <TSource, TDestination> >)
_expressionCache.GetOrAdd(new ExpressionRequest(typeof(TSource), typeof(TDestination), membersToExpand),
tp => CreateMapExpression(mappingEngine, tp, DictionaryFactory.CreateDictionary <ExpressionRequest, int>()));
if (!parameters.Any())
{
return(cachedExpression);
}
var visitor = new ConstantExpressionReplacementVisitor(parameters);
return((Expression <Func <TSource, TDestination> >)visitor.Visit(cachedExpression));
}
public bool HasDerivedTypesToInclude()
{
return(_includedDerivedTypes.Any());
}