public static Query Build(ApplicationSchemaDefinition application, IEnumerable <FilterExpression> filters)
{
var filtersAsList = filters as IList <FilterExpression> ?? filters.ToList();
var parameters = new List <object>(filtersAsList.Count + 1);
var sql = new StringBuilder(filtersAsList.Count * 64);
sql.Append("select * from DataMap where application = ? ");
parameters.Add(application.ApplicationName);
if (filtersAsList.Any())
{
sql.Append("and (");
for (var i = 0; i < filtersAsList.Count; i++)
{
var filter = filtersAsList[i];
var suffix = (i < filtersAsList.Count - 1) ? "and " : ") ";
sql.AppendFormat("{0} {1}", filter.BuildSql(), suffix);
parameters.AddRange(filter.BuildParameters());
}
}
sql.Append(string.Format("limit {0}", MaxRows));
return(new Query(sql.ToString(), parameters.ToArray()));
}
public static PaginatedSearchRequestDto DefaultInstance(ApplicationSchemaDefinition schema)
{
var defaultSize = 30;
var paginationOptions = DefaultPaginationOptions;
if (schema != null)
{
var defaultSizeSt = schema.GetProperty(ApplicationSchemaPropertiesCatalog.DefaultPaginationSize);
if (defaultSizeSt != null)
{
defaultSize = Int32.Parse(defaultSizeSt);
}
var paginationOptionsSt = schema.GetProperty(ApplicationSchemaPropertiesCatalog.PaginationOptions);
if (paginationOptionsSt != null)
{
var paginationOptionsAux = paginationOptionsSt.Split(',');
var paginationOptionListAux = new List <int>();
foreach (var s in paginationOptionsAux)
{
int option;
if (int.TryParse(s, out option))
{
paginationOptionListAux.Add(option);
}
}
if (paginationOptionListAux.Count > 0)
{
paginationOptions = paginationOptionListAux;
}
}
}
return(new PaginatedSearchRequestDto(defaultSize, paginationOptions));
}
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));
}
public static async Task <CompositeDataMap> Expand(ApplicationSchemaDefinition compositeApplication, DataMap compositeDataMap)
{
var repository = new DataRepository();
var components = new List <Component>();
foreach (var composition in compositeApplication.Compositions)
{
var filters = new List <FilterExpression>();
// Handles the composition criteria, which can
// be either literals ("hardcoded") values or
// based on the data map current state.
foreach (var criterion in composition.EntityAssociation.Attributes)
{
var value = string.IsNullOrEmpty(criterion.Literal)
? compositeDataMap.Value(criterion.From)
: criterion.Literal;
filters.Add(new Exactly(criterion.To, value));
}
// Fetches all data maps ("components") that
// satisfies the composition criteria.
var componentApplication = composition.To();
var componentDataMaps = (await repository
.LoadAsync(componentApplication, filters))
.ToList();
components.Add(new Component(componentApplication, componentDataMaps));
}
return(new CompositeDataMap(compositeApplication, compositeDataMap, components));
}
public ApplicationMetadataDefinition(Guid?id, string name, string title, string entity,
string idFieldName, ApplicationSchemaDefinition schema)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (title == null)
{
throw new ArgumentNullException("title");
}
if (entity == null)
{
throw new ArgumentNullException("entity");
}
if (idFieldName == null)
{
throw new ArgumentNullException("idFieldName");
}
if (schema == null)
{
throw new ArgumentNullException("schema");
}
Id = id;
Name = name;
Title = title;
Entity = entity;
IdFieldName = idFieldName;
Schema = schema;
Schema.IdFieldName = idFieldName;
}
private static IEnumerable <EntityAssociation> HandleCompositions(IEnumerable <ApplicationCompositionDefinition> compositions, EntityMetadata entityMetadata, ApplicationSchemaDefinition appSchema)
{
return
(compositions.Select(
composition => {
var entityAssociation = entityMetadata.Associations.FirstOrDefault(a => a.Qualifier == composition.Relationship);
if (entityAssociation == null)
{
throw new InvalidOperationException(String.Format(MissingAssociation, composition.Relationship, entityMetadata.Name));
}
CompositionBuilder.InitializeCompositionSchemas(appSchema);
if (composition.Schema.Schemas == null)
{
return entityAssociation;
}
ApplicationSchemaDefinition schemaToUse = composition.Collection ? composition.Schema.Schemas.List : composition.Schema.Schemas.Detail;
if (schemaToUse == null)
{
return entityAssociation;
}
var entity = MetadataProvider.Entity(entityAssociation.To);
var slicedAttributes = entity.Attributes(EntityMetadata.AttributesMode.NoCollections)
.Where(attribute => schemaToUse.Fields
.Any(r => r.Attribute.Equals(attribute.Name)));
return new SlicedEntityAssociation(entityAssociation, slicedAttributes);
})
.ToList());
}
public byte[] ConvertGridToCsv(InMemoryUser user, ApplicationSchemaDefinition schema, IEnumerable <AttributeHolder> rows, Func <AttributeHolder, ApplicationFieldDefinition, string, string> ColumnValueDelegate = null)
{
var csv = new StringBuilder();
var enumerableFields = schema.Fields.Where(ShouldShowField());
var fields = enumerableFields as IList <ApplicationFieldDefinition> ?? enumerableFields.ToList();
// HEADER: line of comma separated labels
var header = string.Join(",", fields.Select(field => GetI18NLabel(field, schema.Name)));
csv.AppendLine(header);
// ROWS
rows.ForEach(item => {
var row = new StringBuilder();
var values = fields.Select(field => {
var data = GetValueAsString(item, field);
if (ColumnValueDelegate != null)
{
data = ColumnValueDelegate(item, field, data);
}
var displayableData = AsDisplayableData(data, field, user);
return(AsCsvCompliantData(displayableData));
});
row.Append(string.Join(",", values));
csv.AppendLine(row.ToString());
});
// dump to byte array
return(Encoding.UTF8.GetBytes(csv.ToString()));
// return csv.ToString().GetBytes();
}
public static void OnNew(DataMap dataMap, ApplicationSchemaDefinition application, CompositeDataMap composite)
{
var context = new OnNewContext(application, MetadataRepository, User.Current, composite);
var behavior = GetBehavior(context.Application);
behavior.OnNew(context, dataMap);
}
public static void OnBeforeSave(DataMap dataMap, ApplicationSchemaDefinition application)
{
var context = new OnBeforeSaveContext(application, MetadataRepository, User.Current);
var behavior = GetBehavior(context.Application);
behavior.OnBeforeSave(context, dataMap);
}
private static bool ShouldFetchFromServer(ApplicationSchemaDefinition detail, ApplicationSchemaDefinition list)
{
if (detail == null)
{
//sometimes we might need only to see the list
return(false);
}
if (EnumerableExtensions.Any(detail.Associations) || EnumerableExtensions.Any(detail.Compositions))
{
return(true);
}
foreach (var displayable in detail.Displayables)
{
if (!(displayable is IApplicationAttributeDisplayable))
{
return(true);
}
var attrDisplayable = (IApplicationAttributeDisplayable)displayable;
if (list.Fields.All(f => f.Attribute != attrDisplayable.Attribute))
{
return(true);
}
}
//return true, if detail has more data then list
return(false);
}
private static void OverrideReferenceValues(ApplicationSchemaDefinition schema, ReferenceDisplayable reference, IApplicationDisplayable applicationDisplayable)
{
if (reference.ShowExpression != null)
{
applicationDisplayable.ShowExpression = GetPropertyValue(schema, reference, reference.ShowExpression);
}
if (reference.EnableExpression != null)
{
applicationDisplayable.EnableExpression = GetPropertyValue(schema, reference, reference.EnableExpression);
}
if (reference.Label != null)
{
((IApplicationAttributeDisplayable)applicationDisplayable).Label = GetPropertyValue(schema, reference, reference.Label);
}
if (reference.Attribute != null)
{
((IApplicationAttributeDisplayable)applicationDisplayable).Attribute = GetPropertyValue(schema, reference, reference.Attribute);
}
if (reference.ReadOnly != null)
{
applicationDisplayable.ReadOnly = reference.ReadOnly;
}
}
public static ApplicationSchemaDefinition GetInstance(
String applicationName, string title, string schemaId, SchemaStereotype stereotype,
SchemaMode?mode, ClientPlatform?platform, bool @abstract,
[NotNull] List <IApplicationDisplayable> displayables, [NotNull] IDictionary <string, string> schemaProperties,
ApplicationSchemaDefinition parentSchema, ApplicationSchemaDefinition printSchema, [NotNull] ApplicationCommandSchema commandSchema,
string idFieldName, string unionSchema)
{
var schema = new ApplicationSchemaDefinition(applicationName, title, schemaId, stereotype, mode, platform,
@abstract, displayables, schemaProperties, parentSchema, printSchema, commandSchema, idFieldName, unionSchema);
if (schema.ParentSchema != null)
{
schema.Displayables = MergeParentSchemaDisplayables(schema, schema.ParentSchema);
schema.Mode = schema.Mode == null || schema.Mode == SchemaMode.None ? schema.ParentSchema.Mode : schema.Mode;
schema.Stereotype = schema.Stereotype == SchemaStereotype.None ? schema.ParentSchema.Stereotype : schema.Stereotype;
MergeWithParentProperties(schema);
MergeWithParentCommands(schema);
}
schema.Title = title ?? BuildDefaultTitle(schema);
AddHiddenRequiredFields(schema);
MergeWithStereotypeSchema(schema);
schema.FkLazyFieldsResolver = ApplicationSchemaLazyFkHandler.LazyFkResolverDelegate;
schema.ComponentDisplayableResolver = ReferenceHandler.ComponentDisplayableResolver;
return(schema);
}
private static IList <FieldBinding> BindFields(DataMap dataMap, ApplicationSchemaDefinition application, Func <ApplicationFieldDefinition, IValueProvider> valueProviderFactory)
{
var bindings = application
.Fields
.Select(f => new FieldBinding(f, valueProviderFactory(f)))
.ToList();
foreach (var binding in bindings)
{
try
{
var value = dataMap.Value(binding.Metadata);
// Formats the raw value to its
// appropriate representation;
var formattedValue = binding
.Metadata
.Widget()
.Format(value);
binding.ValueProvider.Value = formattedValue;
}
catch
{
Console.Write(binding.Metadata.Attribute);
}
}
return(bindings);
}
private static List <IApplicationDisplayable> OnApplySecurityPolicy(ApplicationSchemaDefinition schema, IEnumerable <Role> userRoles)
{
var activeFieldRoles = RoleManager.ActiveFieldRoles();
if (activeFieldRoles == null || activeFieldRoles.Count == 0)
{
return(schema.Displayables);
}
var resultingFields = new List <IApplicationDisplayable>();
foreach (var field in schema.Displayables)
{
if (!activeFieldRoles.Contains(field.Role))
{
resultingFields.Add(field);
}
else
{
var enumerable = userRoles as IList <Role> ?? userRoles.ToList();
if (enumerable.Any(r => r.Name == field.Role))
{
resultingFields.Add(field);
}
}
}
return(resultingFields);
}
public void SetFromSearchString(ApplicationSchemaDefinition appSchema, IList <String> searchFields, String searchText)
{
var sbParams = new StringBuilder();
var sbValues = new StringBuilder();
//First, verify if searchText is datetime...
var param = new SearchParameter(searchText);
var fieldsToSearch =
appSchema.Fields.Where(f => param.IsDate ? f.RendererType == "datetime" : f.RendererType != "datetime");
fieldsToSearch = fieldsToSearch.Where(f => searchFields.Contains(f.Attribute));
var applicationFieldDefinitions = fieldsToSearch as ApplicationFieldDefinition[] ?? fieldsToSearch.ToArray();
if (!applicationFieldDefinitions.Any())
{
return;
}
foreach (var field in applicationFieldDefinitions)
{
sbParams.Append(field.Attribute);
sbParams.Append(SearchUtils.SearchParamOrSeparator);
sbValues.Append(searchText);
sbValues.Append(SearchUtils.SearchValueSeparator);
}
sbParams.Remove(sbParams.Length - 3, 3);
sbValues.Remove(sbValues.Length - 3, 3);
SearchParams = sbParams.ToString();
SearchValues = sbValues.ToString();
}
public void TestSchemaTitle()
{
ApplicationConfiguration.TestclientName = "hapag";
MetadataProvider.StubReset();
var catalogs = _resolver.FetchCatalogs();
var schemas = MetadataProvider.Application("servicerequest").Schemas();
var schema = schemas[new ApplicationMetadataSchemaKey("list", "input", "web")];
var value = _resolver.DoGetI18NSchemaTitle(schema, "de");
Assert.AreEqual("Service Request Tabelle", value);
var missingSchema = new ApplicationSchemaDefinition {
SchemaId = "fake",
ApplicationName = "fake",
Title = "fake"
};
value = _resolver.DoGetI18NSchemaTitle(missingSchema, "de");
Assert.AreEqual("fake", value);
missingSchema = new ApplicationSchemaDefinition {
ApplicationName = "servicerequest",
SchemaId = "fake",
Title = "fake"
};
value = _resolver.DoGetI18NSchemaTitle(missingSchema, "de");
Assert.AreEqual("fake", value);
ApplicationConfiguration.TestclientName = "fake";
_resolver.ClearCache();
value = _resolver.DoGetI18NSchemaTitle(schema, "de");
Assert.AreEqual(schema.Title, value);
}
/// <summary>
/// Returns all data maps that satisfy the specified filter.
/// </summary>
/// <param name="application">The application metadata.</param>
/// <param name="filters">The search criteria.</param>
/// <param name="cancellationToken">The cancellation token.</param>
public async Task <List <DataMap> > LoadAsync(ApplicationSchemaDefinition application, IEnumerable <FilterExpression> filters, CancellationToken cancellationToken = default(CancellationToken))
{
var query = QueryBuilder.Build(application, filters);
var result = (await Database
.GetConnection(cancellationToken)
.QueryAsync <PersistableDataMap>(query.Sql, query.Parameters))
.Select(map => map.ToDataMap())
.ToList();
//Next and previous are counter-intuitive because the list is ordered on the inverse way
for (int i = 0; i < result.Count; i++)
{
var currentMap = result[i];
if (i != 0)
{
currentMap.Next = result[i - 1];
}
if (i != result.Count - 1)
{
currentMap.Previous = result[i + 1];
}
Dispatcher.OnLoad(currentMap, application);
}
return(result);
}
public async Task <DataMap> NewAsync(ApplicationSchemaDefinition application, CompositeDataMap dataMap = null)
{
var newDataMap = new DataMap(application);
// If we have no composite data map it means
// a "parent" data map is being created. For
// the sake of coherence, let's simply wrap
// it inside a CompositeDataMap structure.
if (null == dataMap)
{
dataMap = CompositeDataMap.Wrap(application, newDataMap);
}
else
{
// A component data map is being created.
// Let's link it to the composite root.
newDataMap.LocalState.ParentId = dataMap.Composite.LocalState.LocalId;
}
await Task
.Factory
.StartNew(() => Dispatcher.OnNew(newDataMap, application, dataMap));
return(newDataMap);
}
public byte[] ConvertGridToExcel(InMemoryUser user, ApplicationSchemaDefinition schema, IEnumerable <AttributeHolder> rows)
{
IEnumerable <ApplicationFieldDefinition> applicationFields = schema.Fields;
using (var resultStream = new MemoryStream())
using (var ms = new MemoryStream())
using (var xl = SpreadsheetDocument.Create(ms, SpreadsheetDocumentType.Workbook)) {
// var ms = new MemoryStream();
// attributes of elements
// the xml writer
OpenXmlWriter writer;
int rowIdx;
var worksheetpart = Setup(xl, out writer, out rowIdx, schema);
// create header row
CreateHeaderRow(applicationFields, writer, rowIdx, schema.Name, schema.SchemaId);
//count up row
rowIdx++;
// write data rows
DoWriteRows(user, schema, rows, rowIdx, writer, applicationFields);
Finish(writer, xl, worksheetpart);
return(ms.ToArray());
}
}
//for testing purposes
internal string DoGetI18NSchemaTitle(ApplicationSchemaDefinition schema, String language)
{
if (_cachedCatalogs == null)
{
_cachedCatalogs = FetchCatalogs();
}
if (language == null)
{
return(schema.Title);
}
var catalog = ((JObject)_cachedCatalogs[language]);
if (catalog == null)
{
//client has no catalog
return(schema.Title);
}
var appObject = catalog[schema.ApplicationName];
if (appObject == null)
{
//default
return(schema.Title);
}
var titleObject = appObject["_title"];
if (titleObject == null)
{
return(schema.Title);
}
var value = titleObject[schema.SchemaId];
return(value == null ? schema.Title : value.ToString());
}
public static ApplicationBehavior Resolve(ApplicationSchemaDefinition application)
{
var platformSpecificNamespace = string.Format("{0}.{1}", PlatformSpecificProbingNamespace, application.ApplicationName);
var applicationSpecificNamespace = string.Format("{0}.{1}", typeof(NamespaceAnchor).Namespace, application.ApplicationName);
// Let's probe for all custom commands
// eligible for this application behavior.
var commands = CommandResolver.Resolve(new[] { platformSpecificNamespace, applicationSpecificNamespace });
// Do we have a behavior specific for this
// application and platform? e.g. workorder
// on iOS.
// ReSharper disable once PossibleMultipleEnumeration
var platformSpecificBehavior = Instantiate(platformSpecificNamespace, application.ApplicationName, commands);
if (null != platformSpecificBehavior)
{
return(platformSpecificBehavior);
}
// Do we have a behavior specific for this
// application, but platform-independent?
// ReSharper disable once PossibleMultipleEnumeration
var applicationSpecificBehavior = Instantiate(applicationSpecificNamespace, application.ApplicationName, commands);
if (null != applicationSpecificBehavior)
{
return(applicationSpecificBehavior);
}
// Damn it, no luck. Let's return the
// base application behavior then.
// ReSharper disable once PossibleMultipleEnumeration
return(new ApplicationBehavior(commands));
}
public static void Init(TestContext testContext)
{
ApplicationConfiguration.TestclientName = "hapag";
MetadataProvider.StubReset();
var schemas = MetadataProvider.Application("asset").Schemas();
_schema = schemas[new ApplicationMetadataSchemaKey("detail", "output", "web")];
}
public static void Init(TestContext testContext)
{
ApplicationConfiguration.TestclientName = "otb";
MetadataProvider.StubReset();
var schemas = MetadataProvider.Application("invbalances").Schemas();
_schema = schemas[new ApplicationMetadataSchemaKey("list", "input", "web")];
}
private static Preview SetOrRetrieve(ApplicationSchemaDefinition definition, Preview value, string constValue)
{
if (value != null)
{
definition.ExtensionParameter(constValue, value);
}
return((Preview)definition.ExtensionParameter(constValue));
}
public static IDictionary <string, object> OnBeforeUpload(DataMap dataMap, ApplicationSchemaDefinition application)
{
var context = new OnBeforeUploadContext(application, MetadataRepository, User.Current);
var behavior = GetBehavior(context.Application);
behavior.OnBeforeUpload(context, dataMap);
return(context.Content);
}
public static ApplicationSchemaDefinition ApplyPolicy(this ApplicationSchemaDefinition schema, [NotNull] IEnumerable <Role> userRoles, ClientPlatform platform)
{
if (userRoles == null)
{
throw new ArgumentNullException("userRoles");
}
return(OnApplyPlatformPolicy(schema, platform, OnApplySecurityPolicy(schema, userRoles)));
}
public void Construct(ApplicationSchemaDefinition application, DataMap dataMap, bool isNew, CompositeDataMap composite, DetailController detailController, Action <DetailComponentController.Result> onCompletion)
{
_applicationMetadata = application;
_dataMap = dataMap;
_isNew = isNew;
_composite = composite;
_detailController = detailController;
_onCompletion = onCompletion;
}
private bool HasActionRedirectionDefinedByProperties(ApplicationSchemaDefinition schema, string operation)
{
if (operation == OperationConstants.CRUD_CREATE || operation == OperationConstants.CRUD_UPDATE)
{
//TODO: distinguish all kind of operators --> oncreateevent.controller
return(schema.Properties.ContainsKey(ApplicationSchemaPropertiesCatalog.OnCrudSaveEventAction));
}
return(false);
}
private static void MergeWithParentCommands(ApplicationSchemaDefinition schema)
{
foreach (var parentCommand in schema.ParentSchema.CommandSchema.Commands)
{
if (!schema.CommandSchema.Commands.Contains(parentCommand))
{
schema.CommandSchema.Commands.Add(parentCommand);
}
}
}
public ApplicationListResult(int totalCount, PaginatedSearchRequestDto searchDTO,
IEnumerable <AttributeHolder> dataMap, ApplicationSchemaDefinition schema)
: base(dataMap, null)
{
Schema = schema;
PageResultDto = new PaginatedSearchRequestDto(totalCount, searchDTO.PageNumber, searchDTO.PageSize, searchDTO.SearchValues, searchDTO.PaginationOptions);
PageResultDto.SearchParams = searchDTO.SearchParams;
PageResultDto.FilterFixedWhereClause = searchDTO.FilterFixedWhereClause;
PageResultDto.UnionFilterFixedWhereClause = searchDTO.UnionFilterFixedWhereClause;
}
