Beispiel #1
0
        public Task <GetFoldersResponse> GetFolders(string rootFolderId)
        {
            GetFoldersRequest         request = _requestFactorty.CreateGetFoldersRequest(_host, _token, rootFolderId);
            Task <GetFoldersResponse> folders = HttpProcessor.GetFolders(request);

            return(folders);
        }
Beispiel #2
0
        public static async Task <GetFoldersResponse> GetFolders(GetFoldersRequest request)
        {
            System.Collections.Specialized.NameValueCollection qs = HttpUtility.ParseQueryString(string.Empty);
            qs.Add("access_token", request.Token);
            qs.Add("root", JsonConvert.SerializeObject(request.Root));
            if (request.Offset > 0)
            {
                qs.Add("offset", request.Offset.ToString());
            }
            if (request.MaxDepth > 0)
            {
                qs.Add("maxDepth", request.MaxDepth.ToString());
            }
            if (request.MaxReturn > 0)
            {
                qs.Add("maxReturn", request.MaxReturn.ToString());
            }
            if (request.WorkSpace != null)
            {
                qs.Add("workSpace", request.WorkSpace);
            }
            string              url      = request.Host + "/rest/asset/v1/folders.json?" + qs.ToString();
            HttpClient          client   = new HttpClient();
            HttpResponseMessage response = await client.GetAsync(url);

            response.EnsureSuccessStatusCode();

            string content = await response.Content.ReadAsStringAsync();

            return(JsonConvert.DeserializeObject <GetFoldersResponse>(content));
        }
 public IHttpActionResult GetAllRootFolders([FromBody] GetFoldersRequest request)
 {
     if (request == null)
     {
         request = new GetFoldersRequest();
     }
     return(Ok(new GetFoldersResponse()
     {
         Data = _folderManipulation.GetAllRootFolders(request.Paging),
         Success = Common.Enumerations.ResponseStatus.Succeeded
     }));
 }
Beispiel #4
0
        public GetFoldersRequest CreateGetFoldersRequest(string host, string token, string rootFolderId)
        {
            Dictionary <string, dynamic> root = new Dictionary <string, dynamic>();

            root.Add("id", rootFolderId);
            root.Add("type", "folder");

            GetFoldersRequest getFoldersRequest = new GetFoldersRequest()
            {
                Host      = host,
                Token     = token,
                Offset    = 0,
                MaxDepth  = 10,
                MaxReturn = 200,
                Root      = root
                            //WorkSpace = "GL LS - Global Life Sciences"
            };

            return(getFoldersRequest);
        }
        public void Should_Return_Folders_List_Successfully()
        {
            RunActionInTransaction(session =>
            {
                CreateFakeMedias(session);
                var repository = CreateRepository(session);

                using (var service = new MediaManagerApiContext(Container.BeginLifetimeScope(), repository))
                {
                    var request = new GetFoldersRequest(MediaType.Image, itemsCount: 2);
                    var imageFolders = service.GetFolders(request);
                    Assert.IsNotNull(imageFolders);
                    Assert.LessOrEqual(imageFolders.Items.Count, 2);

                    request = new GetFoldersRequest(MediaType.File, itemsCount: 2);
                    var fileFolders = service.GetFolders(request);
                    Assert.IsNotNull(fileFolders);
                    Assert.LessOrEqual(fileFolders.Items.Count, 2);
                }
            });
        }
        public void Should_Return_Folders_List_Successfully()
        {
            RunActionInTransaction(session =>
            {
                CreateFakeMedias(session);
                var repository = CreateRepository(session);

                using (var service = new MediaManagerApiContext(Container.BeginLifetimeScope(), repository))
                {
                    var request      = new GetFoldersRequest(MediaType.Image, itemsCount: 2);
                    var imageFolders = service.GetFolders(request);
                    Assert.IsNotNull(imageFolders);
                    Assert.LessOrEqual(imageFolders.Items.Count, 2);

                    request         = new GetFoldersRequest(MediaType.File, itemsCount: 2);
                    var fileFolders = service.GetFolders(request);
                    Assert.IsNotNull(fileFolders);
                    Assert.LessOrEqual(fileFolders.Items.Count, 2);
                }
            });
        }
Beispiel #7
0
        /// <summary>
        /// Gets folder list.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns>
        ///   <c>GetFoldersResponse</c> with folder list.
        /// </returns>
        public GetFoldersResponse Get(GetFoldersRequest request)
        {
            request.Data.SetDefaultOrder("Title");

            var query = this.repository
                        .AsQueryable <Media>()
                        .Where(m => m.Original == null && m.ContentType == Module.MediaManager.Models.MediaContentType.Folder)
                        .Where(f => f is MediaFolder);

            query = request.Data.ParentFolderId == null
                ? query.Where(m => m.Folder == null)
                : query.Where(m => m.Folder.Id == request.Data.ParentFolderId && !m.Folder.IsDeleted);

            if (!request.Data.IncludeArchived)
            {
                query = query.Where(m => !m.IsArchived);
            }

            var listResponse = query.Select(media =>
                                            new FolderModel
            {
                Id             = media.Id,
                Version        = media.Version,
                CreatedBy      = media.CreatedByUser,
                CreatedOn      = media.CreatedOn,
                LastModifiedBy = media.ModifiedByUser,
                LastModifiedOn = media.ModifiedOn,

                Title      = media.Title,
                Type       = (MediaType)((int)media.Type),
                IsArchived = media.IsArchived
            })
                               .ToDataListResponse(request);

            return(new GetFoldersResponse
            {
                Data = listResponse
            });
        }
Beispiel #8
0
        /// <summary>
        /// Gets folder list.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns>
        ///   <c>GetFoldersResponse</c> with folder list.
        /// </returns>
        public GetFoldersResponse Get(GetFoldersRequest request)
        {
            request.Data.SetDefaultOrder("Title");

            var query = this.repository
                .AsQueryable<Media>()
                .Where(m => m.Original == null && m.ContentType == Module.MediaManager.Models.MediaContentType.Folder)
                .Where(f => f is MediaFolder);

            query = request.Data.ParentFolderId == null
                ? query.Where(m => m.Folder == null)
                : query.Where(m => m.Folder.Id == request.Data.ParentFolderId && !m.Folder.IsDeleted);

            if (!request.Data.IncludeArchived)
            {
                query = query.Where(m => !m.IsArchived);
            }

            var listResponse = query.Select(media =>
                    new FolderModel
                        {
                            Id = media.Id,
                            Version = media.Version,
                            CreatedBy = media.CreatedByUser,
                            CreatedOn = media.CreatedOn,
                            LastModifiedBy = media.ModifiedByUser,
                            LastModifiedOn = media.ModifiedOn,

                            Title = media.Title,
                            Type = (MediaType)((int)media.Type),
                            IsArchived = media.IsArchived
                        })
                        .ToDataListResponse(request);

            return new GetFoldersResponse
                       {
                           Data = listResponse
                       };
        }
        /// <summary>
        /// Gets the list of media folder entities.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns>
        /// The list of folder entities
        /// </returns>
        /// <exception cref="CmsApiException"></exception>
        public DataListResponse <MediaFolder> GetFolders(GetFoldersRequest request)
        {
            try
            {
                var query = Repository
                            .AsQueryable <MediaFolder>()
                            .Where(f => f.Type == request.MediaType)
                            .ApplyFilters(request);

                var totalCount = query.ToRowCountFutureValue(request);
                query = query
                        .AddOrderAndPaging(request)
                        .Fetch(m => m.Folder);

                return(query.ToDataListResponse(totalCount));
            }
            catch (Exception inner)
            {
                var message = string.Format("Failed to get folders list for media type={0}.", request.MediaType);
                Logger.Error(message, inner);
                throw new CmsApiException(message, inner);
            }
        }
        /// <summary>
        /// Gets the list of media folder entities.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns>
        /// The list of folder entities
        /// </returns>
        /// <exception cref="CmsApiException"></exception>
        public DataListResponse<MediaFolder> GetFolders(GetFoldersRequest request)
        {
            try
            {
                var query = Repository
                    .AsQueryable<MediaFolder>()
                    .Where(f => f.Type == request.MediaType)
                    .ApplyFilters(request);

                var totalCount = query.ToRowCountFutureValue(request);
                query = query
                    .AddOrderAndPaging(request)
                    .Fetch(m => m.Folder);

                return query.ToDataListResponse(totalCount);

            }
            catch (Exception inner)
            {
                var message = string.Format("Failed to get folders list for media type={0}.", request.MediaType);
                Logger.Error(message, inner);
                throw new CmsApiException(message, inner);
            }
        }