public async Task <PagedQueryResultSet <AlertTemplateDto> > GetAsync(ResultSetCriteria gridCriteria, AlertTemplateSearchCriteria searchCriteria)
{
if (string.IsNullOrWhiteSpace(searchCriteria.Key))
{
searchCriteria.Key = "";
}
var result = await _dataContext.GetDocumentsWithPagingAsync <AlertTemplate, AlertTemplateDto>(q =>
q.Where(d =>
(searchCriteria.Culture == "any" || d.Culture == searchCriteria.Culture) &&
(searchCriteria.Section == "any" || d.Section == searchCriteria.Section) &&
(searchCriteria.Key == "" || d.Key.Contains(searchCriteria.Key.ToUpper().Trim())) &&
(searchCriteria.Channel == "any" || d.Channel == searchCriteria.Channel))
.Select(c => new AlertTemplateDto
{
Id = c.Id,
IsDeleted = c.IsDeleted,
Culture = c.Culture,
GroupId = c.GroupId,
Section = c.Section,
Key = c.Key,
Priority = c.Priority,
Channel = c.Channel,
ETag = c.ETag,
UpdatedOnUtc = c.UpdatedOnUtc,
UpdatedById = c.UpdatedById,
UpdatedByName = c.UpdatedByName
}), gridCriteria);
return(result);
}
public async Task <PagedQueryResultSet <LocalisationTextDto> > GetAsync(ResultSetCriteria gridCriteria, ConfigurationSearchCriteria searchCriteria)
{
if (string.IsNullOrWhiteSpace(searchCriteria.Key))
{
searchCriteria.Key = "";
}
var result = await _dataContext.GetDocumentsWithPagingAsync <LocalisationText, LocalisationTextDto>(q =>
q.Where(d =>
(searchCriteria.Culture == "any" || d.Culture == searchCriteria.Culture) &&
(searchCriteria.Section == "any" || d.Section == searchCriteria.Section) &&
(searchCriteria.Key == "" || d.Key.Contains(searchCriteria.Key.ToUpper().Trim())))
.Select(c => new LocalisationTextDto
{
Id = c.Id,
IsDeleted = c.IsDeleted,
Culture = c.Culture,
GroupId = c.GroupId,
Section = c.Section,
Key = c.Key,
Priority = c.Priority,
Value = c.Value,
IncludeInPod = c.IncludeInPod,
ETag = c.ETag,
UpdatedOnUtc = c.UpdatedOnUtc,
UpdatedById = c.UpdatedById,
UpdatedByName = c.UpdatedByName
}), gridCriteria);
return(result);
}
public async Task <PagedQueryResultSet <LookupDto> > GetLookupListAsync(ResultSetCriteria gridCriteria, ConfigurationSearchCriteria searchCriteria)
{
if (string.IsNullOrWhiteSpace(searchCriteria.Key))
{
searchCriteria.Key = "";
}
var result = await _dataContext.GetDocumentsWithPagingAsync <Lookup, Lookup>(q =>
q.Where(d =>
(searchCriteria.Culture == "any" || d.Culture == searchCriteria.Culture) &&
(searchCriteria.Section == "any" || d.Section == searchCriteria.Section) &&
(searchCriteria.Key == "" || d.Key.Contains(searchCriteria.Key.ToUpper().Trim()))),
gridCriteria);
var lookupDtoList = result.Results.Select(l => new LookupDto
{
Id = l.Id,
IsDeleted = l.IsDeleted,
Culture = l.Culture,
GroupId = l.GroupId,
Key = l.Key,
IncludeInPod = l.IncludeInPod,
Section = l.Section,
Priority = l.Priority,
UpdatedById = l.UpdatedById,
UpdatedByName = l.UpdatedByName,
UpdatedOnUtc = l.UpdatedOnUtc,
ItemValueList = l.Items.OrderBy(i => i.Value).Take(6).Select(item => item.Value)
}).ToList();
return(new PagedQueryResultSet <LookupDto> {
Results = lookupDtoList, ContinuationToken = result.ContinuationToken
});
}
public async Task <PagedQueryResultSet <GroupDto> > GetAsync(ResultSetCriteria gridCriteria, GroupSearchCriteria searchCriteria)
{
string searchText = searchCriteria.Name?.Trim().ToUpper() ?? string.Empty;
var groups = await _systemDataContext.GetDocumentsWithPagingAsync <Group, Group>(q =>
q.Where(d => searchText == string.Empty || d.Name.ToUpper().Contains(searchText)),
gridCriteria);
var groupDtoList = groups.Results.Select(c => new GroupDto
{
Id = c.Id,
Name = c.Name,
FirstName = c.FirstName,
LastName = c.LastName,
FullName = c.FullName,
MobileNumber = new MobileNumberDto
{
IddCode = c.MobileNumber?.IddCode,
Number = c.MobileNumber?.Number
},
Email = c.Email,
IsDeleted = c.IsDeleted,
UpdatedById = c.UpdatedById,
UpdatedByName = c.UpdatedByName,
UpdatedOnUtc = c.UpdatedOnUtc,
ETag = c.ETag
}).ToList();
return(new PagedQueryResultSet <GroupDto> {
Results = groupDtoList, ContinuationToken = groups.ContinuationToken
});
}
[ExcludeFromCodeCoverage] //We exclude this from CodeCoverage because LINQ ARRAY_CONTAINS is not supported in unit tests.
public async Task <PagedQueryResultSet <UserDto> > GetAsync(ResultSetCriteria gridCriteria, UserSearchCriteria searchCriteria)
{
string searchText = searchCriteria.Name?.Trim().ToUpper() ?? string.Empty;
#region GroupRoles ARRAY_CONTAINS expression support
var groupId = _requestContext.GroupId;
JObject customRoleMatch = new JObject();
Dictionary <string, object> arrayContainsMatches = null;
if (!string.IsNullOrEmpty(groupId))
{
customRoleMatch["group"] = groupId;
}
if (!string.IsNullOrEmpty(searchCriteria.Role) && searchCriteria.Role != "any")
{
customRoleMatch["role"] = searchCriteria.Role;
}
var skipGroupRoleMatch = (customRoleMatch.Properties().Count() == 0);
if (!skipGroupRoleMatch)
{
arrayContainsMatches = new Dictionary <string, object> {
{ "groupRoles", customRoleMatch }
}
}
;
#endregion
var users = await _systemDataContext.GetDocumentsWithPagingAsync <User, User>(q =>
q.Where(u => (searchText == string.Empty || u.NormalizedFullName.Contains(searchText)) &&
(skipGroupRoleMatch || u.GroupRoles.Contains(null)))
, gridCriteria, arrayContainsMatches);
var allowedGroups = await GetAllowedGroupIdsForLoggedInUserAsync(Permission_Search);
var userDtoList = users.Results.Select(u => new UserDto
{
Id = u.Id,
IsDeleted = u.IsDeleted,
FirstName = u.FirstName,
LastName = u.LastName,
FullName = u.FullName,
UpdatedById = u.UpdatedById,
UpdatedByName = u.UpdatedByName,
UpdatedOnUtc = u.UpdatedOnUtc,
GroupRoles = u.GroupRoles
.Where(cr => allowedGroups.Contains(cr.Group)) //Only show roles from allowed groups
.Select(cr => new UserGroupRoleDto
{
GroupId = cr.Group,
Role = cr.Role
}).OrderBy(cr => cr.GroupId).ThenBy(cr => cr.Role).ToList()
}).ToList();
return(new PagedQueryResultSet <UserDto> {
Results = userDtoList, ContinuationToken = users.ContinuationToken
});
}
public async Task <PagedQueryResultSet <ConfigurationSettingDto> > GetAsync(ResultSetCriteria gridCriteria, ConfigurationSearchCriteria searchCriteria)
{
string key = searchCriteria.Key ?? string.Empty;
var configurationList = (await _dataContext.GetDocumentsWithPagingAsync <ConfigurationSetting, ConfigurationSettingDto>
(q => q.Where(c =>
(searchCriteria.Culture == "any" || c.Culture == searchCriteria.Culture) &&
(searchCriteria.Section == "any" || c.Section == searchCriteria.Section) &&
(string.IsNullOrEmpty(key) || c.Key.ToLower().Contains(key.ToLower().Trim())))
.Select(c => new ConfigurationSettingDto
{
Id = c.Id,
IsDeleted = c.IsDeleted,
Culture = c.Culture,
GroupId = c.GroupId,
Section = c.Section,
Key = c.Key,
IncludeInPod = c.IncludeInPod,
Priority = c.Priority,
Value = c.Value,
ETag = c.ETag,
UpdatedOnUtc = c.UpdatedOnUtc,
UpdatedByName = c.UpdatedByName,
UpdatedById = c.UpdatedById
}), gridCriteria));
return(configurationList);
}
public virtual async Task <List <TResult> > GetEventsAsync <T, TResult>(Func <IQueryable <T>, IQueryable <TResult> > query,
string partitionKey, Dictionary <string, object> arrayContainsReplacements = null) where T : EventDocumentBase, new()
{
var criteria = new ResultSetCriteria();
var resultSet = await GetEventsWithPagingAsync(query, criteria, partitionKey, arrayContainsReplacements);
return(resultSet.Results);
}
public virtual async Task <bool> AnyAsync <T>(Func <IQueryable <T>, IQueryable <T> > query, bool includeDeleted = false) where T : AuditedDocumentBase, new()
{
var criteria = new ResultSetCriteria {
Limit = 1, IncludeDeleted = includeDeleted
};
var resultSet = await GetDocumentsWithPagingAsync <T, string>(q => query(q).Select(d => d.Id), criteria);
return(resultSet.Results.Count > 0);
}
public virtual async Task <TResult> FirstOrDefaultAsync <T, TResult>(Func <IQueryable <T>, IQueryable <TResult> > query, string partitionKey) where T : EventDocumentBase, new()
{
var criteria = new ResultSetCriteria {
Limit = 1
};
var resultSet = await GetEventsWithPagingAsync(query, criteria, partitionKey);
return(resultSet.Results.FirstOrDefault());
}
public virtual async Task <bool> AnyAsync <T>(Func <IQueryable <T>, IQueryable <T> > query, string partitionKey) where T : EventDocumentBase, new()
{
var criteria = new ResultSetCriteria {
Limit = 1
};
var resultSet = await GetEventsWithPagingAsync <T, string>(q => query(q).Select(d => d.Id), criteria, partitionKey);
return(resultSet.Results.Count > 0);
}
public virtual async Task <TResult> FirstOrDefaultAsync <T, TResult>(Func <IQueryable <T>, IQueryable <TResult> > query, bool includeDeleted = false) where T : AuditedDocumentBase, new()
{
var partitionKey = GetPartitionKey();
var criteria = new ResultSetCriteria {
Limit = 1, IncludeDeleted = includeDeleted
};
var resultSet = await GetDocumentsWithPagingAsync(query, criteria);
return(resultSet.Results.FirstOrDefault());
}
public virtual async Task <List <TResult> > GetDocumentsAsync <T, TResult>(Func <IQueryable <T>, IQueryable <TResult> > query,
bool includeDeleted = false, Dictionary <string, object> arrayContainsReplacements = null) where T : AuditedDocumentBase, new()
{
var criteria = new ResultSetCriteria {
IncludeDeleted = includeDeleted
};
var resultSet = await GetDocumentsWithPagingAsync(query, criteria, arrayContainsReplacements);
return(resultSet.Results);
}
public virtual async Task <PagedQueryResultSet <TResult> > GetEventsWithPagingAsync <T, TResult>(
Func <IQueryable <T>, IQueryable <TResult> > query,
ResultSetCriteria criteria, string partitionKey, Dictionary <string, object> arrayContainsReplacements = null) where T : EventDocumentBase, new()
{
var type = (new T()).DocType;
var resultSet = await _documentDbService.GetDocumentsWithPagingAsync <T, TResult>(_collectionId, partitionKey,
q => query(q.Where(doc => doc.DocType == type)),
criteria, arrayContainsReplacements);
return(resultSet);
}
public virtual async Task <PagedQueryResultSet <TResult> > GetDocumentsWithPagingAsync <T, TResult>(
string collectionId, string partitionKey,
Func <IQueryable <T>, IQueryable <TResult> > query,
ResultSetCriteria criteria = null, Dictionary <string, object> arrayContainsReplacements = null)
{
int pageSize = criteria?.Limit ?? 0;
string continuationToken = criteria?.PageToken;
var collectionUri = CreateCollectionUri(collectionId);
var feedOptions = new FeedOptions
{
PartitionKey = new PartitionKey(partitionKey),
//Set MaxItemCount to a fixed value when pageSize = 0
MaxItemCount = pageSize == 0 ? 500 : pageSize,
RequestContinuation = continuationToken
};
var q = _client.CreateDocumentQuery <T>(collectionUri, feedOptions);
var documentQuery = criteria != null?
query(q.OrderByFieldName(criteria.SortBy, criteria.IsAscending())).AsDocumentQuery() :
query(q).AsDocumentQuery();
//Use ARRAY_CONTAINS hack, if replacements are specified.
if (arrayContainsReplacements != null)
{
var builder = new ArrayContainsExpressionBuilder <TResult>(documentQuery, arrayContainsReplacements);
var updatedSql = builder.Build();
documentQuery = _client.CreateDocumentQuery <TResult>(collectionUri, updatedSql, feedOptions).AsDocumentQuery();
}
var results = new List <TResult>();
FeedResponse <TResult> response = null;
do
{
response = await documentQuery.ExecuteNextAsync <TResult>();
results.AddRange(response.ToList());
//Stop the loop after first iteration when pageSize > 0 because we are getting one page at a time.
} while (pageSize == 0 && documentQuery.HasMoreResults);
return(new PagedQueryResultSet <TResult>
{
Results = results,
ContinuationToken = response.ResponseContinuation
});
}
public async Task <PagedQueryResultSet <BulkDataOperationDto> > GetAsync(ResultSetCriteria gridCriteria)
{
var bulkJobList = await _systemDataContext.GetDocumentsWithPagingAsync <BulkDataOperation, BulkDataOperationDto>
(q => q.Where(b => b.RelatedUserId == _requestContext.UserId &&
b.RelatedGroupId == _requestContext.GroupId).Select(b => new BulkDataOperationDto()
{
Id = b.Id,
FileName = b.FileName,
GroupId = b.RelatedGroupId,
OperationTypeCode = b.OperationTypeCode,
OperationStatusCode = b.OperationStatusCode,
BlobReference = b.BlobReference,
LogBlobReference = b.LogBlobReference,
CreatedOnUtc = b.CreatedOnUtc,
}), gridCriteria);
return(bulkJobList);
}
public async Task <PagedQueryResultSet <PermissionConfigDto> > GetAsync(ResultSetCriteria gridCriteria, PermissionSearchCriteria searchCriteria)
{
var data = await _dataContext.GetDocumentsWithPagingAsync <PermissionConfig, PermissionConfigDto>(q =>
q.Where(p => (searchCriteria.Role == "any" || p.Role == searchCriteria.Role))
.Select(p => new PermissionConfigDto
{
GroupId = p.GroupId,
Role = p.Role,
IsDeleted = p.IsDeleted,
Permissions = p.Permissions,
Id = p.Id,
UpdatedById = p.UpdatedById,
UpdatedByName = p.UpdatedByName,
UpdatedOnUtc = p.UpdatedOnUtc,
ETag = p.ETag
}), gridCriteria);
return(data);
}
public async Task <PagedQueryResultSet <AlertTemplateDto> > Get([FromQuery] ResultSetCriteria gridCriteria, [FromQuery] AlertTemplateSearchCriteria searchCriteria)
{
return(await _alertTemplateService.GetAsync(gridCriteria, searchCriteria));
}
public async Task <PagedQueryResultSet <PermissionConfigDto> > Get([FromQuery] ResultSetCriteria gridCriteria, [FromQuery] PermissionSearchCriteria searchCriteria)
{
var data = await _permissionService.GetAsync(gridCriteria, searchCriteria);
return(data);
}
public async Task <PagedQueryResultSet <LocalisationTextDto> > Get([FromQuery] ResultSetCriteria gridCriteria, [FromQuery] ConfigurationSearchCriteria searchCriteria)
{
return(await _localisationService.GetAsync(gridCriteria, searchCriteria));
}
public async Task <PagedQueryResultSet <ConfigurationSettingDto> > Get([FromQuery] ResultSetCriteria gridCriteria, [FromQuery] ConfigurationSearchCriteria searchCriteria)
{
return(await _configurationManagementService.GetAsync(gridCriteria, searchCriteria));
}
public async Task <PagedQueryResultSet <UserDto> > Get([FromQuery] ResultSetCriteria gridCriteria, [FromQuery] UserSearchCriteria searchCriteria)
{
var data = await _userService.GetAsync(gridCriteria, searchCriteria);
return(data);
}
public Task <PagedQueryResultSet <TResult> > GetDocumentsWithPagingAsync <T, TResult>(string collectionId, string partitionKey,
Func <IQueryable <T>, IQueryable <TResult> > query, ResultSetCriteria criteria = null,
Dictionary <string, object> arrayContainsReplacements = null)
{
int pageSize = criteria?.Limit ?? 0;
string continuationToken = criteria?.PageToken;
var partition = GetPartition(collectionId, partitionKey);
//In-memory provider needs to filter out the matching typed objects.
var allObjectsOfType = GetObjectsOfType <T>(partition.Values.ToList());
var skip = (continuationToken == null ? 0 : int.Parse(continuationToken));
var objQuery = allObjectsOfType.Select(obj => obj.ToObject <T>()).AsQueryable();
if (criteria != null)
{
objQuery = objQuery.OrderByFieldName(criteria.SortBy, criteria.IsAscending());
}
var results = query(objQuery).Skip(skip);
var nextSkip = 0;
if (pageSize > 0)
{
var fullCount = results.Count();
if (fullCount > pageSize)
{
nextSkip = skip + pageSize;
}
results = results.Take(pageSize);
}
return(Task.FromResult(new PagedQueryResultSet <TResult>
{
Results = results.ToList(),
ContinuationToken = nextSkip.ToString()
}));
}
public async Task <PagedQueryResultSet <LookupDto> > Get([FromQuery] ResultSetCriteria gridCriteria, [FromQuery] ConfigurationSearchCriteria searchCriteria)
{
var data = await _lookupService.GetLookupListAsync(gridCriteria, searchCriteria);
return(data);
}
public async Task <PagedQueryResultSet <BulkDataOperationDto> > Get([FromQuery] ResultSetCriteria gridCriteria)
{
return(await _bulkDataService.GetAsync(gridCriteria));
}
