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

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

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 PwgImagesService : IPwgImagesService
    {
        public PwgImageRate RateImage(Int32 imageId, Int32 imageRate)
        {
            PwgImageRate returnValue = new PwgImageRate();

            try
            {
                PwgImageRateProxyResponse response = PwgImagesProxy.pwg_images_rate(imageId, imageRate);

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

        /// <summary>
        /// private: convert response to dto object
        /// </summary>
        /// <param name="response"></param>
        /// <param name="session"></param>
        internal static PwgImageRate ConvertProxyResponseToDTO(PwgImageRateProxyResponse response)
        {
            PwgImageRate returnValue = new PwgImageRate();
            Double aDouble = 0;
            NumberStyles style = NumberStyles.AllowDecimalPoint;
            CultureInfo en_us = CultureInfo.CreateSpecificCulture("en-US");

            returnValue.Count = response.Count;

            returnValue.Stdev = 0.0 ;
            if (Double.TryParse(response.Stdev, style, en_us, out aDouble))
            {
                returnValue.Stdev = aDouble;
            }

            returnValue.Average = 0.0;
            if (Double.TryParse(response.Average, style, en_us, out aDouble))
            {
                returnValue.Average = aDouble;
            }


            return returnValue;
        }

        /// <summary>
        /// private: convert response to dto object
        /// </summary>
        /// <param name="response"></param>
        /// <param name="session"></param>
        internal static void ConvertProxyResponseToDTO(PwgImagesProxyResponse response,
                                                      List<PwgImage> lstImage, 
                                                      ref Int32 Page, ref Int32 PerPagee, ref Int32 Count)
        {
                ConvertProxyResponseToDTO(response.ImageList, lstImage, ref Page, ref PerPagee, ref Count);
        }

        /// <summary>
        /// private: convert response to dto object
        /// </summary>
        /// <param name="response"></param>
        /// <param name="session"></param>
        internal static void ConvertProxyResponseToDTO(PwgImageListProxyResponse response,
                                                      List<PwgImage> lstImage, 
                                                      ref Int32 Page, ref Int32 PerPagee, ref Int32 Count)
        {
            Page = response.Page;
            PerPagee = response.PerPage;
            Count = response.Count;

            if (response.Images != null)
            {
                foreach (PwgImageProxyResponse respImg in response.Images)
                {
                    lstImage.Add(ConvertProxyResponseToDTO(respImg));
                }
            }
        }

        /// <summary>
        /// private: convert response to dto object
        /// </summary>
        /// <param name="response"></param>
        /// <param name="session"></param>
        internal static PwgImage ConvertProxyResponseToDTO(PwgImageProxyResponse response)
        {
            PwgImage returnValue = new PwgImage();

            try
            {
                returnValue.Counter = response.Counter;
                returnValue.Id = response.Id;
                returnValue.File = response.File;
                returnValue.Height = response.Height;
                returnValue.Width = response.Width;

                if (String.IsNullOrEmpty(response.UrlElement))
                {
                    returnValue.UrlElement = null;
                }
                else
                {
                    returnValue.UrlElement = (new UriBuilder(response.UrlElement)).Uri;
                }

                if (String.IsNullOrEmpty(response.UrlThunb))
                {
                    returnValue.UrlThunb = null;
                }
                else
                {
                    returnValue.UrlThunb = (new UriBuilder(response.UrlThunb)).Uri;
                }

                if (String.IsNullOrEmpty(response.UrlHighDef))
                {
                    returnValue.UrlHighDef = null;
                }
                else
                {
                    returnValue.UrlHighDef = (new UriBuilder(response.UrlHighDef)).Uri;
                }

                returnValue.Tags = new List<PwgTag>();
                if (response.Tags != null)
                {
                    foreach (PwgTagProxyResponse tagResp in response.Tags)
                    {
                        PwgTag aTag = PwgTagsService.ConvertProxyResponseToDTO(tagResp);
                        returnValue.Tags.Add(aTag);
                    }
                }

                returnValue.Categories = new List<PwgCategory>();
                if (response.Categories != null)
                {
                    foreach (PwgCategoryProxyResponse catResp in response.Categories)
                    {
                        PwgCategory aCat = PwgCategoriesService.ConvertProxyResponseToDTO(catResp);
                        returnValue.Categories.Add(aCat);
                    }
                }

            }
            catch (Exception ex)
            {
                throw new PwgServiceException("ConvertProxyResponseToDTO : a error is raised when converting PwgTagProxyResponse.", ex);
            }

            return returnValue;
        }
    }
}