private string SaveResponseSuccess(string message, string kindOfMessage)
{
Embarque embarque = new EmbarqueDao().FindBySbeln(RESPONSE.MAIN.SBELN, kindOfMessage);
MainDAO dao = new MainDAO();
IList <MAIN> mainsSaved = dao.FindByIdEmbarqueLazy(embarque.ID);
if (mainsSaved.Count > 0)
{
dao.DeleteAll(mainsSaved);
}
ConfigStatus.SaveStatus(RESPONSE.STATUS, embarque);
RESPONSE.MAIN.Embarque = embarque;
RESPONSE.MAIN.BUK = RESPONSE.BUK;
RESPONSE.MAIN.PAR = RESPONSE.PAR;
RESPONSE.MAIN.PARS = RESPONSE.PARS;
RESPONSE.MAIN.DAT = RESPONSE.DAT;
RESPONSE.MAIN.DI = RESPONSE.DI;
RESPONSE.MAIN.BL = RESPONSE.BL;
RESPONSE.MAIN.SHP = RESPONSE.SHP;
RESPONSE.MAIN.SHP_TEXT_Main = RESPONSE.SHP_TEXT_Main;
dao.Save(RESPONSE.MAIN);
return(MessagesOfReturn.ProcessMessageSuccess(message, embarque.SBELN));
}
private string SaveResponseSuccess(string message, string kindOfMessage)
{
Embarque embarque = new EmbarqueDao().FindBySbeln(RESPONSE.TGTESHK_N.SBELN, kindOfMessage);
ConfigStatus.SaveStatus(RESPONSE.STATUS, embarque);
TGTESHK_NDao dao = new TGTESHK_NDao();
IList <TGTESHK_N> list = dao.FindByIdEmbarqueLazy(embarque.ID);
if (list.Count > 0)
{
dao.DeleteAll(list);
}
RESPONSE.TGTESHK_N.TGTESHP_N = RESPONSE.TGTESHP_N;
RESPONSE.TGTESHK_N.TGTERES = RESPONSE.TGTERES;
RESPONSE.TGTESHK_N.TGTEPRD = RESPONSE.TGTEPRD;
RESPONSE.TGTESHK_N.SHP_TEXT = RESPONSE.SHP_TEXT;
RESPONSE.TGTESHK_N.TGTEDUEK = RESPONSE.TGTEDUEK;
RESPONSE.TGTESHK_N.TGTEDUEP = RESPONSE.TGTEDUEP;
RESPONSE.TGTESHK_N.Embarque = embarque;
RESPONSE.TGTESHK_N.TGTESHP_N.ForEach(t => t.Embarque = embarque);
RESPONSE.TGTESHK_N.TGTERES.ForEach(t => t.Embarque = embarque);
RESPONSE.TGTESHK_N.TGTEPRD.ForEach(t => t.Embarque = embarque);
RESPONSE.TGTESHK_N.SHP_TEXT.ForEach(t => t.Embarque = embarque);
RESPONSE.TGTESHK_N.TGTEDUEK.ForEach(t => t.Embarque = embarque);
RESPONSE.TGTESHK_N.TGTEDUEP.ForEach(t => t.Embarque = embarque);
dao.Save(RESPONSE.TGTESHK_N);
return(MessagesOfReturn.ProcessMessageSuccess(message, embarque.SBELN));
}
private string ExecuteProcessMessage(string key, string value)
{
string messageReturn = "";
if (!string.IsNullOrEmpty(value))
{
try
{
string xmlRequest = value;
string fileName = GetFileName(key);
SaveXMLOriginal.SaveXML(_contentFile.ProvideContent(xmlRequest, fileName, TypeContentText.REQUEST));
string xmlResponse = RequestWebService.doRequestWebService(xmlRequest, _contentFile.Message);
SaveXMLOriginal.SaveXML(_contentFile.ProvideContent(xmlResponse, fileName, TypeContentText.RESPONSE));
messageReturn += SaveResponseDataBase(xmlResponse, key);
}
catch (Exception ex)
{
BuildLogException(key, ex);
}
}
else
{
messageReturn += MessagesOfReturn.DatasToRequestEmpty(_contentFile.Message);
}
return(messageReturn);
}
private string SaveResponseSuccess(string message, string kindOfMessage)
{
string sbeln = RESPONSE.PCK.FirstOrDefault(e => !string.IsNullOrEmpty(e.SBELN)).SBELN;
TPCKDao tpckDao = new TPCKDao();
Embarque embarque = new EmbarqueDao().FindBySbeln(sbeln, kindOfMessage);
IDictionary <string, TPCK> dictionaryTcpkByXblnr = tpckDao.DictionaryByXblnr(embarque.ID);
IList <Status> listStatus = new List <Status>();
foreach (var itemTpck in RESPONSE.PCK)
{
string newDesc = "";
if (dictionaryTcpkByXblnr.ContainsKey(itemTpck.XBLNR))
{
dictionaryTcpkByXblnr[itemTpck.XBLNR].STATU = itemTpck.STATU;
newDesc = MessagesOfReturn.DescriptionUpdateXblnrSuccess(itemTpck.XBLNR, RESPONSE.STATUS.DESC);
}
else
{
newDesc = MessagesOfReturn.DescriptionUpdateXblnrNotFound(itemTpck.XBLNR, RESPONSE.STATUS.DESC);
}
listStatus.Add(RESPONSE.STATUS.BuildsStatusWithNewDesc(newDesc));
}
tpckDao.Update();
foreach (var itemStatus in listStatus)
{
ConfigStatus.SaveStatus(itemStatus, embarque);
}
return(MessagesOfReturn.ProcessMessageSuccess(message, embarque.SBELN));
}
private string Importation(NumberOfMessage numberOfMessage)
{
string kindMessage = Option.IMPORTACAO;
string message = MessagesOfReturn.Message(numberOfMessage, kindMessage);
IDictionary <string, List <string> > objectsToRequest = new DatasToRequest4(kindMessage).GetDatasToRequest();
ContentText contentForSave = new ContentText(numberOfMessage, kindMessage);
return(new ProcessMessage <ResponseMessage4>(objectsToRequest, contentForSave).Process());
}
private string SaveResponseError(string xmlResponse, string identifier)
{
ResponseFatalError returnError = new DeserializeXml <ResponseFatalError>().deserializeXmlForDB(xmlResponse);
Status status = new Status(returnError.RESPONSE);
ConfigStatus.ConfigureStatus(status, _contentFile.NumberOfMessage, _contentFile.KindOfMessage, identifier);
ConfigStatus.SaveStatus(status);
return(MessagesOfReturn.AlertResponseWebServiceError(_contentFile.Message, identifier, _contentFile.NumberOfMessage));
}
private string ProcessMessageExcept4()
{
string messageReturn = "";
if (_objectsToRequest.Count > 0)
{
foreach (string key in _objectsToRequest.Keys)
{
messageReturn = ExecuteProcessMessage(key, _objectsToRequest[key]);
}
}
else
{
messageReturn += MessagesOfReturn.NotRequest(_contentFile.Message);
}
return(messageReturn);
}
private string BuildLogException(string identifier, Exception ex)
{
string messageError = MessagesOfReturn.ExceptionMessageLogSupport(_contentFile.Message, identifier, _contentFile.NumberOfMessage);
string detailProcess = "";
if (_contentFile.NumberOfMessage == NumberOfMessage.One)
{
detailProcess = MessagesOfReturn.DetailProcessWithIdBroker(_contentFile.Message, identifier);
}
else
{
detailProcess = MessagesOfReturn.DetailProcessWithSblen(_contentFile.Message, identifier);
}
int codeMessageError = MakeLog.BuildErrorLogSupport(ex, messageError, detailProcess);
return(MessagesOfReturn.ExceptionMessageLogUser(codeMessageError, messageError));
}
/// <summary>
/// Salva o arquivo XML do objeto xmlOriginal no diretóro do servidor
/// </summary>
/// <param name="xmlOriginal">Objeto que contém as propriedades do XML que será gravado</param>
/// <exception cref="ChangeXmlException">Lança a exceção do tipo ChangeXmlException com uma mensagem e internamente as exeções que ocorreram</exception>
public static void SaveXML(ContentText xmlOriginal)
{
//Verifica se o arquivo deve ser salva
if (xmlOriginal.IsConditionsAcceptableForSaveText)
{
try
{
RecordFile.CreateDirectorIfNotExisty(xmlOriginal.DirectoryFileSaveFileText);
RecordFile.SaveFile(xmlOriginal.PathFileSaveFileText, xmlOriginal.Content);
}
catch (Exception ex)
{
string msg = MessagesOfReturn.ExceptionSaveXml(xmlOriginal.PathFileSaveFileText);
throw new ChangeXmlException(msg, ex);
}
}
}
private string SaveResponseSuccess(string message, string kindOfMessage)
{
EmbarqueDao dao = new EmbarqueDao();
List <String> listSbeln = dao.GetListSbeln(kindOfMessage);
string retorno = "";
foreach (Embarque embarque in RESPONSE.ListaEmbarque.Embarques)
{
if (!listSbeln.Contains(embarque.SBELN))
{
embarque.Tipo = kindOfMessage;
dao.Save(embarque);
}
}
retorno += MessagesOfReturn.ProcessMessageOneSuccess(message, RESPONSE.ListaEmbarque.Embarques.FirstOrDefault().DadosBrokerID);
return(retorno);
}
public string SaveDataBase(string idBroker, string message, string kindOfMessage)
{
NumberOfMessage numberOfMessage = NumberOfMessage.One;
ConfigStatus.ConfigureStatus(RESPONSE.STATUS, numberOfMessage, kindOfMessage);
AlimentaIdDadosBroker(int.Parse(idBroker));
if (RESPONSE.ListaEmbarque != null && RESPONSE.ListaEmbarque.Embarques.Count > 0)
{
return(SaveResponseSuccess(message, kindOfMessage));
}
else if (RESPONSE.STATUS != null)
{
return(SaveResponseAlerta(message, numberOfMessage));
}
else // Se não recebeu nenhum Embarque do WebService
{
return(MessagesOfReturn.AlertResponseWebServiceError(message, idBroker, numberOfMessage));
}
}
private string ProcessOnlyMessage4()
{
string messageReturn = "";
if (_objectsToRequestMessage4.Count > 0)
{
foreach (string key in _objectsToRequestMessage4.Keys)
{
foreach (string value in _objectsToRequestMessage4[key])
{
messageReturn = ExecuteProcessMessage(key, value);
}
}
}
else
{
messageReturn += MessagesOfReturn.NotRequest(_contentFile.Message);
}
return(messageReturn);
}
/// <summary>
/// Instancia as classes do tipo Mensagem do BL.Command
/// e invoca o método SwapXmlWithGTE
/// </summary>
/// <returns></returns>
public void StartChangeXML()
{
for (int i = 0; i < 5; i++)
{
string retorno = "";
int message = i + 1;
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
try
{
//Recarrega o contexto
ChangeXMLContext.ReloadContext();
//Define qual Mensagem instanciar
string objeto = "BL.Command.Mensagem" + message;
//Instancia a Mensagem
var classe = Activator.CreateInstance(null, objeto);
IMessage mensagem = (IMessage)classe.Unwrap();
//Efetua a troca da Mensagem com o Web Service
retorno += mensagem.Execute();
}
catch (Exception ex)
{
string messageError = MessagesOfReturn.ExceptionMessageLogSupport($"Message {message}", null, GetNumberOfMessage(message));
int codeMessageError = MakeLog.BuildErrorLogSupport(ex, messageError, "RunMessenger");
messageError = $"Erro Faltal{Environment.NewLine}";
retorno += MessagesOfReturn.ExceptionMessageLogUser(codeMessageError, message.ToString());
}
finally
{
stopwatch.Stop();
MakeLog.BuildLogUser(retorno, GetNumberOfMessage(message), stopwatch.Elapsed);
}
}
}
private string SaveResponseSuccess(string identifier, string message)
{
ConfigStatus.SaveStatus(RESPONSE.STATUS);
return(MessagesOfReturn.ProcessMessageSuccess(message, identifier));
}
private string SaveResponseAlerta(string identifier, string message, NumberOfMessage numberOfMessage)
{
ConfigStatus.SaveStatus(RESPONSE.STATUS);
return(MessagesOfReturn.AlertResponseWebServiceError(message, identifier, numberOfMessage));
}
private string SaveResponseAlerta(Status status, string message, NumberOfMessage numberOfMessage)
{
ConfigStatus.SaveStatus(status);
return(MessagesOfReturn.AlertResponseWebServiceError(message, RESPONSE.STATUS.SBELN, numberOfMessage));
}
private string SaveResponseSuccess(Status retornoWebService, string message, string sbeln)
{
ConfigStatus.SaveStatus(retornoWebService);
return(MessagesOfReturn.ProcessMessageSuccess(message, sbeln));
}
private string SaveResponseAlerta(string message, NumberOfMessage numberOfMessage)
{
ConfigStatus.SaveStatus(RESPONSE.STATUS);
return(MessagesOfReturn.AlertResponseWebServiceError(message, RESPONSE.STATUS.idBroker.ToString(), numberOfMessage));
}
