Histórico da Página

using RM.Glb.SGDP.SmartLink.Service.Domain;
using RM.Glb.SGDP.SmartLink.Service.Domain.Interfaces;
using RM.Lib.Log;
using RM.Lib.SmartLink.Domain;
using RM.Lib.SmartLink.Domain.Interfaces;
using System;
using System.Collections.Generic;
using System.Linq;

namespace RM.Glb.SGDP.SmartLink.Service
{
  public class GlbSGDPPublisherMessageService : IGlbSGDPPublisherMessageService
  {
    private readonly IGlbSGDPResolverService _sgdpResolverService;
    private readonly IRMSSmartLinkPublisherService _smartLinkPublisherService;
    private readonly IRMSLogger _logService;
   private const string ctSGDPDataResponseEndPoint = "/api/v1/link/send/SGDPDataResponse/SGDP";

    private const string ctSGDPUpdateTenantMetadata = "SGDPUpdateTenantMetadata";


    private const string ctSGDPDataCommand = "SGDPDataCommand";
    private const string ctSGDPResponseDataCommand = "SGDPResponseDataCommand";

    private const string ctSGDPMaskResponseEndPoint = "/api/v1/link/send/SGDPMaskResponse/SGDP";
    private const string ctSGDPMaskCommand = "SGDPMaskCommand";
    private const string ctSGDPResponseMaskCommand = "SGDPResponseMaskCommand";

    private const string ctSGDPLogResponseEndPoint = "/api/v1/link/send/SGDPLogsResponse/SGDP";
    private const string ctSGDPLogsCommand = "SGDPLogsCommand";
    private const string ctSGDPResponseLogCommandctSGDPUpdateTenantMetadataEndPoint = "SGDPResponseLogsCommand/api/v1/link/send/SGDPUpdateTenantMetadata/SGDP";

    private const string ctSmartLinkSetupCommandctSGDPDataResponseEndPoint = "setup/api/v1/link/send/SGDPDataResponse/SGDP";

    private const string ctSmartLinkUnSetupCommandctSGDPUpdateTenantMetadata = "unSetupSGDPUpdateTenantMetadata";


    public GlbSGDPPublisherMessageService(IRMSSmartLinkPublisherService smartLinkPublisherService,
      IGlbSGDPResolverService sgdpResolverService,
      IRMSLogger logService)
    {
   private const string _smartLinkPublisherServicectSGDPDataCommand = smartLinkPublisherService"SGDPDataCommand";
    private const _sgdpResolverServicestring ctSGDPResponseDataCommand = sgdpResolverService"SGDPDataResponse";

    private const string _logServicectSGDPMaskResponseEndPoint = logService"/api/v1/link/send/SGDPMaskResponse/SGDP";
    }

private const string ctSGDPMaskCommand /// <summary>= "SGDPMaskCommand";
    ///private Adicionaconst uma mensagem de reposta para o comando "SGDPResponseDataCommand".string ctSGDPResponseMaskCommand = "SGDPMaskResponse";

    /// </summary>
    /// <param name="parms"></param>private const string ctSGDPLogResponseEndPoint = "/api/v1/link/send/SGDPLogsResponse/SGDP";
    publicprivate voidconst AddResponseDataCommand(AddResponseDataCommandParms parms)
    {string ctSGDPLogsCommand = "SGDPLogsCommand";
    private const SmartLinkPublisherAddMessageParamsstring parPublisherctSGDPResponseLogCommand = new SmartLinkPublisherAddMessageParams
      {"SGDPLogsResponse";

    private const string  CommandctSmartLinkSetupCommand = ctSGDPResponseDataCommand,"setup";
    private const string ctSmartLinkUnSetupCommand CorrelatedId = parms.CorrelatedId"unSetup";


    public  };
GlbSGDPPublisherMessageService(IRMSSmartLinkPublisherService smartLinkPublisherService,
      IGlbSGDPResolverService ;sgdpResolverService,
      IRMSLogger logService)
  parPublisher.Data = parms.Message;{
      parPublisher.RouterMessage_smartLinkPublisherService = ctSGDPDataResponseEndPointsmartLinkPublisherService;
      _logService.NotifyLogInfo(Properties.Resources.sconTotvsAppSGDPResponseDataCommandGravadoNaFila)sgdpResolverService = sgdpResolverService;
      _smartLinkPublisherService.AddMessage(parPublisher)logService = logService;
    }

    /// <summary>
    /// Adiciona uma mensagem de reposta para o comando "SGDPResponseMaskCommandSGDPResponseDataCommand".
    /// </summary>
    /// <param name="parms"></param>
    public void AddResponseMaskCommandAddResponseDataCommand(AddResponseMaskCommandParmsAddResponseDataCommandParms parms)
    {
      SmartLinkPublisherAddMessageParams parPublisher = new SmartLinkPublisherAddMessageParams
      {
        Command = ctSGDPResponseMaskCommandctSGDPResponseDataCommand,
        CorrelatedId = parms.CorrelatedId,
        Data = parms.Message,
        RouterMessage = ctSGDPMaskResponseEndPointctSGDPDataResponseEndPoint
      };

      _logService.NotifyLogInfo(Properties.Resources.sconTotvsAppSGDPResponseMaskCommandGravadoNaFilasconTotvsAppSGDPResponseDataCommandGravadoNaFila);
      _smartLinkPublisherService.AddMessage(parPublisher);
    }

    /// <summary>
    /// Adiciona uma mensagem de reposta para o comando "SGDPResponseLogCommandSGDPResponseMaskCommand".
    /// </summary>
    /// <param name="parms">Parms<></param>
    public void AddResponseLogCommandAddResponseMaskCommand(AddResponseLogCommandParmsAddResponseMaskCommandParms parms)
    {
      SmartLinkPublisherAddMessageParams parPublisher = new SmartLinkPublisherAddMessageParams
      {
        Command = ctSGDPResponseLogCommandctSGDPResponseMaskCommand,
        CorrelatedId = parms.CorrelatedId,
        Data = parms.Message,
        RouterMessage = ctSGDPLogResponseEndPointctSGDPMaskResponseEndPoint
      };
      _logService.NotifyLogInfo(Properties.Resources.sconTotvsAppSGDPResponseLogCommandGravadoNaFilasconTotvsAppSGDPResponseMaskCommandGravadoNaFila);
      _smartLinkPublisherService.AddMessage(parPublisher);
    }

    /// <summary>
    /// Adiciona uma mensagem parade envioreposta depara umo comando de sgldpdateapplicationmetada"SGDPResponseLogCommand".
    /// </summary>
    public/// void AddMessageUpdateTenantMetadata(AddMessageUpdateTenantMetadataParms parms)
    {<param name="parms">Parms</param>
    public void if (CanAddTenantMetadataMessage()AddResponseLogCommand(AddResponseLogCommandParms parms)
      {
      SmartLinkPublisherAddMessageParams parPublisher try
= new SmartLinkPublisherAddMessageParams
      {
        Command  List<string> jsons = GetUpdateTenandMetadata(parms.TenantId);ctSGDPResponseLogCommand,
        CorrelatedId  foreach (string json in jsons)= parms.CorrelatedId,
        Data = {parms.Message,
        RouterMessage    SmartLinkPublisherAddMessageParams smartLinkParms = new SmartLinkPublisherAddMessageParams();ctSGDPLogResponseEndPoint
      };
      smartLinkParms.Command = ctSGDPUpdateTenantMetadata_logService.NotifyLogInfo(Properties.Resources.sconTotvsAppSGDPResponseLogCommandGravadoNaFila);
      _smartLinkPublisherService.AddMessage(parPublisher);
    }

  smartLinkParms.CorrelatedId = "";  /// <summary>
    /// Adiciona uma mensagem para envio de um smartLinkParms.Datacomando =de json;sgldpdateapplicationmetada.
    /// </summary>
    public   smartLinkParms.RouterMessage = ctSGDPUpdateTenantMetadataEndPoint;void AddMessageUpdateTenantMetadata(AddMessageUpdateTenantMetadataParms parms)
    {
      try
  _logService.NotifyLogInfo(Properties.Resources.sconTotvsAppSGDPTenantMetadaGravadoNaFila);
    {
        _smartLinkPublisherService.AddMessage(smartLinkParms);if(string.IsNullOrEmpty(parms.TenantId))
        {
  }
        }_logService.NotifyLogWarning(Properties.Resources.sSGDPTenantMetadataInvalidSGDPUpdateTenantMetadata);
        catch (Exception ex)return;
        {}
        List<string>  _logService.NotifyLogWarning(ex, Properties.Resources.sconTotvsAppErroAoEnviarSGDPUpdateTenantMetadatajsons = GetUpdateTenandMetadata(parms.TenantId);
        }
foreach (string json in jsons)
  }
    }

  {
  private bool CanAddTenantMetadataMessage()
    {
  SmartLinkPublisherAddMessageParams smartLinkParms = new //SeSmartLinkPublisherAddMessageParams
 existir alguma mensagem de sgdp para ser processada, então não{
 envia atualizaçaõ de medatdos pois esse processo é caro.
   Command = ctSGDPUpdateTenantMetadata,
 var pendingMessages = _smartLinkPublisherService.GetPendingMessages();
        List<SmartLinkMessageDataModel> messageUpstreamCorrelatedId = pendingMessages?.Messages?.Where("",
        y   => y.TypeEventData == ctSGDPUpdateTenantMetadata || json,
            RouterMessage y.TypeEvent == ctSGDPDataCommand ||ctSGDPUpdateTenantMetadataEndPoint
          };
   y.TypeEvent == ctSGDPMaskCommand ||
    _logService.NotifyLogInfo(Properties.Resources.sconTotvsAppSGDPTenantMetadaGravadoNaFila);
         y.TypeEvent == ctSGDPResponseDataCommand || _smartLinkPublisherService.AddMessage(smartLinkParms);
        }
     y.TypeEvent == ctSGDPResponseMaskCommand).ToList(); }
      ifcatch (messageUpstream?.Count > 0)//Se existir alguma não inclua na fila...Exception ex)
      {
        return false_logService.NotifyLogWarning(ex, Properties.Resources.sconTotvsAppErroAoEnviarSGDPUpdateTenantMetadata);
      return true;}
    }

    private List<string> GetUpdateTenandMetadata(string tenantId)
    {
      return _sgdpResolverService.GetSGDPTenantMetadata(
        new MetadataTenantParms() { TenantId = tenantId }
        )?.JsonsResult;
    }

    public void AddMessageUnSetup()
    {
      var pendingMessages = _smartLinkPublisherService.GetPendingMessages();
      List<SmartLinkMessageDataModel>var messagesSGDP =
        pendingMessages?.Messages?.Where(y => y.TypeEvent.ToUpper() == ctSGDPUpdateTenantMetadata.ToUpper() &&
                                              y.TypeEvent.ToUpper() == ctSGDPDataCommand.ToUpper() &&
                                              y.TypeEvent.ToUpper() == ctSGDPMaskCommand.ToUpper() &&
                                              y.TypeEvent.ToUpper() == ctSGDPLogsCommand.ToUpper() &&
                                              y.TypeEvent.ToUpper() == ctSGDPResponseDataCommand.ToUpper() &&
                                              y.TypeEvent.ToUpper() == ctSGDPResponseMaskCommand.ToUpper()).ToList();

      if (messagesSGDP != null)
      {
        foreach (SmartLinkMessageDataModelSmartLinkMessageEntity model in messagesSGDP)
        {
          _smartLinkPublisherService.RemoveMessageById(model.Id);
        }
      }

      SmartLinkPublisherAddMessageParams parms = new SmartLinkPublisherAddMessageParams
      {
        Command = ctSmartLinkUnSetupCommand,
        CorrelatedId = "",
        Data = _sgdpResolverService.GetSGDPSetup().JsonResult
      };
      _logService.NotifyLogInfo(Properties.Resources.sconTotvsAppUnSetupGravadoNaFila);
      _smartLinkPublisherService.AddMessage(parms);
    }

    public void AddMessageSetup()
    {
      SmartLinkPublisherAddMessageParams parms = new SmartLinkPublisherAddMessageParams
      {
        Command = ctSmartLinkSetupCommand,
        CorrelatedId = "",
        Data = _sgdpResolverService.GetSGDPSetup().JsonResult
      };
      _logService.NotifyLogInfo(Properties.Resources.sconTotvsAppSetupGravadoNaFila);
      _smartLinkPublisherService.AddMessage(parms);
    }
  }
}