/// <summary>
/// Finds a collection of Access Control Entries (ACEs) with the given values.
/// </summary>
/// <param name="objectType">The type of the shared object to be found.</param>
/// <param name="objectId">The primary key of the shared object to be found.</param>
/// <param name="cancellationToken">A token to observe while waiting for the task to complete.</param>
/// <returns>
/// A task that represents the asynchronous operation.
/// </returns>
public virtual async Task <ListResult <AccessRuleItem> > GetOwnersAsync(AccessObjectType objectType, int objectId, CancellationToken cancellationToken)
{
ThrowIfDisposed();
var rules = await Store.GetAccessRulesAsync(objectType, objectId, cancellationToken);
return(ListResult.Create(rules.Data.Where(ace => !ace.Anyone && ace.Permission == AccessPermission.IsOwner)));
}
/// <summary>
/// Creates an <see cref="T:System.Net.Http.HttpResponseMessage" /> asynchronously.
/// </summary>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
/// <returns>
/// A task that, when completed, contains the <see cref="T:System.Net.Http.HttpResponseMessage" />.
/// </returns>
public Task <HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
{
// Add HTTP headers and hypermedia links to the items here.
return(Task.FromResult(Request.CreateResponse(
StatusCode,
ListResult.Create(Rules.Data.Select(r => ModelMapper.ToRuleResultDto(r)), Rules.Total))));
}
public async Task <IHttpActionResult> PostAsync(string parentId = null, string mail = null, bool extract = false, CancellationToken cancellationToken = default(CancellationToken))
{
int userId = ApiSecurity.CurrentUserId;
var files = new List <FileItem>();
var parent = await FindFileAsync(parentId, cancellationToken);
var parenti = parent == null ? default(int?) : parent.Id;
var manager = new DriveManager(ApiSecurity.Manager, _services, ServerPaths.Map(ServerPaths.DriveFiles));
using (var content = await Request.Content.ReadAsFileStreamAsync(cancellationToken))
{
files.Add(await manager.CreateFromStreamAsync(content.FileStream, parenti, userId, content.FileName, cancellationToken));
}
return(Ok(ListResult.Create(files.Select(file => new FileStoreUploadResult
{
Name = file.Name,
Link = new Uri(Request.RequestUri, Url.Route(PublicRootName, new RouteValueDictionary
{
{ "userId", file.OwnerId },
{ "path", file.PhysicalPath }
}))
.AbsoluteUri
}))));
}
/// <summary>
/// Finds a collection of rules with the given values.
/// </summary>
/// <param name="userId">The user identifier for the item to be found.</param>
/// <param name="fields">The related fields to include in the query results.</param>
/// <param name="cancellationToken">A token to observe while waiting for the task to complete.</param>
/// <returns>
/// A task that represents the asynchronous operation.
/// </returns>
public virtual async Task <ListResult <RuleItem> > FindAllAsync(int userId, RuleField fields, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
ThrowIfDisposed();
var rules = await Rules.Where(userId).ToArrayAsync(cancellationToken);
var list = new List <RuleItem>();
foreach (var rule in rules)
{
list.Add(LoggingQueries.ToRuleItem(rule));
}
return(ListResult.Create(list));
}
/// <summary>
/// Finds a collection of events with the given values
/// </summary>
/// <param name="ownerId">Owner ID (Foreign Key)</param>
/// <param name="categoryId">Category ID (Foreign Key)</param>
/// <param name="projectId">Project ID (Foreign Key)</param>
/// <param name="actionId">Action ID (Foreign Key)</param>
/// <param name="pageId">Page ID (Foreign Key)</param>
/// <param name="contactState">Contact state flag</param>
/// <param name="dateFrom"></param>
/// <param name="dateTo"></param>
/// <param name="emails">A collection of contact emails.</param>
/// <param name="clients">A collection of Client IDs.</param>
/// <param name="pageIndex">The index of the page of results to return. Use 1 to indicate the first page.</param>
/// <param name="pageSize">The size of the page of results to return. <paramref name="pageIndex" /> is non-zero-based.</param>
/// <param name="cancellationToken">A token to observe while waiting for the task to complete.</param>
/// <returns>
/// A task that represents the asynchronous operation.
/// </returns>
public virtual async Task <ListResult <EventResult> > FindAllAsync(
int userId,
int?categoryId,
DateTime?dateFrom,
DateTime?dateTo,
ObjectType?objectType,
int?objectId,
int?contactId,
ObjectState?contactState,
int?projectId,
string customUri,
IEnumerable <string> emails,
IEnumerable <string> clients,
int pageIndex,
int pageSize,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
ThrowIfDisposed();
var listBuilder = ImmutableArray.CreateBuilder <EventResult>();
var total = 0;
var connection = Context.Database.Connection;
try
{
await connection.OpenAsync(cancellationToken);
// This solution has a considerable effect on performance avoiding EF Code First
// object materialization. Log queries are performance critical. Do not be lazy :-)
using (var command = connection.CreateCommand())
{
command.CommandText = "Logging.GetEvents";
command.CommandType = CommandType.StoredProcedure;
command.Parameters.Add(DbParameters.Value("UserId", userId));
command.Parameters.Add(DbParameters.Value("CategoryId", categoryId));
command.Parameters.Add(DbParameters.Value("DateFrom", dateFrom));
command.Parameters.Add(DbParameters.Value("DateTo", dateTo));
command.Parameters.Add(DbParameters.Value("ObjectTypeId", objectType));
command.Parameters.Add(DbParameters.Value("ObjectId", objectId));
command.Parameters.Add(DbParameters.Value("ContactId", contactId));
command.Parameters.Add(DbParameters.Value("ContactStateId", contactState));
command.Parameters.Add(DbParameters.Value("ProjectId", projectId));
command.Parameters.Add(DbParameters.Value("CustomUri", customUri));
command.Parameters.Add(DbParameters.EmailList("Emails", emails));
command.Parameters.Add(DbParameters.ClientList("Clients", clients));
command.Parameters.Add(DbParameters.Value("PageIndex", pageIndex));
command.Parameters.Add(DbParameters.Value("PageSize", pageSize));
command.Parameters.Add(DbParameters.Value("TotalItemCount", 50000));
using (var reader = await command.ExecuteReaderAsync(cancellationToken))
{
var mapper = new LoggingEventResultMapper(reader);
// Read the first record to get the total number of events before paging is applied.
// This stored procedure uses an optimized CTE query, however, a side effect of
// this solution is that the total number of records is presented in each row.
if (!reader.Read() || (total = mapper.GetTotal()) <= 0)
{
return(ListResult <EventResult> .Empty);
}
do
{
listBuilder.Add(mapper.Translate());
}while (reader.Read());
}
}
}
finally
{
connection.Close();
}
return(ListResult.Create(listBuilder.ToImmutable(), total));
}
/// <summary>
/// Maps an action to a result model object.
/// </summary>
/// <param name="portal">The action to map.</param>
/// <returns>
/// The mapped action.
/// </returns>
public static ListResult <PortalItemDto> ToPortalListDto(ListResult <PortalItem> portal)
{
return(ListResult.Create(portal.Data.Select(p => ToPortalDto(p)), portal.Total));
}
/// <summary>
/// Maps a <paramref name="media" /> to a <see cref="MediaItemDto" /> object.
/// </summary>
/// <param name="media">The model to map.</param>
/// <returns>
/// The viewModel object.
/// </returns>
public static ListResult <MediaItemDto> ToMediaListDto(ListResult <MediaItem> media, Func <string, string> linkGenerator)
{
return(ListResult.Create(media.Data.Select(m => ToMediaDto(m, linkGenerator)), media.Total));
}
/// <summary>
/// Maps an <see cref="ReferenceItem" /> to a DTO object.
/// </summary>
/// <param name="referenceList">The model to map.</param>
/// <returns>
/// The mapped model.
/// </returns>
public static ListResult <ReferenceItemDto> ToReferenceListDto(ListResult <ReferenceItem> referenceList)
{
return(ListResult.Create(referenceList.Data.Select(r => ToReferenceDto(r)), referenceList.Total));
}
