/// <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)); }