/// <summary>
/// Creates a panel with a grid containing the business object
/// information
/// </summary>
/// <param name="formGrid">The grid to fill</param>
/// <returns>Returns the object containing the panel</returns>
private PanelFactoryInfo CreatePanelWithGrid(IUIFormGrid formGrid)
{
IEditableGridControl myGrid = _controlFactory.CreateEditableGridControl();
BusinessObject bo = _currentBusinessObject;
ClassDef classDef = bo.ClassDef;
DataSetProvider dataSetProvider = myGrid.Grid.DataSetProvider as DataSetProvider;
if (dataSetProvider != null)
{
dataSetProvider.ObjectInitialiser =
new RelationshipObjectInitialiser(bo, (RelationshipDef)classDef.GetRelationship(formGrid.RelationshipName),
formGrid.CorrespondingRelationshipName);
}
IBusinessObjectCollection collection =
bo.Relationships.GetRelatedCollection(formGrid.RelationshipName);
myGrid.SetBusinessObjectCollection(collection);
myGrid.Dock = DockStyle.Fill;
IPanel panel = _controlFactory.CreatePanel(formGrid.RelationshipName, _controlFactory);
panel.Controls.Add(myGrid);
PanelFactoryInfo panelFactoryInfo = new PanelFactoryInfo(panel);
panelFactoryInfo.FormGrids.Add(formGrid.RelationshipName, myGrid);
return(panelFactoryInfo);
}
public static T Invoke <T>(ApplicationSchemaDefinition schema, string stringToCheck, params object[] parameters)
{
if (stringToCheck.StartsWith("@"))
{
stringToCheck = stringToCheck.Substring(1);
}
if (stringToCheck.Contains("."))
{
//generic simple injector call
var strings = stringToCheck.Split('.');
var serviceName = strings[0];
var methodName = strings[1];
var ob = SimpleInjectorGenericFactory.Instance.GetObject <object>(serviceName);
if (ob != null)
{
return((T)ReflectionUtil.Invoke(ob, methodName, parameters));
}
//shouldn´t happen as theoretically method should have been checked by existence before
return(default(T));
}
//if no service is defined, applying dataset implementation
var dataSet = DataSetProvider.GetInstance().LookupDataSet(schema.ApplicationName, schema.SchemaId);
return((T)ReflectionUtil.Invoke(dataSet, stringToCheck, parameters));
}
private HapagImacDataSet GetImacDataSet()
{
if (_imacDataSet == null)
{
_imacDataSet = (HapagImacDataSet)DataSetProvider.GetInstance().LookupAsBaseDataSet("imac");
}
return(_imacDataSet);
}
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);
}
protected IDataSet FindDataSet(String applicationName, string missingParameter)
{
var dataSet = DataSetProvider.GetInstance().LookupDataSet(applicationName);
if (dataSet == null)
{
throw new InvalidOperationException(String.Format(DataSetNotFound, applicationName,
missingParameter));
}
return(dataSet);
}
/// <summary>
/// Reads the xlsx file from the given input file path and writes as a CSV file to the given output path
/// </summary>
/// <param name="inputFilePath">The complete path to the location of xlsx file which needs to be processed</param>
/// <param name="OutputFilePath">The complete path to which the output CSV should be written to</param>
public void Execute(string inputFilePath, string OutputFilePath)
{
var dataSet = DataSetProvider.GetDataSet(inputFilePath);
var skbData = PocoGenerator.GeneratePoco(dataSet, data => new SkbData(data));
//The Map column values should be in the order we desire ion output file
ClassMap <SkbData> classMapFun() => new Factory()
.CreateClassMapBuilder <SkbData>()
.Map(m => m.UserId).Name("User ID")
.Map(m => m.Height).Name("Height")
.Map(m => m.Age).Name("Age")
.Map(m => m.PrimaryScore).Name("Primary Score")
.Map(m => m.SecondaryScore).Name("Secondary Score")
.Build();
CsvWriter.WriteCsv(skbData, OutputFilePath, classMapFun);
}
public IGenericResponseResult GetCompositionData(CompositionRequestWrapperDTO dto)
{
var user = SecurityFacade.CurrentUser();
if (null == user)
{
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
var application = dto.Application;
var request = dto.Request;
var applicationMetadata = MetadataProvider.Application(application).ApplyPolicies(request.Key, user, ClientPlatform.Web);
ContextLookuper.FillContext(request.Key);
var compositionData = DataSetProvider
.LookupDataSet(application)
.GetCompositionData(applicationMetadata, request, dto.Data);
return(compositionData);
}
private void FetchAsync(SlicedEntityMetadata entityMetadata, EntityAssociation collectionAssociation, IDictionary <string, ApplicationCompositionSchema> compositionSchemas, IEnumerable <AttributeHolder> entitiesList,
ContextHolder ctx, Dictionary <string, EntityRepository.SearchEntityResult> results, PaginatedSearchRequestDto paginatedSearch)
{
Quartz.Util.LogicalThreadContext.SetData("context", ctx);
var lookupAttributes = collectionAssociation.Attributes;
var collectionEntityMetadata = MetadataProvider.Entity(collectionAssociation.To);
var targetCollectionAttribute = EntityUtil.GetRelationshipName(collectionAssociation.Qualifier);
var applicationCompositionSchema = compositionSchemas[collectionAssociation.Qualifier] as ApplicationCompositionCollectionSchema;
if (applicationCompositionSchema == null)
{
throw ExceptionUtil.InvalidOperation("collection schema {0} not found", collectionAssociation.Qualifier);
}
var lookupattributes = lookupAttributes as EntityAssociationAttribute[] ?? lookupAttributes.ToArray();
var attributeHolders = entitiesList as AttributeHolder[] ?? entitiesList.ToArray();
var matchingResultWrapper = new CollectionMatchingResultWrapper();
var searchRequestDto = BuildSearchRequestDto(applicationCompositionSchema, lookupattributes, matchingResultWrapper, attributeHolders, collectionEntityMetadata, paginatedSearch);
searchRequestDto.QueryAlias = collectionAssociation.To;
var firstAttributeHolder = attributeHolders.First();
if (applicationCompositionSchema.PrefilterFunction != null)
{
var dataSet = DataSetProvider.GetInstance().LookupDataSet(entityMetadata.ApplicationName);
//we will call the function passing the first entry, altough this method could have been invoked for a list of items (printing)
//TODO: think about it
var preFilterParam = new CompositionPreFilterFunctionParameters(entityMetadata.AppSchema, searchRequestDto, firstAttributeHolder, applicationCompositionSchema);
searchRequestDto = PrefilterInvoker.ApplyPreFilterFunction(dataSet, preFilterParam, applicationCompositionSchema.PrefilterFunction);
}
EntityRepository.SearchEntityResult queryResult = null;
if (paginatedSearch == null)
{
//if there´s no pagination needed we can just do one thread-query
queryResult = EntityRepository.GetAsRawDictionary(collectionEntityMetadata, searchRequestDto);
}
else
{
var tasks = new Task[2];
tasks[0] = Task.Factory.NewThread(() => {
queryResult = EntityRepository.GetAsRawDictionary(collectionEntityMetadata, searchRequestDto);
});
// one thread to count results for paginations
tasks[1] = Task.Factory.NewThread(() => {
paginatedSearch.TotalCount = EntityRepository.Count(collectionEntityMetadata, searchRequestDto);
});
Task.WaitAll(tasks);
// add paginationData to result
// creating a new pagination data in order to have everything calculated correctly
queryResult.PaginationData = new PaginatedSearchRequestDto(
paginatedSearch.TotalCount,
paginatedSearch.PageNumber,
paginatedSearch.PageSize,
paginatedSearch.SearchValues,
paginatedSearch.PaginationOptions
);
}
// one thread to fetch results
results.Add(collectionAssociation.Qualifier, queryResult);
if (attributeHolders.Length == 1)
{
//default scenario, we have just one entity here
firstAttributeHolder.Attributes.Add(targetCollectionAttribute, queryResult.ResultList);
return;
}
MatchResults(queryResult, matchingResultWrapper, targetCollectionAttribute);
}
