private ISet <IAssociationOption> BuildOptions(IEnumerable <AttributeHolder> queryResponse,
ApplicationAssociationDefinition association, ProjectionResult projectionResult)
{
ISet <IAssociationOption> options = new SortedSet <IAssociationOption>();
foreach (var attributeHolder1 in queryResponse)
{
var attributeHolder = (DataMap)attributeHolder1;
var value = attributeHolder.GetAttribute(projectionResult.ValueKey);
var labelNumber = association.LabelFields.Count;
var label = labelNumber == 1
? (string)attributeHolder.GetAttribute(association.LabelFields[0])
: BuildComplexLabel(attributeHolder, association);
if (association.ExtraProjectionFields.Count > 0)
{
options.Add(new MultiValueAssociationOption((string)value, label, attributeHolder));
}
else
{
options.Add(new AssociationOption((string)value, label));
}
}
return(options);
}
public static ApplicationAssociationDefinition GetInstance([NotNull] string @from, ApplicationAssociationDefinition.LabelData labelData, string target, string qualifier, ApplicationAssociationSchemaDefinition applicationAssociationSchema,
string showExpression, string toolTip, string required, ISet <ApplicationEvent> events, string defaultValue, string extraProjectionFields = null, string isEnabled = "true")
{
var association = new ApplicationAssociationDefinition(from, labelData, target, qualifier, applicationAssociationSchema, showExpression,
toolTip, required, defaultValue, isEnabled, events);
var labelField = labelData.LabelField;
association.LabelFields = ParseLabelFields(labelField);
association.ApplicationTo = ParseApplicationTo(labelField);
if (extraProjectionFields != null)
{
BuildExtraProjectionFields(association, extraProjectionFields);
}
association.SetLazyResolver(new Lazy <EntityAssociation>(
() => {
var appMetadata = MetadataProvider.Application(association.From);
var indexOf = labelField.IndexOf(".", StringComparison.Ordinal);
var firstPart = labelField.Substring(0, indexOf);
var lookupString = firstPart.EndsWith("_") ? firstPart : firstPart + "_";
if (Char.IsNumber(lookupString[0]))
{
lookupString = lookupString.Substring(1);
}
var entityAssociations = MetadataProvider.Entity(appMetadata.Entity).Associations;
return(entityAssociations.FirstOrDefault(a => a.Qualifier == lookupString));
}));
return(association);
}
private string BuildComplexLabel(AttributeHolder attributeHolder, ApplicationAssociationDefinition association)
{
var fmt = new object[association.LabelFields.Count];
for (var i = 0; i < association.LabelFields.Count; i++)
{
fmt[i] = attributeHolder.GetAttribute(association.LabelFields[i], true);
}
return(String.Format(association.LabelPattern, fmt));
}
private static void BuildExtraProjectionFields(ApplicationAssociationDefinition association, string extraProjectionFields)
{
string[] collection = extraProjectionFields.Split(',');
var relationshipName = EntityUtil.GetRelationshipName(association.ApplicationTo);
foreach (var s in collection)
{
association.ExtraProjectionFields.Add(s.Trim());
}
}
public static ApplicationMetadata GetAssociationApplicationMetadata(ApplicationAssociationDefinition association)
{
// See if association has a schema defined
string optionApplication;
string optionSchemaId;
association.Schema.RendererParameters.TryGetValue("application", out optionApplication);
association.Schema.RendererParameters.TryGetValue("schemaId", out optionSchemaId);
if (!String.IsNullOrWhiteSpace(optionApplication) && !String.IsNullOrWhiteSpace(optionSchemaId))
{
return(MetadataProvider
.Application(optionApplication)
.ApplyPolicies(new ApplicationMetadataSchemaKey(optionSchemaId), SecurityFacade.CurrentUser(), ClientPlatform.Web));
}
return(null);
}
/// <summary>
/// this is used for both autocompleteserver or lookup to peform the search on the server based upon the labe string
/// </summary>
/// <param name="request"></param>
/// <param name="association"></param>
/// <param name="searchRequest"></param>
private static void AppendSearchLabelString(AssociationUpdateRequest request,
ApplicationAssociationDefinition association, PaginatedSearchRequestDto searchRequest)
{
var sbParam = new StringBuilder("(");
var sbValue = new StringBuilder();
foreach (var labelField in association.LabelFields)
{
sbParam.Append(labelField).Append(SearchUtils.SearchParamOrSeparator);
sbValue.Append("%" + request.LabelSearchString + "%").Append(SearchUtils.SearchValueSeparator);
}
sbParam.Remove(sbParam.Length - SearchUtils.SearchParamOrSeparator.Length, SearchUtils.SearchParamOrSeparator.Length);
sbValue.Remove(sbValue.Length - SearchUtils.SearchValueSeparator.Length, SearchUtils.SearchValueSeparator.Length);
sbParam.Append(")");
searchRequest.AppendSearchEntry(sbParam.ToString(), sbValue.ToString());
}
public IEnumerable <IAssociationOption> ResolveOptions(ApplicationMetadata applicationMetadata,
AttributeHolder originalEntity, ApplicationAssociationDefinition association, SearchRequestDto associationFilter)
{
if (!FullSatisfied(association, originalEntity))
{
return(null);
}
// Set dependante lookup atributes
var lookupAttributes = association.LookupAttributes();
foreach (var lookupAttribute in lookupAttributes)
{
var searchValue = SearchUtils.GetSearchValue(lookupAttribute, originalEntity);
if (!String.IsNullOrEmpty(searchValue))
{
associationFilter.AppendSearchParam(lookupAttribute.To);
associationFilter.AppendSearchValue(searchValue);
}
else if (lookupAttribute.Query != null)
{
associationFilter.AppendWhereClause(lookupAttribute.GetQueryReplacingMarkers(association.EntityAssociation.To));
}
}
// Set projections and pre filter functions
var numberOfLabels = BuildProjections(associationFilter, association);
var prefilterFunctionName = association.Schema.DataProvider.PreFilterFunctionName;
if (prefilterFunctionName != null)
{
var preFilterParam = new AssociationPreFilterFunctionParameters(applicationMetadata, associationFilter, association, originalEntity);
associationFilter = PrefilterInvoker.ApplyPreFilterFunction(DataSetProvider.GetInstance().LookupDataSet(applicationMetadata.Name), preFilterParam, prefilterFunctionName);
}
var entityMetadata = MetadataProvider.Entity(association.EntityAssociation.To);
associationFilter.QueryAlias = association.AssociationKey;
var queryResponse = EntityRepository.Get(entityMetadata, associationFilter);
if (associationFilter is PaginatedSearchRequestDto)
{
var paginatedFilter = (PaginatedSearchRequestDto)associationFilter;
if (paginatedFilter.NeedsCountUpdate)
{
paginatedFilter.TotalCount = EntityRepository.Count(entityMetadata, associationFilter);
}
}
var options = BuildOptions(queryResponse, association, numberOfLabels);
string filterFunctionName = association.Schema.DataProvider.PostFilterFunctionName;
return(filterFunctionName != null?ApplyFilters(applicationMetadata.Name, originalEntity, filterFunctionName, options, association) : options);
}
public IEnumerable <IAssociationOption> ResolveOptions(ApplicationMetadata applicationMetadata,
AttributeHolder originalEntity, ApplicationAssociationDefinition association)
{
return(ResolveOptions(applicationMetadata, originalEntity, association, new SearchRequestDto()));
}
private static ProjectionResult BuildProjections(SearchRequestDto searchRequestDto, ApplicationAssociationDefinition association)
{
var valueField = association.EntityAssociation.PrimaryAttribute().To;
// See if association has a schema defined
var associationMetadata = GetAssociationApplicationMetadata(association);
var valueKey = ValueKeyConst;
var fields = association.LabelFields;
if (associationMetadata != null)
{
//if we have a schema then the projections should be all the fields out of it, except collections, instead of default labelfields
var entityMetatada = MetadataProvider.SlicedEntityMetadata(associationMetadata);
fields = entityMetatada.Attributes(EntityMetadata.AttributesMode.NoCollections).Select(a => a.Name).ToList();
}
foreach (var field in fields)
{
searchRequestDto.AppendProjectionField(new ProjectionField {
Alias = field, Name = field
});
if (field == valueField)
{
valueKey = field;
}
}
if (valueKey == ValueKeyConst)
{
searchRequestDto.AppendProjectionField(new ProjectionField {
Alias = ValueKeyConst, Name = valueField
});
}
foreach (var extraField in association.ExtraProjectionFields)
{
searchRequestDto.AppendProjectionField(new ProjectionField {
Alias = extraField, Name = extraField
});
}
return(new ProjectionResult(valueKey));
}
private IEnumerable <IAssociationOption> ApplyFilters(string applicationName, AttributeHolder originalEntity, string filterFunctionName, ISet <IAssociationOption> options, ApplicationAssociationDefinition association)
{
var dataSet = FindDataSet(applicationName, filterFunctionName);
var mi = dataSet.GetType().GetMethod(filterFunctionName);
if (mi == null)
{
throw new InvalidOperationException(String.Format(MethodNotFound, filterFunctionName, dataSet.GetType().Name));
}
if (mi.GetParameters().Count() != 1)
{
throw new InvalidOperationException(String.Format(WrongPostFilterMethod, filterFunctionName, dataSet.GetType().Name));
}
var postFilterParam = new AssociationPostFilterFunctionParameters()
{
Options = options,
OriginalEntity = originalEntity,
Association = association
};
return((IEnumerable <IAssociationOption>)mi.Invoke(dataSet, new object[] { postFilterParam }));
}
private static PaginatedSearchRequestDto BuildSearchDTO(AssociationUpdateRequest request, ApplicationAssociationDefinition association, AttributeHolder cruddata)
{
var searchRequest = new PaginatedSearchRequestDto(100, PaginatedSearchRequestDto.DefaultPaginationOptions);
if (request.SearchDTO == null)
{
request.SearchDTO = PaginatedSearchRequestDto.DefaultInstance(null);
}
searchRequest.PageNumber = request.SearchDTO.PageNumber;
searchRequest.PageSize = request.SearchDTO.PageSize;
//avoids pagination unless the association renderer defines so (lookup)
searchRequest.ShouldPaginate = association.IsPaginated();
searchRequest.NeedsCountUpdate = association.IsPaginated();
var valueSearchString = request.ValueSearchString;
if (association.IsLazyLoaded() && !request.HasClientSearch())
{
if ((cruddata == null || cruddata.GetAttribute(association.Target) == null))
{
//we should not update lazy dependant associations except in one case:
//there´s a default value in place already for the dependent association
// in that case, we would need to return a 1-value list to show on screen
return(null);
}
//this will force that the search would be made only on that specific value
//ex: autocomplete server, lookups that depend upon another association
valueSearchString = cruddata.GetAttribute(association.Target) as string;
}
if (request.AssociationKey != null)
{
// If association has a schema key defined, the searchDTO will be filled on client, so just copy it from request
searchRequest.SearchParams = request.SearchDTO.SearchParams;
searchRequest.SearchValues = request.SearchDTO.SearchValues;
}
else
{
if (!String.IsNullOrWhiteSpace(valueSearchString))
{
searchRequest.AppendSearchParam(association.EntityAssociation.PrimaryAttribute().To);
searchRequest.AppendSearchValue("%" + valueSearchString + "%");
}
if (!String.IsNullOrWhiteSpace(request.LabelSearchString))
{
AppendSearchLabelString(request, association, searchRequest);
}
}
return(searchRequest);
}
