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

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;
using Com.Piwigo.Lib.IService;

namespace Com.Piwigo.Lib.Service
{

    internal sealed class PwgCategoriesService : IPwgCategoriesService
    {
        /// <summary>
        /// Get the list of category the user is connected can access
        /// </summary>
        /// <param name="sortedByCounter"></param>
        /// <returns></returns>
        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>
        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>
        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;
        }


        /// <summary>
        /// Update category data
        /// </summary>
        /// <param name="IdCat"></param>
        /// <param name="categoryName"></param>
        /// <param name="categoryComment"></param>
        /// <returns></returns>
        public Boolean UpdateCategoryInfo(Int32 IdCat, String categoryName, String categoryComment)
        {
            Boolean returnValue = false;

            try
            {
                PwgBaseProxyReponse response = PwgCategoriesProxy.pwg_categories_setInfo(IdCat, categoryName, categoryComment);

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

        /// <summary>
        /// return the list of PwgImage in the category
        /// </summary>
        /// <param name="categoryId"></param>
        /// <param name="recursive"></param>
        /// <param name="perPage"></param>
        /// <param name="Page"></param>
        /// <param name="Order"></param>
        /// <param name="minRate"></param>
        /// <param name="maxRate"></param>
        /// <param name="minHit"></param>
        /// <param name="maxHit"></param>
        /// <param name="minDateAvailable"></param>
        /// <param name="maxDateAvailable"></param>
        /// <param name="minDateCreated"></param>
        /// <param name="maxDateCreated"></param>
        /// <param name="minRatio"></param>
        /// <param name="maxRatio"></param>
        /// <param name="withThumbnail"></param>
        /// <param name="PageReturned"></param>
        /// <param name="PerPageeReturned"></param>
        /// <param name="CountReturned"></param>
        /// <returns></returns>
        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>
        internal static 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>
        internal static 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;
        }
    }
}