lux/EgwCoreLib.Lux.Data/Services/General/IImageCacheService.cs

using EgwMultiEngineManager.Data;
using StackExchange.Redis;

namespace EgwCoreLib.Lux.Data.Services.General
{
    /// <summary>
    /// Interfaccia per ImageCacheService - caching e publishing immagini via Redis
    /// </summary>
    public interface IImageCacheService
    {
        #region Public Methods

        /// <summary>
        /// Effettua una generica chiamata ApiRest GET
        /// </summary>
        /// <param name="ApiUrl">URL Api di base</param>
        /// <param name="ApiRequest">Richiesta completa</param>
        /// <returns>Risposta RestSharp</returns>
        Task<RestSharp.RestResponse> CallRestGet(string ApiUrl, string ApiRequest);

        /// <summary>
        /// Effettua una generica chiamata ApiRest POST
        /// </summary>
        /// <param name="ApiUrl">URL Api di base</param>
        /// <param name="ApiRequest">Richiesta completa</param>
        /// <param name="rawBody">Corpo Json trasmesso con richiesta</param>
        /// <returns>Risposta RestSharp</returns>
        Task<RestSharp.RestResponse> CallRestPost(string ApiUrl, string ApiRequest, object rawBody);

        /// <summary>
        /// Elimina da cache Redis SVG per il record richiesto
        /// </summary>
        /// <param name="imgId">UID immagine</param>
        /// <param name="env">Environment</param>
        /// <returns>True se eliminato con successo</returns>
        bool DeleteSvg(string imgId, Constants.EXECENVIRONMENTS env);

        /// <summary>
        /// Elimina da cache Redis SVG per il record richiesto (async)
        /// </summary>
        /// <param name="imgId">UID immagine</param>
        /// <param name="env">Environment</param>
        /// <returns>True se eliminato con successo</returns>
        Task<bool> DeleteSvgAsync(string imgId, Constants.EXECENVIRONMENTS env);

        /// <summary>
        /// Esegue flush memoria Redis dato pattern
        /// </summary>
        /// <param name="pat2Flush">Pattern di cancellazione</param>
        /// <returns>True se eseguito con successo</returns>
        Task<bool> ExecFlushRedisPatternAsync(RedisValue pat2Flush);

        /// <summary>
        /// Genera URL immagine dato
        /// </summary>
        /// <param name="baseUrl">Base url IMG server</param>
        /// <param name="isLive">Live = in fase di calcolo (cache REDIS)</param>
        /// <param name="imgUID">UID elemento/immagine</param>
        /// <param name="envir">Environment item (opzionale)</param>
        /// <returns>URL immagine completa</returns>
        string ImageUrl(string baseUrl, bool isLive, string imgUID, Constants.EXECENVIRONMENTS envir = Constants.EXECENVIRONMENTS.WINDOW);

        /// <summary>
        /// Rilettura risposta da debug in formato string
        /// </summary>
        /// <param name="uID">UID record</param>
        /// <param name="env">Environment</param>
        /// <returns>Contenuto da debug</returns>
        Task<string> LoadDebug(string uID, Constants.EXECENVIRONMENTS env);

        /// <summary>
        /// Recupera immagine PNG x id item richiesto
        /// </summary>
        /// <param name="imgUid">UID item</param>
        /// <param name="envir">Environment item (opzionale)</param>
        /// <returns>Contenuto PNG come stringa base64</returns>
        string LoadPng(string imgUid, Constants.EXECENVIRONMENTS envir = Constants.EXECENVIRONMENTS.WINDOW);

        /// <summary>
        /// Recupera immagine PNG x id item richiesto (async)
        /// </summary>
        /// <param name="imgUid">UID item</param>
        /// <param name="envir">Environment item (opzionale)</param>
        /// <returns>Contenuto PNG come stringa base64</returns>
        Task<string> LoadPngAsync(string imgUid, Constants.EXECENVIRONMENTS envir = Constants.EXECENVIRONMENTS.WINDOW);

        /// <summary>
        /// Recupera immagine SVG x id item richiesto
        /// </summary>
        /// <param name="imgUid">UID item</param>
        /// <param name="envir">Environment item (opzionale)</param>
        /// <returns>Contenuto SVG come stringa XML</returns>
        string LoadSvg(string imgUid, Constants.EXECENVIRONMENTS envir = Constants.EXECENVIRONMENTS.WINDOW);

        /// <summary>
        /// Recupera immagine SVG x id item richiesto (async)
        /// </summary>
        /// <param name="imgId">UID item</param>
        /// <param name="envir">Environment item (opzionale)</param>
        /// <returns>Contenuto SVG come stringa XML</returns>
        Task<string> LoadSvgAsync(string imgId, Constants.EXECENVIRONMENTS envir = Constants.EXECENVIRONMENTS.WINDOW);

        /// <summary>
        /// Salva e invia su channel richiesto un update x UID
        /// È atteso un refresh per chi sottoscrive il canale
        /// </summary>
        /// <param name="uid">UID record</param>
        /// <param name="env">Environment</param>
        /// <returns>True se pubblicato con successo</returns>
        Task<bool> PublishUpdateAsync(string uid, Constants.EXECENVIRONMENTS env);

        /// <summary>
        /// Salva e invia su channel BOM redis il doc richiesto
        /// </summary>
        /// <param name="uid">UID record</param>
        /// <param name="env">Environment</param>
        /// <param name="bomContent">Contenuto BOM serializzato</param>
        /// <returns>True se salvato e pubblicato con successo</returns>
        Task<bool> SaveBomAsync(string uid, Constants.EXECENVIRONMENTS env, string bomContent);

        /// <summary>
        /// Salvataggio risposta x debug in formato RAW
        /// </summary>
        /// <param name="uID">UID record</param>
        /// <param name="env">Environment</param>
        /// <param name="rawData">Dati raw</param>
        /// <returns>True se salvato con successo</returns>
        Task<bool> SaveDebug(string uID, Constants.EXECENVIRONMENTS env, string rawData);

        /// <summary>
        /// Salva e invia su channel dedicato HML l'elenco degli HardwareModel (conf preferiti) gestiti
        /// </summary>
        /// <param name="uid">UID record</param>
        /// <param name="env">Environment</param>
        /// <param name="rawData">Dati raw</param>
        /// <returns>True se salvato e pubblicato con successo</returns>
        Task<bool> SaveHmlAsync(string uid, Constants.EXECENVIRONMENTS env, string rawData);

        /// <summary>
        /// Salva e invia su channel l'XML delle HW options per il doc richiesto
        /// </summary>
        /// <param name="uid">UID record</param>
        /// <param name="env">Environment</param>
        /// <param name="xmlContent">Contenuto XML</param>
        /// <returns>True se salvato e pubblicato con successo</returns>
        Task<bool> SaveHwOptAsync(string uid, Constants.EXECENVIRONMENTS env, string xmlContent);

        /// <summary>
        /// Salva immagine PNG su Redis e pubblica notifica sul channel
        /// </summary>
        /// <param name="imgId">UID immagine</param>
        /// <param name="env">Environment</param>
        /// <param name="pngContent">Contenuto PNG come stringa base64</param>
        /// <returns>True se salvato e pubblicato con successo</returns>
        bool SavePng(string imgId, Constants.EXECENVIRONMENTS env, string pngContent);

        /// <summary>
        /// Salva immagine PNG su Redis e pubblica notifica sul channel (async)
        /// </summary>
        /// <param name="imgId">UID immagine</param>
        /// <param name="env">Environment</param>
        /// <param name="pngContent">Contenuto PNG come stringa base64</param>
        /// <returns>True se salvato e pubblicato con successo</returns>
        Task<bool> SavePngAsync(string imgId, Constants.EXECENVIRONMENTS env, string pngContent);

        /// <summary>
        /// Salva e invia su channel risultato balance per POR (UID.GroupId.Type) richiesto
        /// </summary>
        /// <param name="uid">UID record</param>
        /// <param name="env">Environment</param>
        /// <param name="estimContent">Contenuto stima serializzato</param>
        /// <returns>True se salvato e pubblicato con successo</returns>
        Task<bool> SaveProdBalanceAsync(string uid, Constants.EXECENVIRONMENTS env, string estimContent);

        /// <summary>
        /// Salva e invia su channel risultato stima per POR (UID.GroupId) richiesto
        /// </summary>
        /// <param name="uid">UID record</param>
        /// <param name="env">Environment</param>
        /// <param name="estimContent">Contenuto stima serializzato</param>
        /// <returns>True se salvato e pubblicato con successo</returns>
        Task<bool> SaveProdEstimateAsync(string uid, Constants.EXECENVIRONMENTS env, string estimContent);

        /// <summary>
        /// Salva e invia su channel areaProfElem ricevuta
        /// </summary>
        /// <param name="uID">UID record</param>
        /// <param name="env">Environment</param>
        /// <param name="areaProfElem">Contenuto areaProfElem serializzato</param>
        /// <returns>True se salvato e pubblicato con successo</returns>
        Task<bool> SaveProfileElemAsync(string uID, Constants.EXECENVIRONMENTS env, string areaProfElem);

        /// <summary>
        /// Salva e invia su channel profile list gestiti
        /// </summary>
        /// <param name="uid">UID record</param>
        /// <param name="env">Environment</param>
        /// <param name="rawData">Dati raw</param>
        /// <returns>True se salvato e pubblicato con successo</returns>
        Task<bool> SaveProfileListAsync(string uid, Constants.EXECENVIRONMENTS env, string rawData);

        /// <summary>
        /// Salva e invia su channel info Threshold e Data x profili gestiti
        /// </summary>
        /// <param name="uid">UID record</param>
        /// <param name="env">Environment</param>
        /// <param name="rawDataThresh">Info Threshold</param>
        /// <param name="rawProfData">Info generiche</param>
        /// <returns>True se salvato e pubblicato con successo</returns>
        Task<bool> SaveProfileThreshAsync(string uid, Constants.EXECENVIRONMENTS env, string rawDataThresh, string rawProfData);

        /// <summary>
        /// Salva e invia su channel shape per item (UID.GroupId) richiesto
        /// </summary>
        /// <param name="uid">UID record</param>
        /// <param name="env">Environment</param>
        /// <param name="shapeContent">Contenuto shape serializzato</param>
        /// <returns>True se salvato e pubblicato con successo</returns>
        Task<bool> SaveShapeAsync(string uid, Constants.EXECENVIRONMENTS env, string shapeContent);

        /// <summary>
        /// Salva immagine SVG su Redis e pubblica notifica sul channel
        /// </summary>
        /// <param name="imgId">UID immagine</param>
        /// <param name="env">Environment</param>
        /// <param name="svgContent">Contenuto SVG come stringa XML</param>
        /// <returns>True se salvato e pubblicato con successo</returns>
        bool SaveSvg(string imgId, Constants.EXECENVIRONMENTS env, string svgContent);

        /// <summary>
        /// Salva immagine SVG su Redis e pubblica notifica sul channel (async)
        /// </summary>
        /// <param name="imgId">UID immagine</param>
        /// <param name="env">Environment</param>
        /// <param name="svgContent">Contenuto SVG come stringa XML</param>
        /// <returns>True se salvato e pubblicato con successo</returns>
        Task<bool> SaveSvgAsync(string imgId, Constants.EXECENVIRONMENTS env, string svgContent);

        #endregion Public Methods
    }
}