/// <summary>
/// This is needed in both the generic and specific controllers, so we move it out here
/// </summary>
public static Query <Document> SearchImpl(Query <Document> query, GetArguments args, IEnumerable <AbstractPermission> filteredPermissions)
{
string search = args.Search;
if (!string.IsNullOrWhiteSpace(search))
{
search = search.Replace("'", "''"); // escape quotes by repeating them
// TODO:
// IF the search starts with the serial prefix (case insensitive) then search the serial numbers exclusively
// ELSE: search the memo etc normally
var memo = nameof(Document.Memo);
var serialNumber = nameof(Document.SerialNumber);
var filterString = $"{memo} {Ops.contains} '{search}'";
// If the search is a number, include the result with that serial number
if (int.TryParse(search.Trim(), out int searchNumber))
{
filterString = $"{filterString} or {serialNumber} eq {searchNumber}";
}
query = query.Filter(FilterExpression.Parse(filterString));
}
return(query);
}
protected override Query <InboxRecord> Search(Query <InboxRecord> query, GetArguments args)
{
string search = args.Search;
if (!string.IsNullOrWhiteSpace(search))
{
search = search.Replace("'", "''"); // escape quotes by repeating them
var createdByProp = nameof(InboxRecord.CreatedBy);
var nameProp = $"{createdByProp}.{nameof(User.Name)}";
var name2Prop = $"{createdByProp}.{nameof(User.Name2)}";
var name3Prop = $"{createdByProp}.{nameof(User.Name3)}";
var commentProp = nameof(InboxRecord.Comment);
var memoProp = $"{nameof(InboxRecord.Document)}.{nameof(Document.Memo)}";
// Prepare the filter string
var filterString = $"{nameProp} contains '{search}' or {name2Prop} contains '{search}' or {name3Prop} contains '{search}' or {commentProp} contains '{search}' or {memoProp} contains '{search}'";
// Apply the filter
query = query.Filter(ExpressionFilter.Parse(filterString));
}
return(query);
}
protected override Query <ExchangeRate> Search(Query <ExchangeRate> query, GetArguments args)
{
string search = args.Search;
if (!string.IsNullOrWhiteSpace(search))
{
search = search.Replace("'", "''"); // escape quotes by repeating them
var currencyProp = nameof(ExchangeRate.Currency);
var idProp = $"{currencyProp}.{nameof(Currency.Id)}";
var nameProp = $"{currencyProp}.{nameof(Currency.Name)}";
var name2Prop = $"{currencyProp}.{nameof(Currency.Name2)}";
var name3Prop = $"{currencyProp}.{nameof(Currency.Name3)}";
var descProp = $"{currencyProp}.{nameof(Currency.Description)}";
var desc2Prop = $"{currencyProp}.{nameof(Currency.Description2)}";
var desc3Prop = $"{currencyProp}.{nameof(Currency.Description3)}";
// Prepare the filter string
var filterString = $"{idProp} contains '{search}' or {nameProp} contains '{search}' or {name2Prop} contains '{search}' or {name3Prop} contains '{search}' or {descProp} contains '{search}' or {desc2Prop} contains '{search}' or {desc3Prop} contains '{search}'";
// If the search is a date, include documents with that date
if (DateTime.TryParse(search.Trim(), out DateTime searchDate))
{
var validAsOfProp = nameof(ExchangeRate.ValidAsOf);
filterString = $"{filterString} or {validAsOfProp} eq {searchDate:yyyy-MM-dd}";
}
// Apply the filter
query = query.Filter(ExpressionFilter.Parse(filterString));
}
return(query);
}
protected async Task <IActionResult> GetAsync <TModel>(GetArguments <TEntity, TModel> arguments)
{
var query = this.context.Set <TEntity>()
.AsNoTracking();
if (this.DefaultPredicate != null)
{
query = query.Where(this.DefaultPredicate);
}
if (typeof(DAL.IHasSoftDelete).IsAssignableFrom(typeof(TEntity)))
{
query = query.Cast <DAL.IHasSoftDelete>().Where(x => !x.IsDeleted).Cast <TEntity>();
}
if (arguments.Predicate != null)
{
query = query.Where(arguments.Predicate);
}
var model = await query
.Select(arguments.Selector)
.SingleOrDefaultAsync();
if (model == null)
{
return(this.NotFound());
}
return(this.Ok(model));
}
public virtual async Task <ActionResult <GetFactResponse> > GetFact([FromQuery] GetArguments args, CancellationToken cancellation)
{
return(await ControllerUtilities.InvokeActionImpl(async() =>
{
using var _ = _instrumentation.Block("Controller GetFact");
// Calculate server time at the very beginning for consistency
var serverTime = DateTimeOffset.UtcNow;
// Retrieves the raw data from the database, unflattend, untrimmed
var service = GetFactService();
var(data, isPartial, count) = await service.GetFact(args, cancellation);
// Prepare the result in a response object
var result = new GetFactResponse
{
IsPartial = isPartial,
ServerTime = serverTime,
Result = data,
TotalCount = count
};
return Ok(result);
}, _logger));
}
public async Task Get(GetArguments arguments)
{
var(app, service) = Configuration.GetClient();
var schemasClient = service.CreateSchemasClient();
var schema = await schemasClient.GetSchemaAsync(app, arguments.Name);
Console.WriteLine(schema.JsonPrettyString());
}
protected override Query <SummaryEntry> Search(Query <SummaryEntry> query, GetArguments args, IEnumerable <AbstractPermission> filteredPermissions)
{
//string search = args.Search;
//if (!string.IsNullOrWhiteSpace(search))
//{
// search = search.Replace("'", "''"); // escape quotes by repeating them
// var name = nameof(SummaryEntry.Name);
// query = query.Filter($"{name} {Ops.contains} '{search}'");
//}
return(query);
}
public void ShouldGetArgumentsOfInvokedMethod()
{
MockFactory mocks = new MockFactory();
string message = "hello";
Mock <IMessageService> serviceMock = mocks.CreateMock <IMessageService>();
MessageController controller = new MessageController(serviceMock.MockObject);
serviceMock.Expects.One.Method(_ => _.GetMessage(0, null)).With(Is.EqualTo(23), Is.Anything)
.Will(GetArguments.WhenCalled(arguments => (arguments[1] as Action <string>).Invoke(message)));
controller.GetMessage(23);
Assert.AreEqual(message, controller.Message);
}
protected override Query <LegacyType> Search(Query <LegacyType> query, GetArguments args, IEnumerable <AbstractPermission> filteredPermissions)
{
string search = args.Search;
if (!string.IsNullOrWhiteSpace(search))
{
search = search.Replace("'", "''"); // escape quotes by repeating them
var name = nameof(LegacyType.Name);
var name2 = nameof(LegacyType.Name2);
var name3 = nameof(LegacyType.Name3);
query = query.Filter($"{name} {Ops.contains} '{search}' or {name2} {Ops.contains} '{search}' or {name3} {Ops.contains} '{search}'");
}
return(query);
}
protected override Query <DetailsEntry> Search(Query <DetailsEntry> query, GetArguments args)
{
string search = args.Search;
if (!string.IsNullOrWhiteSpace(search))
{
search = search.Replace("'", "''"); // escape quotes by repeating them
var line = nameof(DetailsEntry.Line);
var memo = nameof(LineForQuery.Memo);
var text1 = nameof(LineForQuery.Text1);
var filterString = $"{line}.{memo} contains '{search}' or {line}.{text1} contains '{search}' ";
query = query.Filter(ExpressionFilter.Parse(filterString));
}
return(query);
}
protected override Query <EntryType> Search(Query <EntryType> query, GetArguments args)
{
string search = args.Search;
if (!string.IsNullOrWhiteSpace(search))
{
search = search.Replace("'", "''"); // escape quotes by repeating them
var name = nameof(EntryType.Name);
var name2 = nameof(EntryType.Name2);
var name3 = nameof(EntryType.Name3);
var code = nameof(EntryType.Code);
query = query.Filter($"{name} contains '{search}' or {name2} contains '{search}' or {name3} contains '{search}' or {code} contains '{search}'");
}
return(query);
}
/// <summary>
/// This is needed in both the generic and specific controllers, so we move it out here
/// </summary>
public static Query <Resource> SearchImpl(Query <Resource> query, GetArguments args, IEnumerable <AbstractPermission> _)
{
string search = args.Search;
if (!string.IsNullOrWhiteSpace(search))
{
search = search.Replace("'", "''"); // escape quotes by repeating them
var name = nameof(Resource.Name);
var name2 = nameof(Resource.Name2);
var name3 = nameof(Resource.Name3);
var code = nameof(Resource.Code);
query = query.Filter($"{name} {Ops.contains} '{search}' or {name2} {Ops.contains} '{search}' or {name3} {Ops.contains} '{search}' or {code} {Ops.contains} '{search}'");
}
return(query);
}
protected override Query <Agent> Search(Query <Agent> query, GetArguments args)
{
string search = args.Search;
if (!string.IsNullOrWhiteSpace(search))
{
search = search.Replace("'", "''"); // escape quotes by repeating them
var name = nameof(Agent.Name);
var name2 = nameof(Agent.Name2);
var name3 = nameof(Agent.Name3);
var filterString = $"{name} contains '{search}' or {name2} contains '{search}' or {name3} contains '{search}'";
query = query.Filter(ExpressionFilter.Parse(filterString));
}
return(query);
}
/// <summary>
/// This is needed in both the generic and specific controllers, so we move it out here
/// </summary>
public static Query <Resource> SearchImpl(Query <Resource> query, GetArguments args)
{
string search = args.Search;
if (!string.IsNullOrWhiteSpace(search))
{
search = search.Replace("'", "''"); // escape quotes by repeating them
var name = nameof(Resource.Name);
var name2 = nameof(Resource.Name2);
var name3 = nameof(Resource.Name3);
var code = nameof(Resource.Code);
var identifier = nameof(Resource.Identifier);
query = query.Filter($"{name} contains '{search}' or {name2} contains '{search}' or {name3} contains '{search}' or {code} contains '{search}' or {identifier} contains '{search}'");
}
return(query);
}
/// <summary>
/// This is needed in both the generic and specific controllers, so we move it out here
/// </summary>
public static Query <Agent> SearchImpl(Query <Agent> query, GetArguments args, IEnumerable <AbstractPermission> filteredPermissions)
{
string search = args.Search;
if (!string.IsNullOrWhiteSpace(search))
{
search = search.Replace("'", "''"); // escape quotes by repeating them
var name = nameof(Agent.Name);
var name2 = nameof(Agent.Name2);
var name3 = nameof(Agent.Name3);
var code = nameof(Agent.Code);
var filterString = $"{name} {Ops.contains} '{search}' or {name2} {Ops.contains} '{search}' or {name3} {Ops.contains} '{search}' or {code} {Ops.contains} '{search}'";
query = query.Filter(FilterExpression.Parse(filterString));
}
return(query);
}
/// <summary>
/// This is needed in both the generic and specific controllers, so we move it out here
/// </summary>
public static Query <Custody> SearchImpl(Query <Custody> query, GetArguments args)
{
string search = args.Search;
if (!string.IsNullOrWhiteSpace(search))
{
search = search.Replace("'", "''"); // escape quotes by repeating them
var name = nameof(Custody.Name);
var name2 = nameof(Custody.Name2);
var name3 = nameof(Custody.Name3);
var code = nameof(Custody.Code);
var filterString = $"{name} contains '{search}' or {name2} contains '{search}' or {name3} contains '{search}' or {code} contains '{search}'";
query = query.Filter(ExpressionFilter.Parse(filterString));
}
return(query);
}
public async Task Get(GetArguments arguments)
{
var session = configuration.StartSession();
var schema = await session.Schemas.GetSchemaAsync(session.App, arguments.Name);
if (arguments.WithReferencedNames)
{
var allSchemas = await session.Schemas.GetSchemasAsync(session.App);
var result = new SchemaWithRefs <SchemaDto>(schema).EnrichSchemaNames(allSchemas.Items);
log.WriteLine(result.JsonPrettyString());
}
else
{
log.WriteLine(schema.JsonPrettyString());
}
}
public async Task Get(GetArguments arguments)
{
var(app, service) = Configuration.GetClient();
var schemasClient = service.CreateSchemasClient();
var schema = await schemasClient.GetSchemaAsync(app, arguments.Name);
if (arguments.WithReferencedNames)
{
var allSchemas = await schemasClient.GetSchemasAsync(app);
var result = new SchemaWithRefs <SchemaDetailsDto>(schema).EnrichSchemaNames(allSchemas);
Console.WriteLine(result.JsonPrettyString());
}
else
{
Console.WriteLine(schema.JsonPrettyString());
}
}
protected override Query <EmailForQuery> Search(Query <EmailForQuery> query, GetArguments args)
{
string search = args.Search;
if (!string.IsNullOrWhiteSpace(search))
{
search = search.Replace("'", "''"); // escape quotes by repeating them
var toEmail = nameof(EmailForQuery.ToEmail);
var subject = nameof(EmailForQuery.Subject);
// Prepare the filter string
var filterString = $"{toEmail} contains '{search}' or {subject} contains '{search}'";
// Apply the filter
query = query.Filter(ExpressionFilter.Parse(filterString));
}
return(query);
}
protected override Query <IfrsConcept> Search(Query <IfrsConcept> query, GetArguments args)
{
string search = args.Search;
if (!string.IsNullOrWhiteSpace(search))
{
search = search.Replace("'", "''"); // escape quotes by repeating them
var labelProp = nameof(IfrsConcept.Label);
var label2Prop = nameof(IfrsConcept.Label2);
var label3Prop = nameof(IfrsConcept.Label3);
// Prepare the filter string
var filterString = $"{labelProp} contains '{search}' or {label2Prop} contains '{search}' or {label3Prop} contains '{search}'";
// Apply the filter
query = query.Filter(ExpressionFilter.Parse(filterString));
}
return(query);
}
protected override Query <Currency> Search(Query <Currency> query, GetArguments args, IEnumerable <AbstractPermission> filteredPermissions)
{
string search = args.Search;
if (!string.IsNullOrWhiteSpace(search))
{
search = search.Replace("'", "''"); // escape quotes by repeating them
var name = nameof(Currency.Name);
var name2 = nameof(Currency.Name2);
var name3 = nameof(Currency.Name3);
var desc = nameof(Currency.Description);
var desc2 = nameof(Currency.Description2);
var desc3 = nameof(Currency.Description3);
var filterString = $"{name} {Ops.contains} '{search}' or {name2} {Ops.contains} '{search}' or {name3} {Ops.contains} '{search}' or {desc} {Ops.contains} '{search}' or {desc2} {Ops.contains} '{search}' or {desc3} {Ops.contains} '{search}'";
query = query.Filter(FilterExpression.Parse(filterString));
}
return(query);
}
protected override Query <Currency> Search(Query <Currency> query, GetArguments args)
{
string search = args.Search;
if (!string.IsNullOrWhiteSpace(search))
{
search = search.Replace("'", "''"); // escape quotes by repeating them
var id = nameof(Currency.Id);
var name = nameof(Currency.Name);
var name2 = nameof(Currency.Name2);
var name3 = nameof(Currency.Name3);
var desc = nameof(Currency.Description);
var desc2 = nameof(Currency.Description2);
var desc3 = nameof(Currency.Description3);
var filterString = $"{id} contains '{search}' or {name} contains '{search}' or {name2} contains '{search}' or {name3} contains '{search}' or {desc} contains '{search}' or {desc2} contains '{search}' or {desc3} contains '{search}'";
query = query.Filter(ExpressionFilter.Parse(filterString));
}
return(query);
}
// Endpoint implementations
/// <summary>
/// Returns the entities as per the specifications in the get request
/// </summary>
protected virtual async Task <GetResponse <TEntity> > GetImplAsync(GetArguments args, Query <TEntity> queryOverride = null)
{
// Parse the parameters
var filter = FilterExpression.Parse(args.Filter);
var orderby = OrderByExpression.Parse(args.OrderBy);
var expand = ExpandExpression.Parse(args.Expand);
var select = SelectExpression.Parse(args.Select);
// Prepare the query
var query = queryOverride ?? GetRepository().Query <TEntity>();
// Retrieve the user permissions for the current view
var permissions = await UserPermissions(Constants.Read);
// Filter out permissions with masks that would be violated by the filter or order by arguments
var defaultMask = GetDefaultMask() ?? new MaskTree();
permissions = FilterViolatedPermissionsForFlatQuery(permissions, defaultMask, filter, orderby);
// Apply read permissions
var permissionsFilter = GetReadPermissionsCriteria(permissions);
query = query.Filter(permissionsFilter);
// Search
query = Search(query, args, permissions);
// Filter
query = query.Filter(filter);
// Before ordering or paging, retrieve the total count
int totalCount = await query.CountAsync();
// OrderBy
query = OrderBy(query, orderby);
// Apply the paging (Protect against DOS attacks by enforcing a maximum page size)
var top = args.Top;
var skip = args.Skip;
top = Math.Min(top, MaximumPageSize());
query = query.Skip(skip).Top(top);
// Apply the expand, which has the general format 'Expand=A,B/C,D'
var expandedQuery = query.Expand(expand);
// Apply the select, which has the general format 'Select=A,B/C,D'
expandedQuery = expandedQuery.Select(select);
// Load the data in memory
var result = await expandedQuery.ToListAsync();
// Apply the permission masks (setting restricted fields to null) and adjust the metadata accordingly
await ApplyReadPermissionsMask(result, query, permissions, defaultMask);
// Flatten and Trim
var relatedEntities = FlattenAndTrim(result, expand);
// Prepare the result in a response object
return(new GetResponse <TEntity>
{
Skip = skip,
Top = result.Count(),
OrderBy = args.OrderBy,
TotalCount = totalCount,
Result = result,
RelatedEntities = relatedEntities,
CollectionName = GetCollectionName(typeof(TEntity))
});
}
public virtual async Task <ActionResult <GetResponse <TEntity> > > Get([FromQuery] GetArguments args)
{
return(await GetInnerAsync(args));
}
protected virtual async Task <ActionResult <GetResponse <TEntity> > > GetInnerAsync(GetArguments args, Query <TEntity> queryOverride = null)
{
return(await ControllerUtilities.InvokeActionImpl(async() =>
{
var result = await GetImplAsync(args, queryOverride);
return Ok(result);
}, _logger));
}
/// <summary> /// Applies the search argument, which is handled differently in every controller /// </summary> protected abstract Query <TEntity> Search(Query <TEntity> query, GetArguments args, IEnumerable <AbstractPermission> filteredPermissions);
protected override Task <EntityQuery <MessageCommand> > Search(EntityQuery <MessageCommand> query, GetArguments args, CancellationToken _)
{
string search = args.Search;
if (!string.IsNullOrWhiteSpace(search))
{
search = search.Replace("'", "''"); // escape quotes by repeating them
// Prepare the filter string
var caption = nameof(MessageCommand.Caption);
var filterString = $"{caption} contains '{search}'";
// Apply the filter
query = query.Filter(filterString);
}
return(Task.FromResult(query));
}
protected override Query <RelationDefinition> Search(Query <RelationDefinition> query, GetArguments args)
{
string search = args.Search;
if (!string.IsNullOrWhiteSpace(search))
{
search = search.Replace("'", "''"); // escape quotes by repeating them
var titleP = nameof(RelationDefinition.TitlePlural);
var titleP2 = nameof(RelationDefinition.TitlePlural2);
var titleP3 = nameof(RelationDefinition.TitlePlural3);
var titleS = nameof(RelationDefinition.TitleSingular);
var titleS2 = nameof(RelationDefinition.TitleSingular2);
var titleS3 = nameof(RelationDefinition.TitleSingular3);
var code = nameof(RelationDefinition.Code);
query = query.Filter($"{titleS} contains '{search}' or {titleS2} contains '{search}' or {titleS3} contains '{search}' or {titleP} contains '{search}' or {titleP2} contains '{search}' or {titleP3} contains '{search}' or {code} contains '{search}'");
}
return(query);
}
protected override Query <DetailsEntry> Search(Query <DetailsEntry> query, GetArguments args, IEnumerable <AbstractPermission> filteredPermissions)
{
return(query);
}
protected override Query <SmsMessageForQuery> Search(Query <SmsMessageForQuery> query, GetArguments args)
{
string search = args.Search;
if (!string.IsNullOrWhiteSpace(search))
{
search = search.Replace("'", "''"); // escape quotes by repeating them
// Prepare the filter string
var message = nameof(SmsMessageForQuery.Message);
var filterString = $"{message} contains '{search}'";
// If the search term looks like a phone number, include the contact mobile in the search
if (phoneAtt.IsValid(search))
{
var e164 = ControllerUtilities.ToE164(search);
var toPhone = nameof(SmsMessageForQuery.ToPhoneNumber);
filterString += $" or {toPhone} startsw '{e164}'";
}
// Apply the filter
query = query.Filter(filterString);
}
return(query);
}
