source: extensions/PiwigoLib/PiwigoLib/Service/PwgCategoriesService.cs @ 3835

using System;
using System.Collections.Generic;
using System.Text;

using Com.Piwigo.Lib.DTO;
using Com.Piwigo.Lib.Proxy;
using Com.Piwigo.Lib.Proxy.Response;
using Com.Piwigo.Lib.DTO.Helper;

namespace Com.Piwigo.Lib.Service
{

    static public class PwgCategoriesService
    {
        /// <summary>
        /// Get the list of category the user is connected can access
        /// </summary>
        /// <param name="sortedByCounter"></param>
        /// <returns></returns>
        static public List<PwgCategory> GetListOfCategory(Int32? CatgeroryId, Boolean? Recursive, Boolean? PublicOnly)
        {
            List<PwgCategory> returnValue = new List<PwgCategory>();

            try
            {
                PwgCategoriesProxyResponse response = PwgCategoriesProxy.pwg_categories_getList(CatgeroryId, Recursive, PublicOnly);

                if (response.Retour != PwgBaseProxyReponseRetourEnum.Ok)
                {
                    if (response.Erreur != null)
                    {
                        throw new PwgServiceException("GetListOfCategory, the server has return the error.",
                            response.Erreur.Code,
                            response.Erreur.Message);
                    }
                    else
                    {
                        throw new PwgServiceException("GetListOfCategory : a error occurs during server process.");
                    }
                }
                else
                {
                    returnValue = ConvertProxyResponseToDTO(response);
                }
            }
            catch (PwgProxyException ex)
            {
                throw new PwgServiceException("GetListOfCategory : a error is raised by proxy.", ex);
            }
            return returnValue;
        }

        /// <summary>
        /// Get List of all Category, must be logged as admin
        /// </summary>
        /// <returns></returns>
        static public List<PwgCategory> GetAdminListOfCategory()
        {
            List<PwgCategory> returnValue = new List<PwgCategory>();

            try
            {
                PwgCategoriesProxyResponse response = PwgCategoriesProxy.pwg_categories_getAdminList();

                if (response.Retour != PwgBaseProxyReponseRetourEnum.Ok)
                {
                    if (response.Erreur != null)
                    {
                        throw new PwgServiceException("GetAdminListOfCategory, the server has return the error.",
                            response.Erreur.Code,
                            response.Erreur.Message);
                    }
                    else
                    {
                        throw new PwgServiceException("GetAdminListOfCategory : a error occurs during server process.");
                    }
                }
                else
                {
                    returnValue = ConvertProxyResponseToDTO(response);
                }
            }
            catch (PwgProxyException ex)
            {
                throw new PwgServiceException("GetAdminListOfCategory : a error is raised by proxy.", ex);
            }
            return returnValue;
        }

        /// <summary>
        /// Add a category to the gallery
        /// </summary>
        /// <param name="categoryName"></param>
        /// <param name="upperCatId"></param>
        /// <param name="newId"> Id used by the new category</param>
        /// <param name="messageInfo">Message returned by the server</param>
        /// <returns>false, if a error occurs</returns>
        static public Boolean AddCategory(String categoryName, Int32? upperCatId, ref Int32 newId, ref String messageInfo)
        {
            Boolean returnValue = false;

            try
            {
                PwgAddRequestProxyResponse response = PwgCategoriesProxy.pwg_categories_add(categoryName, upperCatId);

                if (response.Retour != PwgBaseProxyReponseRetourEnum.Ok)
                {
                    if (response.Erreur != null)
                    {
                        throw new PwgServiceException("AddCategory, the server has return the error.",
                            response.Erreur.Code,
                            response.Erreur.Message);
                    }
                    else
                    {
                        throw new PwgServiceException("AddCategory : a error occurs during server process.");
                    }
                }
                else
                {
                    returnValue = true;
                    newId = response.NewId;
                    messageInfo = response.Message;
                }
            }
            catch (PwgProxyException ex)
            {
                throw new PwgServiceException("AddCategory : a error is raised by proxy.", ex);
            }
            return returnValue;
        }

        static public List<PwgImage> GetListOfImagesFormCategory(Int32 categoryId,
                                                    Boolean? recursive,
                                                    Int32? perPage,
                                                    Int32? Page,
                                                    Int32? Order,
                                                    Int32? minRate,
                                                    Int32? maxRate,
                                                    Int32? minHit,
                                                    Int32? maxHit,
                                                    DateTime? minDateAvailable,
                                                    DateTime? maxDateAvailable,
                                                    DateTime? minDateCreated,
                                                    DateTime? maxDateCreated,
                                                    Int32? minRatio,
                                                    Int32? maxRatio,
                                                    Boolean? withThumbnail,
                                                    ref Int32 PageReturned,
                                                    ref Int32 PerPageeReturned,
                                                    ref Int32 CountReturned)
        {
            List<PwgImage> returnValue = new List<PwgImage>();

            try
            {
                PwgImagesProxyResponse response = PwgCategoriesProxy.pwg_categories_getImages(categoryId,
                                                            recursive,
                                                            perPage,
                                                            Page,
                                                            Order,
                                                            minRate,
                                                            maxRate,
                                                            minHit,
                                                            maxHit,
                                                            minDateAvailable,
                                                            maxDateAvailable,
                                                            minDateCreated,
                                                            maxDateCreated,
                                                            minRatio,
                                                            maxRatio,
                                                            withThumbnail);

                if (response.Retour != PwgBaseProxyReponseRetourEnum.Ok)
                {
                    if (response.Erreur != null)
                    {
                        throw new PwgServiceException("GetListOfImagesFormCategory, the server has return the error.",
                            response.Erreur.Code,
                            response.Erreur.Message);
                    }
                    else
                    {
                        throw new PwgServiceException("GetListOfImagesFormCategory : a error occurs during server process.");
                    }
                }
                else
                {
                    PwgImagesService.ConvertProxyResponseToDTO(response, returnValue,
                                                            ref PageReturned,
                                                            ref PerPageeReturned,
                                                            ref CountReturned);
                }
            }
            catch (PwgProxyException ex)
            {
                throw new PwgServiceException("GetListOfImagesFormCategory : a error is raised by proxy.", ex);
            }
            return returnValue;
        }

        /// <summary>
        /// convert response to dto object
        /// </summary>
        /// <param name="response"></param>
        /// <param name="session"></param>
        static public List<PwgCategory> ConvertProxyResponseToDTO(PwgCategoriesProxyResponse response)
        {
            List<PwgCategory> returnValue = new List<PwgCategory>();

            foreach (PwgCategoryProxyResponse respCat in response.Categories)
            {
                returnValue.Add(ConvertProxyResponseToDTO(respCat));
            }

            return returnValue;
        }


        /// <summary>
        /// convert response to dto object
        /// </summary>
        /// <param name="response"></param>
        /// <param name="session"></param>
        static public PwgCategory ConvertProxyResponseToDTO(PwgCategoryProxyResponse response)
        {
            PwgCategory returnValue = new PwgCategory();

            try
            {
                returnValue.Id = response.Id;
                returnValue.Name = response.Name;

                returnValue.DeepImagesCount = response.DeepImagesCount;
                returnValue.ImagesCount = response.ImagesCount;
                returnValue.SubCategoriesCount = response.SubCategoriesCount;

                returnValue.UpperCategoriesId = new List<int>();
                if (response.UpperCategoryId != null)
                {
                    foreach (String stringId in response.UpperCategoryId.Split(','))
                    {
                        returnValue.UpperCategoriesId.Add(Int32.Parse(stringId));
                    }
                }

                if (response.LastDate != null)
                {
                    DateTime tryDate;
                    if (DateTime.TryParse(response.LastDate, out tryDate))
                    {
                        returnValue.LastDate = tryDate;
                    }
                }

                if (String.IsNullOrEmpty(response.Url))
                {
                    returnValue.Url = null;
                }
                else
                {
                    returnValue.Url = (new UriBuilder(response.Url)).Uri;
                }
            }
            catch (Exception ex)
            {
                throw new PwgServiceException("ConvertProxyResponseToDTO : a error is raised when converting PwgTagProxyResponse.", ex);
            }

            return returnValue;
        }
    }
}