public ViewResult ProdutoCadastrarSave(Produto p)
{
ViewResult vr = new ViewResult();
rdnProduto rdn = new rdnProduto();
Mensagem msg = new Mensagem();
String resultado = rdnProduto.adicionar(p);
try
{
int id = Convert.ToInt32(resultado);
msg.Titulo = "Produto cadastrado com sucesso. Código: " + resultado;
msg.Conteudo = "Deseja cadastrar imagens para o produto cadasrtado?";
msg.botaoEsquerdoLink = "ProdutoCadastrarImagem";
msg.botaoEsquerdoTitulo = "Sim";
}
catch (Exception e)
{
msg.Titulo = "Erro ao inserir.";
msg.Conteudo = "Produto cadastrado com sucesso." + resultado + e;
}
vr.ViewBag.Categorias = rdnCategoria.listarTodos();
vr.ViewBag.SubCategorias = rdnSubCategoria.listarTodos();
vr.ViewBag.Resultado = resultado;
vr.ViewBag.Mensagem = msg;
vr.ViewName = "ProdutoLista";
return vr;
}
public bool Salvar()
{
bool retorno = false;
int codigo = int.Parse(Request["codigo"]);
Turma turma = new Turma().Selecionar(codigo);
DateTime dataSelecionada = Convert.ToDateTime(txtData.Text);
DateTime dataAtual = DateTime.Now.Date;
if (dataSelecionada > dataAtual)
{
Mensagem.Aviso("Data da chamada deve ser menor ou igual a Data atual.");
}
else
{
DataTable listaAlunos = (DataTable)ViewState["ListaAlunos"];
if (turma != null && listaAlunos != null)
{
//checar preseça dos alunos
IList <Chamada> listaChamada = new Chamada().SelecionarPorTurmaData(turma, dataSelecionada);
for (int i = 0; i < listaAlunos.Rows.Count; i++)
{
Chamada chamada;
CheckBox chk = (CheckBox)gdvAluno.Rows[i].Cells[2].FindControl("chkPresenca");
int codigoChamada = 0;
//verifica se a chamada ja foi incluida no banco de dados
foreach (Chamada chamadaBanco in listaChamada)
{
if (chamadaBanco.Aluno.Codigo == Convert.ToInt32(listaAlunos.Rows[i].ItemArray[0].ToString()))
{
codigoChamada = chamadaBanco.Codigo;
break;
}
}
//atualiza
if (codigoChamada > 0)
{
chamada = new Chamada().Selecionar(codigoChamada);
}
else
{
//inclui registro na tabela
chamada = new Chamada();
chamada.Aluno = new Aluno().Selecionar(Convert.ToInt32(listaAlunos.Rows[i].ItemArray[0].ToString()));
chamada.Turma = turma;
chamada.Data = dataSelecionada;
chamada.Presenca = chk.Checked;
}
//inclui ou atualiza a presença do aluno
chamada.Presenca = chk.Checked;
try
{
retorno = chamada.Confirmar();
}
catch (Model.Base.GepexException.EBancoDados ex)
{
Mensagem.Aviso(Comum.TraduzirMensagem(ex));
}
catch (Model.Base.GepexException.ERegraNegocio ex)
{
Mensagem.Aviso(ex.Message);
}
catch (Exception ex)
{
throw ex;
}
if (!retorno)
{
break;
}
}
}
}
return(retorno);
}
private void Mensagem_buttonOk(object source, EventArgs e)
{
Mensagem.FecharMensagemAlerta();
}
public void ReceberMensagemFimEdicaoTarefaTest()
{
//Configurações do Servidor
IPAddress ipServidor = IPAddress.Parse("127.0.0.1");
const int portaServidor = 8007;
//Instanciar e iniciar o Servidor (Listener)
TcpListener servidor = new TcpListener(ipServidor, portaServidor);
servidor.Start();
Queue <MensagemDto> filaProcessamento = new Queue <MensagemDto>();
//Instanciar os Clientes (2x TcpClient)
TcpClient cliente1 = new TcpClient();
TcpClient cliente2 = new TcpClient();
const string login1 = "Joao";
const string login2 = "Pedro";
const string oidCronograma = "C1";
//Tentativa de conexao do cliente1
cliente1.Connect(ipServidor, portaServidor);
// Servidor aceitar a conexao do cliente1 e armazenar
TcpClient cliente1EmServidor = servidor.AcceptTcpClient();
//Tentativa de conexao do cliente2
cliente2.Connect(ipServidor, portaServidor);
// Servidor aceitar a conexao do cliente1 e armazenar
TcpClient cliente2EmServidor = servidor.AcceptTcpClient();
//Iniciar ConexaoCliente do cliente1
ConexaoClienteMock c1 = new ConexaoClienteMock(login1, cliente1EmServidor, filaProcessamento)
{
PermissaoDeEscrita = false
};
//Iniciar ConexaoCliente do cliente2
ConexaoClienteMock c2 = new ConexaoClienteMock(login2, cliente2EmServidor, filaProcessamento)
{
PermissaoDeEscrita = false
};
//Criar mensagemDto novoUsuarioConectado para o cliente1
MensagemDto m1 = Mensagem.RnCriarMensagemNovoUsuarioConectado(new string[] { login1 }, oidCronograma);
string m1Json = JsonConvert.SerializeObject(m1);
m1Json = TcpUtil.AdicionarStringProtecaoDeIntegridade(m1Json);
//Criar mensagemDto novoUsuarioConectado para o cliente2
MensagemDto m2 = Mensagem.RnCriarMensagemNovoUsuarioConectado(new string[] { login2 }, oidCronograma);
string m2Json = JsonConvert.SerializeObject(m2);
m2Json = TcpUtil.AdicionarStringProtecaoDeIntegridade(m2Json);
//Enviar a mensagem Json do primeiro cliente atráves do tcp cliente1;
TcpUtil.EnviarMensagemTcp(m1Json, cliente1);
ControleDeEsperaUtil.AguardarAte(() => { return(filaProcessamento.Count > 0); });
//Enviar a mensagem Json do segundo cliente atráves do tcp cliente2;
TcpUtil.EnviarMensagemTcp(m2Json, cliente2);
ControleDeEsperaUtil.AguardarAte(() => { return(filaProcessamento.Count > 1); });
Assert.AreEqual(2, filaProcessamento.Count, "Deveria ser enfileirada 2 objetos MensagemDto");
MensagemDto m3 = Mensagem.RnCriarMensagemFinalizarEdicaoTarefa("T1", "gabriel", "C1");
string m3Json = JsonConvert.SerializeObject(m3);
m3Json = TcpUtil.AdicionarStringProtecaoDeIntegridade(m3Json);
TcpUtil.EnviarMensagemTcp(m3Json, cliente2);
ControleDeEsperaUtil.AguardarAte(() => { return(filaProcessamento.Count > 2); });
c1.Desconectar();
c2.Desconectar();
servidor.Stop();
cliente1.Close();
cliente2.Close();
cliente1EmServidor.Close();
cliente2EmServidor.Close();
}
public void ReceberMensagemQuandoJsonIncompleto()
{
#region Estimativa do teste:
/*
* Estimativa do teste:
* - Receber uma mensagem json incompleta e armazenar no buffer e a fila deve estar vazia
* - receber o resto da mensagem processar e enfileirar
* Cenário:
* - conexão instanciada e configurada
* - filaProcessamento
* - MensagemJson convertida
* - MensagemJson repartida em 2
* - enviar as 2 partes separadamente
* Acontecimento Estimado:
* - Armazenar no buffer a mensagem incompleta
* - Verificar quando ela completar
* - Enfileirar a mensagem(somente se for completa)
* Resultado Estimado:
* - Deve conseguir enfileirar a mensagem
*/
#endregion
//Configurações de Ip e porta do servidor
IPAddress ipServidor = IPAddress.Parse("127.0.0.1");
const int portaServidor = 8001;
const string login = "******";
string[] usuarios = new string[1];
//Instanciação do Servidor para escutar o cliente
TcpListener servidor = new TcpListener(ipServidor, portaServidor);
servidor.Start();
//Instanciação do cliente que irá conectar no servidor
TcpClient cliente = new TcpClient();
cliente.Connect(ipServidor, portaServidor);
//Servidor Aceitando a solicitação do cliente
TcpClient conexao = servidor.AcceptTcpClient();
//Fila de processamento
Queue <MensagemDto> filaProcessamento = new Queue <MensagemDto>();
ConexaoCliente conexaoCliente = new ConexaoCliente(login, conexao, filaProcessamento);
//Montando a Mensagem que será enviada
MensagemDto mensagem = Mensagem.RnCriarMensagemNovoUsuarioConectado(new string[] { login }, "C1");
//Serializando a Mensagem que será enviada
string mensagemEnvio = JsonConvert.SerializeObject(mensagem);
//Adicionando string de verificação de integridade
mensagemEnvio = TcpUtil.AdicionarStringProtecaoDeIntegridade(mensagemEnvio);
//Dividindo a mensagem em 2 partes
string mensagemParte1 = mensagemEnvio.Substring(0, 12);
string mensagemParte2 = mensagemEnvio.Substring(12, (mensagemEnvio.Length - 12));
Assert.AreEqual(mensagemEnvio, mensagemParte1 + mensagemParte2, "Deveriam Ser Iguais");
//Enviando a Mensagem através da conexão do cliente
TcpUtil.EnviarMensagemTcp(mensagemParte1, cliente);
TcpUtil.EnviarMensagemTcp(mensagemParte2, cliente);
//Aguardando o enfileiramento
ControleDeEsperaUtil.AguardarAte(() => { return(filaProcessamento.Count == 1); });
Assert.AreEqual(1, filaProcessamento.Count, "Deveria possuir 1 mensagem enfileirada");
Assert.IsTrue(conexaoCliente.Buffer == "", "Deveria ter resolvido o buffer e enfileirado o evento");
conexaoCliente.Desconectar();
servidor.Stop();
conexao.Close();
}
public object AtualizarMensagem(Mensagem aoMensagem)
{
ManutencaoMensagem loManutencaoMensagem = new ManutencaoMensagem();
return(loManutencaoMensagem.Update(aoMensagem));
}
public void Enviar(Entidade_NotaFiscal ObjEnt, out Entidade_NotaFiscal objDados)
{
docTran = new XmlDocument();
ns = new XmlSerializerNamespaces();
xmlStatus = new XmlSerializer(typeof(nfe.TNFe));
Settings = new XmlWriterSettings();
DataTable DtLoteNfe = new DataTable();
mLog = new Model_LogNfe();
ObjLote = new Model_Lote();
ObjModNfe = new Model_NotaFiscal();
ObjNotaFiscal = ObjEnt;
NFuncoes = new NegocioFuncoesGerais();
ObjNotaFiscal = new Entidade_NotaFiscal();
var Lojas = FuncoesGerais.LojasEmitentes();
for (int i = 0; i < Lojas.Rows.Count; i++)
{
int Loja = 0;
int Nota = 0;
int Fornecedor = 0;
string Serie = "";
int TpEmis = 0;
var Lote = GerarLoteNfe(Convert.ToInt32(Lojas.Rows[i]["id_loja"].ToString()));
docEnviNfe = new XmlDocument();
if (Lote != 0)
{
docEnviNfe.PreserveWhitespace = false;
docEnviNfe.LoadXml(CabecalhoEnvieNfe(Lote));
nodeListNfe = docEnviNfe.GetElementsByTagName("enviNFe");
DtLoteNfe = PesquisaNotasFiscaisLoteNfe(Convert.ToInt32(Lojas.Rows[i]["id_loja"].ToString()), Lote);
foreach (DataRow RowNFDt in DtLoteNfe.Rows)
{
try
{
docTran = new XmlDocument();
var RetEnt = CarregarDados(Convert.ToInt32(RowNFDt["id_loja"]), Convert.ToInt32(RowNFDt["NrNf"]), RowNFDt["serienf"].ToString(), Convert.ToInt32(RowNFDt["CdFornec"]), RowNFDt["TpNFe"].ToString());
if (RetEnt != null)
{
ObjNotaFiscal.cUf = RetEnt.cUf; // Uf do Emitente
ObjNotaFiscal.Loja = RetEnt.Loja;
Loja = RetEnt.Loja;
Nota = RetEnt.NotaFiscal;
Fornecedor = RetEnt.CdFornecedor;
Serie = RetEnt.sSerieNf;
TpEmis = RetEnt.TpEmis;
ObjNotaFiscal.Lote = Lote;
Nfe = new nfe.TNFe(RetEnt);
}
// E DEFINIDO O TIPO DE LEITURA DO XML
Settings.Encoding = UTF8Encoding.UTF8;
Settings.NewLineHandling = NewLineHandling.None;
Settings.Indent = true;
Settings.IndentChars = "";
ns.Add(string.Empty, "http://www.portalfiscal.inf.br/nfe");
Sw = new UTF8StringWriter();
Wx = XmlWriter.Create(Sw, Settings);
xmlStatus.Serialize(Sw, Nfe, ns);
string xmlGer = Sw.ToString();
docTran.LoadXml(xmlGer);
docTran.PreserveWhitespace = false;
CertEmpresa = AssinaturaDigital.FindCertOnStore(Convert.ToInt32(RowNFDt["id_loja"]));
docTran = AssinaturaDigital.SignXml(docTran, CertEmpresa, "infNFe");
if (NFuncoes.ValidarEstruturaXml(docTran.OuterXml, "nfe_v3.10"))
{
Mensagem.MensagemErro(Mensagem.TipoMensagem.XmlLoteGerados, "Entrada", Lote.ToString() + "|" + "Nota :" + RetEnt.sSerieNf + "-" + RetEnt.NotaFiscal.ToString() + "|" + docTran.OuterXml);
nodeListCarregarNfe = docTran.GetElementsByTagName("NFe", "http://www.portalfiscal.inf.br/nfe");
nodeListNfe.Item(0).AppendChild(docEnviNfe.ImportNode(nodeListCarregarNfe.Item(0), true));
ObjLote.UpdateXmlTpSaida(RetEnt.Loja, RetEnt.NotaFiscal, RetEnt.sSerieNf, Lote, RetEnt.TpEmis.ToString(), docTran.OuterXml, RetEnt.CdFornecedor);
ObjModNfe.UpdateNfTpEmisVersaoNFe(RetEnt.TpEmis.ToString(), null, "3.10", Lote.ToString(), RetEnt.NotaFiscal.ToString(), RetEnt.Loja.ToString(), RetEnt.sSerieNf, RetEnt.CdFornecedor, Model_NotaFiscal.NotaFiscal.Entrada);
}
}
catch (Exception Ex)
{
Mensagem.MensagemErro(Mensagem.TipoMensagem.Nfe, "Entrada", Ex.Message.ToString());
ObjLote.UpdateXmlTpSaida(Loja, Nota, Serie, Lote, TpEmis.ToString(), docTran.OuterXml, Fornecedor);
ObjModNfe.UpdateNfErro(225, Loja, Serie, Nota, Fornecedor, Model_NotaFiscal.NotaFiscal.Entrada);
ObjLote.UpdateLoteErro(225, Loja, Serie, Nota, Fornecedor);
mLog.InsertErroLog("Erro Lote:" + Lote + ", Nota Fiscal Entrada:" + Serie + "-" + Nota + ". " + NFuncoes.TiraCampos(Ex.Message.ToString()));
}
}
if (CertEmpresa != null)
{
ObjNotaFiscal.TpAmbiente = FuncoesGerais.TipoAmbiente();
EnviarXml(docEnviNfe, CertEmpresa, ref ObjNotaFiscal);
}
objDados = null;
}
else
{
objDados = null;
}
}
objDados = null;
}
public void Atualizar(Mensagem mensagem)
{
_banco.Mensagem.Update(mensagem);
_banco.SaveChanges();
}
public void RnProcessarEventosReceberMensagensComStringDeProtecao()
{
int contador = 0;
WexMultiAccessClientMock cliente = new WexMultiAccessClientMock()
{
Porta = porta, EnderecoIp = ipServidor, Login = "******", OidCronograma = "C1", TcpAdapterStubAtivo = true
};
TcpAdapterPool pool = new TcpAdapterPool();
// mensagemDto que serão preenchidas no disparo dos eventos do client
MensagemDto mensagemAutenticacaoEsperada = new MensagemDto();
MensagemDto mensagemNovaTarefaCriadaEsperada = new MensagemDto();
MensagemDto mensagemInicioEdicaoTarefaCriada = new MensagemDto();
//eventos que deverão preencher as mensagensDto anteriores para comparação posterior
cliente.AoSerAutenticadoComSucesso += (mensagem) => { contador++; mensagemAutenticacaoEsperada = mensagem; };
cliente.AoSerCriadaNovaTarefa += (mensagem) => { contador++; mensagemNovaTarefaCriadaEsperada = mensagem; };
cliente.AoIniciarEdicaoTarefa += (mensagem) => { contador++; mensagemInicioEdicaoTarefaCriada = mensagem; };
cliente.AoServidorDesconectar += (mensagemDto) => { };
cliente.Conectar();
pool.AceitarConexao(cliente);
//dicionário de tarefas impactadas
Dictionary <string, Int16> tarefasImpactadas = new Dictionary <string, short>();
tarefasImpactadas.Add("T2", 1);
tarefasImpactadas.Add("T3", 2);
tarefasImpactadas.Add("T4", 3);
tarefasImpactadas.Add("T5", 4);
//mensagens que serão comunicadas ao client e deverão ser recebidas com sucesso no client
MensagemDto autenticacaoEnviada, novaTarefaCriadaEnviada, inicioEdicaoTarefaEnviada;
//criando mensagem de conexão aceita e retornando a mensagem ao client
autenticacaoEnviada = Mensagem.RnCriarMensagemConexaoEfetuadaComSucesso(new string[] { "Joao", "Pedro" }, "C1", null);
string json = JsonConvert.SerializeObject(autenticacaoEnviada);
json = TcpUtil.AdicionarStringProtecaoDeIntegridade(json);
//criando mensagem de inicio de edição de uma tarefa e comunicando ao client
inicioEdicaoTarefaEnviada = Mensagem.RnCriarMensagemInicioEdicaoTarefa("T1", "Joao", "C1");
string json2 = JsonConvert.SerializeObject(inicioEdicaoTarefaEnviada);
json2 = TcpUtil.AdicionarStringProtecaoDeIntegridade(json2);
DateUtil.CurrentDateTime = DateTime.Now;
//criando mensagem de criação de uma nova tarefa
novaTarefaCriadaEnviada = Mensagem.RnCriarMensagemNovaTarefaCriada("T2", "Gabriel", "C2", tarefasImpactadas, DateUtil.CurrentDateTime);
string json3 = JsonConvert.SerializeObject(novaTarefaCriadaEnviada);
json3 = TcpUtil.AdicionarStringProtecaoDeIntegridade(json3);
//unindo as mensagens em uma unica para testar o envio e o recebimento de mensagens coladas
json = json + json2 + json3;
pool.EnviarMensagemPara(cliente, json);
//aguardar até que os 3 eventos do client sejam disparados ao receber e tratar as mensagens enviadas
ControleDeEsperaUtil.AguardarAte(() => { return(contador == 3); });
Assert.AreEqual(3, contador, "Deveria ter contado 3 pois foram é a quantidade de mensagens acumuladas no tcp");
//asserts para a mensagem de autenticação
Assert.AreEqual(mensagemAutenticacaoEsperada.Tipo, autenticacaoEnviada.Tipo, "A mensagem recebida de autenticação deveria ser do mesmo tipo");
Assert.AreEqual((string)mensagemAutenticacaoEsperada.Propriedades[Constantes.OIDCRONOGRAMA], (string)autenticacaoEnviada.Propriedades["oidCronograma"], "Deveria possuir o mesmo" +
" cronograma nas mensagens de autenticação");
CollectionAssert.AreEquivalent((string[])mensagemAutenticacaoEsperada.Propriedades[Constantes.USUARIOS], (string[])autenticacaoEnviada.Propriedades[Constantes.USUARIOS], "Deveria possuir a mesma lista de usuários online");
//asserts para mensagem de criação de nova tarefa
Assert.AreEqual(mensagemNovaTarefaCriadaEsperada.Tipo, novaTarefaCriadaEnviada.Tipo, "A mensagem recebida de nova tarefa criada deveria ser do mesmo tipo");
Assert.AreEqual((string)mensagemNovaTarefaCriadaEsperada.Propriedades[Constantes.OIDCRONOGRAMA], (string)novaTarefaCriadaEnviada.Propriedades[Constantes.OIDCRONOGRAMA], "A mensagem recebida de nova tarefa criada deveria ser do mesmo tipo");
CollectionAssert.AreEquivalent((Dictionary <string, Int16>)mensagemNovaTarefaCriadaEsperada.Propriedades[Constantes.TAREFAS_IMPACTADAS], (Dictionary <string, Int16>)novaTarefaCriadaEnviada.Propriedades[Constantes.TAREFAS_IMPACTADAS], "Deveria possuir as tarefas impactadas com a mesma ordenacao");
}
public void DeveMontarUmaMensagemParaEnvioNoChat(string mensagemTexto, Mensagem mensagemEsperada)
{
var mensagemObtida = CriacaoDeMensagemDoBatePapo.Montar(mensagemTexto);
mensagemEsperada.ToExpectedObject().ShouldEqual(mensagemObtida);
}
/*/// <summary>
* /// Adiciona nova TbEmpresa
* /// </summary>
* /// <param name="param"></param>
* /// <returns></returns>
* public static string Add(string token, tbEmpresa param)
* {
* try
* {
* _db.tbEmpresas.Add(param);
* _db.SaveChanges();
* return param.nrCNPJBase;
* }
* catch (Exception e)
* {
* if (e is DbEntityValidationException)
* {
* string erro = MensagemErro.getMensagemErro((DbEntityValidationException)e);
* throw new Exception(erro.Equals("") ? "Falha ao salvar TbEmpresa" : erro);
* }
* throw new Exception(e.InnerException == null ? e.Message : e.InnerException.InnerException == null ? e.InnerException.Message : e.InnerException.InnerException.Message);
* }
* }
*
*
* /// <summary>
* /// Apaga uma TbEmpresa
* /// </summary>
* /// <param name="param"></param>
* /// <returns></returns>
* public static void Delete(string token, string nrCNPJBase)
* {
* try
* {
* _db.tbEmpresas.Remove(_db.tbEmpresas.Where(e => e.nrCNPJBase.Equals(nrCNPJBase)).First());
* _db.SaveChanges();
* }
* catch (Exception e)
* {
* if (e is DbEntityValidationException)
* {
* string erro = MensagemErro.getMensagemErro((DbEntityValidationException)e);
* throw new Exception(erro.Equals("") ? "Falha ao apagar TbEmpresa" : erro);
* }
* throw new Exception(e.InnerException == null ? e.Message : e.InnerException.InnerException == null ? e.InnerException.Message : e.InnerException.InnerException.Message);
* }
* }*/
/*/// <summary>
* /// Altera tbEmpresa
* /// </summary>
* /// <param name="param"></param>
* /// <returns></returns>
* public static Retorno Update(string token, tbEmpresa param)
* {
* try
* {
* tbEmpresa value = _db.tbEmpresas
* .Where(e => e.nrCNPJBase.Equals(param.nrCNPJBase))
* .First<tbEmpresa>();
*
* Retorno retorno = new Retorno();
*
* HttpRequest httpRequest = HttpContext.Current.Request;
* if (httpRequest.Files.Count == 0) throw new Exception("Não foi identificado o certificado digital");
* // Obtém o arquivo
* HttpPostedFile postedFile = httpRequest.Files[0];
*
* // Converte para um array de bytes
* MemoryStream memoryStream = postedFile.InputStream as MemoryStream;
* if (memoryStream == null)
* {
* memoryStream = new MemoryStream();
* postedFile.InputStream.CopyTo(memoryStream);
* }
* byte[] data = new byte[memoryStream.ToArray().Length];
* memoryStream.Read(data, 0, data.Length);
* memoryStream.Close();
*
* // VERIFICAR SE EXISTE ALTERAÇÃO NOS PARAMETROS
* if (data != null && (value.dsCertificadoDigital == null || !data.SequenceEqual(value.dsCertificadoDigital)))
* value.dsCertificadoDigital = data;
* if (param.dsCertificadoDigitalSenha != null && (value.dsCertificadoDigitalSenha == null || !param.dsCertificadoDigitalSenha.Equals(value.dsCertificadoDigitalSenha)))
* value.dsCertificadoDigitalSenha = param.dsCertificadoDigitalSenha;
*
* Mensagem mensagem = CertificadoDigital.ValidarCertificado(value.dsCertificadoDigital, value.dsCertificadoDigitalSenha);
* if (mensagem.cdMensagem == 200)
* {
* value.dtCadastro = DateTime.Now;
* value.dtValidade = CertificadoDigital.GetDataValidade(param.dsCertificadoDigital, param.dsCertificadoDigitalSenha);
* value.flSenhaValida = true;
*
* _db.SaveChanges();
* }
*
* retorno.Registros.Add(mensagem);
*
* return retorno;
* }
* catch (Exception e)
* {
* if (e is DbEntityValidationException)
* {
* string erro = MensagemErro.getMensagemErro((DbEntityValidationException)e);
* throw new Exception(erro.Equals("") ? "Falha ao alterar TbEmpresa" : erro);
* }
* throw new Exception(e.InnerException == null ? e.Message : e.InnerException.InnerException == null ? e.InnerException.Message : e.InnerException.InnerException.Message);
* }
* }*/
/// <summary>
/// Altera certificado e senha
/// </summary>
/// <param name="param"></param>
/// <returns></returns>
public static Mensagem Patch(string token, Dictionary <string, string> queryString, painel_taxservices_dbContext _dbContext = null)
{
painel_taxservices_dbContext _db;
if (_dbContext == null)
{
_db = new painel_taxservices_dbContext();
}
else
{
_db = _dbContext;
}
try
{
// TEM QUE TER ENVIADO VIA QUERYSTRING nrCNPJBase e dsCertificadoDigitalSenha
string outValue = null;
if (!queryString.TryGetValue("" + (int)GatewayTbEmpresa.CAMPOS.NRCNPJBASE, out outValue) ||
!queryString.TryGetValue("" + (int)GatewayTbEmpresa.CAMPOS.DSCERTIFICADODIGITALSENHA, out outValue))
{
throw new Exception("CNPJ base e Senha são obrigatórios!");
}
string nrCNPJBase = queryString["" + (int)GatewayTbEmpresa.CAMPOS.NRCNPJBASE];
string dsCertificadoDigitalSenha = queryString["" + (int)GatewayTbEmpresa.CAMPOS.DSCERTIFICADODIGITALSENHA];
// Obtém o objet
tbEmpresa value = _db.tbEmpresas.Where(e => e.nrCNPJBase.Equals(nrCNPJBase)).FirstOrDefault();
if (value == null)
{
throw new Exception("CNPJ Base inexistente!");
}
// TEM QUE TER ENVIADO O ARQUIVO
HttpRequest httpRequest = HttpContext.Current.Request;
if (httpRequest.Files.Count == 0)
{
throw new Exception("Não foi identificado o certificado digital");
}
// Obtém o arquivo
HttpPostedFile postedFile = httpRequest.Files[0];
// Valida a extensão
string extensao = postedFile.FileName.Substring(postedFile.FileName.LastIndexOf("."));
if (!extensao.ToLower().Equals(".pfx"))
{
throw new Exception("Formato do arquivo deve ser PFX!");
}
// Converte para um array de bytes
BinaryReader binaryReader = new BinaryReader(postedFile.InputStream);
byte[] data = binaryReader.ReadBytes(postedFile.ContentLength);
// VERIFICAR SE EXISTE ALTERAÇÃO NOS PARAMETROS
if (value.dsCertificadoDigital == null || !data.SequenceEqual(value.dsCertificadoDigital))
{
value.dsCertificadoDigital = data;
}
if (value.dsCertificadoDigitalSenha == null || !dsCertificadoDigitalSenha.Equals(value.dsCertificadoDigitalSenha))
{
value.dsCertificadoDigitalSenha = dsCertificadoDigitalSenha;
}
// Decodifica a senha
string senha = CertificadoDigital.DecodeFrom64(dsCertificadoDigitalSenha);
Mensagem mensagem = CertificadoDigital.ValidarCertificado(data, senha);//value.dsCertificadoDigital, value.dsCertificadoDigitalSenha);
if (mensagem.cdMensagem == 200)
{
value.dtCadastro = DateTime.Now;
value.dtValidade = CertificadoDigital.GetDataValidade(data, senha);//value.dsCertificadoDigital, value.dsCertificadoDigitalSenha);
value.flSenhaValida = true;
_db.SaveChanges();
}
return(mensagem);
}
catch (Exception e)
{
if (e is DbEntityValidationException)
{
string erro = MensagemErro.getMensagemErro((DbEntityValidationException)e);
throw new Exception(erro.Equals("") ? "Falha ao alterar TbEmpresa" : erro);
}
throw new Exception(e.InnerException == null ? e.Message : e.InnerException.InnerException == null ? e.InnerException.Message : e.InnerException.InnerException.Message);
}
finally
{
if (_dbContext == null)
{
// Fecha conexão
_db.Database.Connection.Close();
_db.Dispose();
}
}
}
public Mensagem DeleteVerify(int id)
{
var msg = new Mensagem(Descricoes.MSG002, Tipo.Confirmacao);
return(msg);
}
public bool Salvar(Empreendimento empreendimento)
{
try
{
if (_validar.Salvar(empreendimento))
{
Mensagem erros = VerificarLocalizacaoEmpreendimento(empreendimento.Coordenada.EastingUtmTexto, empreendimento.Coordenada.NorthingUtmTexto, empreendimento.Enderecos[0].EstadoId, empreendimento.Enderecos[0].MunicipioId);
if (erros.Texto != null)
{
Validacao.Add(erros);
return(Validacao.EhValido);
}
empreendimento.CredenciadoId = User.FuncionarioId;
if (empreendimento.InternoId.GetValueOrDefault() > 0)
{
empreendimento.InternoTid = new EmpreendimentoInternoBus().ObterSimplificado(empreendimento.InternoId.Value).Tid;
}
if (empreendimento.Coordenada.Tipo.Id > 0)
{
empreendimento.Coordenada.Datum.Sigla = ListaCredenciadoBus.Datuns.SingleOrDefault(x => Equals(x.Id, empreendimento.Coordenada.Datum.Id)).Sigla;
}
#region Utilizar o mesmo endereço de localização
if (empreendimento.Enderecos.Count == 1)
{
Endereco enderecoLocalizacao = empreendimento.Enderecos.First();
Endereco endereco = new Endereco();
endereco.Correspondencia = 1;
endereco.Cep = enderecoLocalizacao.Cep;
endereco.Logradouro = enderecoLocalizacao.Logradouro;
endereco.Bairro = enderecoLocalizacao.Bairro;
endereco.EstadoId = enderecoLocalizacao.EstadoId;
endereco.MunicipioId = enderecoLocalizacao.MunicipioId;
endereco.Numero = enderecoLocalizacao.Numero;
endereco.DistritoLocalizacao = enderecoLocalizacao.DistritoLocalizacao;
endereco.Complemento = enderecoLocalizacao.Complemento;
empreendimento.Enderecos.Add(endereco);
}
#endregion
GerenciadorTransacao.ObterIDAtual();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(UsuarioCredenciado))
{
bancoDeDados.IniciarTransacao();
PessoaCredenciadoBus pessoaCredenciadoBus = new PessoaCredenciadoBus();
Pessoa aux;
List <Mensagem> mensagens = new List <Mensagem>();
foreach (Responsavel responsavel in empreendimento.Responsaveis)
{
if (responsavel.Id <= 0)
{
aux = pessoaCredenciadoBus.ObterPessoa(interno: responsavel.InternoId);
Pessoa pessoaCredenciado = pessoaCredenciadoBus.Obter(aux.CPFCNPJ, bancoDeDados, simplificado: true, credenciadoId: User.FuncionarioId);
aux.Id = pessoaCredenciado.Id;
pessoaCredenciadoBus.Salvar(aux, bancoDeDados);
responsavel.Id = aux.Id;
if (!Validacao.EhValido)
{
mensagens.Add(Mensagem.Pessoa.DadosRepresentanteIncompleto(aux.NomeRazaoSocial));
}
}
}
if (!Validacao.EhValido)
{
mensagens.ForEach(msg =>
{
msg.Texto = msg.Texto.Replace("representante", "responsável");
});
Validacao.Erros = mensagens;
bancoDeDados.Rollback();
return(false);
}
_da.Salvar(empreendimento, bancoDeDados);
#region Solicitação de CAR
CARSolicitacaoBus carSolicitacaoBus = new CARSolicitacaoBus();
CARSolicitacao carSolicitacao = new CARSolicitacao();
carSolicitacao.Empreendimento.Id = empreendimento.Id;
carSolicitacaoBus.AlterarSituacao(carSolicitacao, new CARSolicitacao()
{
SituacaoId = (int)eCARSolicitacaoSituacao.Invalido
}, bancoDeDados);
#endregion
bancoDeDados.Commit();
}
}
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(Validacao.EhValido);
}
/// <summary>
/// Responsável por comunicar o manager quais tarefas foram realmente excluídas
/// </summary>
/// <param name="tarefas">vetor de tarefas efetivamente excluidas</param>
/// <param name="tarefasNaoExcluidas">vetor de tarefas que não puderam ser excluidas</param>
public void RnComunicarFimExclusaoTarefaConcluida(string[] tarefas, Dictionary <string, Int16> tarefasImpactadas, string[] tarefasNaoExcluidas, DateTime dataHoraAcao)
{
MensagemDto mensagem = Mensagem.RnCriarMensagemComunicarExclusaoTarefaConcluida(tarefas, tarefasImpactadas, OidCronograma, Login, dataHoraAcao, tarefasNaoExcluidas);
RnEnviarMensagem(mensagem);
}
/// <summary>
/// Responsável por comunicar o manager quais tarefas o colaborador deseja excluir
/// </summary>
/// <param name="tarefas"></param>
public void RnComunicarInicioExclusaoTarefa(string[] tarefas)
{
MensagemDto mensagem = Mensagem.RnCriarMensagemInicioExclusaoTarefas(tarefas, Login, OidCronograma);
RnEnviarMensagem(mensagem);
}
public void Alterar(Mensagem mensagem)
{
context.Mensagem.Update(mensagem);
context.SaveChanges();
}
public T ObterObjetoMensagem <T>() where T : class
{
return(JsonConvert.DeserializeObject <T>(Mensagem.ToString()));
}
public void Cadastrar(Mensagem mensagem)
{
_banco.Mensagem.Add(mensagem);
_banco.SaveChanges();
}
public TesteDeRede()
{
//Cria o servidor DNS
var dns = new DNS();
var mascara = new Endereco("255.255.0.0");
//Cria um cliente "Notebook"
var ipNotebook = new Endereco("192.23.23.23");
var macNotebook = new EnderecoMAC("00.01.02.03.04.05");
var portaNotebook = 45;
var notebook = new Maquina("Notebook", ipNotebook, macNotebook, mascara);
var clientDNS = notebook.ClienteDNS;
Aplicacao client = new AplicacaoCliente(portaNotebook, notebook, clientDNS);
notebook.Adicionar(portaNotebook, client);
//Criação dos Servidores
var ipServidorHP = new Endereco("192.23.12.12");
var macServidorHP = new EnderecoMAC("24.88.90.00.FF.AB");
var portaServidorHP = 888;
var servidorHP = new Maquina("ServidorHP", ipServidorHP, macServidorHP, mascara);
Aplicacao servidor = new ServidorMultiplicaPorDois(portaServidorHP, servidorHP, servidorHP.ClienteDNS);
servidorHP.Adicionar(portaServidorHP, servidor);
//Adiciona uma nova aplicação ao servidor
portaServidorHP = 42;
servidor = new ServidorDeMaiusculizacao(portaServidorHP, servidorHP, servidorHP.ClienteDNS);
servidorHP.Adicionar(portaServidorHP, servidor);
//DNS
var ipServidorOpenDNS = new Endereco("192.23.89.41");
var macServidorOpenDNS = new EnderecoMAC("AA.CD.EF.00.AA.54");
var portaServidorOpenDNS = 53; //porta DNS padrão
var servidorOpenDNS = new Maquina("ServidorOpenDNS", ipServidorOpenDNS, macServidorOpenDNS, mascara);
var servidorDns = new ServidorDNS(portaServidorOpenDNS, servidorOpenDNS, dns);
servidorOpenDNS.Adicionar(portaServidorOpenDNS, servidorDns);
{
//Adiciona ás máquinas no Cache DNS
dns.Adicionar(notebook.NomeMaquina, notebook.EnderecoIP);
dns.Adicionar(servidorHP.NomeMaquina, servidorHP.EnderecoIP);
dns.Adicionar(servidorOpenDNS.NomeMaquina, servidorOpenDNS.EnderecoIP);
}
//Criação da rede local
var redeLocal = new RedeLocal();
redeLocal.Adicionar(notebook, servidorHP, servidorOpenDNS);
Console.WriteLine("\n\n\r\r");
//*** Utilização das aplicações ***
{
/* .1) Servidor de duplicação
* Descrição: O cliente envia uma mensagem (valor inteiro) ao servidor
* que irá duplicar o valor
*/
var valor = 10;
var mensagem = new Mensagem(valor);
Console.WriteLine($"Valor a ser duplicado: {valor}");
client.EnviarMensagem("ServidorHP", 888, mensagem);
var resul = client.Resultado;
Console.WriteLine($"O servidor de duplicação retornou o valor {resul.ExtrairTudo(0)}");
etapa = 0;
}
Console.WriteLine("\n\n\n\n");
{
/* 2.) Servidor de Maiusulilazação
* Descrição: O cliente envia uma mensagem (string) para o servidor que
* retorna o texto em caixa alta.
*/
//var texto = "Pneumoultramicroscopicossilicovulcanoconiótico";
var texto = "um dia para testar rede";
var mensagem = new Mensagem(texto);
Console.WriteLine($"Maiusculalização de \"{texto}\"");
client.EnviarMensagem("ServidorHP", 42, mensagem);
var result = client.Resultado;
Console.WriteLine($"O servidor retornou: {result.ExtrairTexto()}");
}
Console.ReadKey();
}
public object CadastraMensagem(Mensagem aoMensagem)
{
ManutencaoMensagem loManutencaoMensagem = new ManutencaoMensagem();
return(loManutencaoMensagem.Insert(aoMensagem));
}
internal EmissaoPTVRelatorio Obter(int id, bool simplificado = false)
{
EmissaoPTVRelatorio emissaoPTV = new EmissaoPTVRelatorio();
List <String> listDeclaracoesAdicionais = new List <String>();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia())
{
Comando comando = null;
#region SQL PTV
comando = bancoDeDados.CriarComando(@"
select distinct t.id,
t.tid,
t.numero,
t.situacao,
e.denominador,
e.cnpj,
le.sigla as uf,
lm.texto as municipio,
ee.logradouro,
ee.bairro,
ee.distrito,
nvl(pr.nome, pr.razao_social) as resp_razao_social,
pr.cpf as empreend_resp_cpf,
t.partida_lacrada_origem,
t.numero_lacre,
t.numero_porao,
t.numero_container,
t.apresentacao_nota_fiscal,
t.numero_nota_fiscal,
t.tipo_transporte,
t.rota_transito_definida,
t.veiculo_identificacao_numero,
t.itinerario,
t.data_ativacao,
t.valido_ate,
t.responsavel_tecnico,
d.nome as destinatario_nome,
d.endereco as destinatario_endereco,
led.sigla destinatario_uf,
lmd.texto destinatario_mun,
lme.texto as municipio_emissao,
d.cpf_cnpj destinatario_cpfcnpj
from tab_ptv t,
tab_empreendimento e,
tab_empreendimento_endereco ee,
lov_estado le,
lov_municipio lm,
lov_municipio lme,
tab_pessoa pr,
tab_destinatario_ptv d,
lov_estado led,
lov_municipio lmd
where e.id = t.empreendimento
and (ee.empreendimento = e.id and ee.correspondencia = 0)
and le.id = ee.estado
and lm.id = ee.municipio
and lme.id(+) = t.municipio_emissao
and pr.id(+) = t.responsavel_emp
and d.id = t.destinatario
and led.id = d.uf
and lmd.id = d.municipio
and t.id = :id" , EsquemaBanco);
comando.AdicionarParametroEntrada("id", id, DbType.Int32);
using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
{
if (reader.Read())
{
emissaoPTV.Id = id;
emissaoPTV.Tid = reader.GetValue <string>("tid");
emissaoPTV.Situacao = reader.GetValue <int>("situacao");
emissaoPTV.FuncId = reader.GetValue <int>("responsavel_tecnico");
emissaoPTV.NumeroPTV = reader.GetValue <string>("numero");
emissaoPTV.PartidaLacrada = reader.GetValue <int>("partida_lacrada_origem");
emissaoPTV.NumeroLacre = reader.GetValue <string>("numero_lacre");
emissaoPTV.NumeroPorao = reader.GetValue <string>("numero_porao");
emissaoPTV.NumeroConteiner = reader.GetValue <string>("numero_container");
emissaoPTV.TipoTransporte = reader.GetValue <int>("tipo_transporte");
emissaoPTV.Rota_transito_definida = reader.GetValue <int>("rota_transito_definida");
emissaoPTV.ApresentacaoNotaFiscal = reader.GetValue <int>("apresentacao_nota_fiscal");
emissaoPTV.NumeroNotaFiscal = reader.GetValue <string>("numero_nota_fiscal");
emissaoPTV.VeiculoNumero = reader.GetValue <string>("veiculo_identificacao_numero");
emissaoPTV.Itinerario = reader.GetValue <string>("itinerario");
emissaoPTV.DataAtivacao = reader.GetValue <DateTime>("data_ativacao").ToString("dd/MM/yyyy");
emissaoPTV.DataValidade = reader.GetValue <DateTime>("valido_ate").ToShortDateString();
emissaoPTV.Destinatario.Nome = reader.GetValue <string>("destinatario_nome");
emissaoPTV.Destinatario.Endereco = reader.GetValue <string>("destinatario_endereco");
emissaoPTV.Destinatario.UF = reader.GetValue <string>("destinatario_uf");
emissaoPTV.Destinatario.Municipio = reader.GetValue <string>("destinatario_mun");
emissaoPTV.Destinatario.CPFCNPJ = reader.GetValue <string>("destinatario_cpfcnpj");
emissaoPTV.MunicipioEmissao = reader.GetValue <string>("municipio_emissao");
emissaoPTV.Empreendimento.ResponsavelRazaoSocial = reader.GetValue <string>("resp_razao_social");
emissaoPTV.Empreendimento.NomeRazao = reader.GetValue <string>("denominador");
emissaoPTV.Empreendimento.EndLogradouro = reader.GetValue <string>("logradouro");
emissaoPTV.Empreendimento.EndBairro = reader.GetValue <string>("bairro");
emissaoPTV.Empreendimento.EndDistrito = reader.GetValue <string>("distrito");
emissaoPTV.Empreendimento.EndMunicipio = reader.GetValue <string>("municipio");
emissaoPTV.Empreendimento.EndUF = reader.GetValue <string>("uf");
emissaoPTV.Empreendimento.CNPJ = reader.GetValue <string>("cnpj");
emissaoPTV.Empreendimento.ResponsavelCPF = reader.GetValue <string>("empreend_resp_cpf");
}
reader.Close();
}
#endregion
if (simplificado)
{
return(emissaoPTV);
}
#region SQL Funcionário
comando = bancoDeDados.CriarComando(@"
select f.nome, h.numero_habilitacao, h.numero_crea, f.arquivo arquivo_id from {0}tab_hab_emi_ptv h, {0}tab_funcionario f
where f.id = h.funcionario and f.id = :idfun" , EsquemaBanco);
comando.AdicionarParametroEntrada("idfun", emissaoPTV.FuncId, DbType.Int32);
using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
{
if (reader.Read())
{
emissaoPTV.FuncionarioHabilitado.Nome = reader.GetValue <string>("nome");
emissaoPTV.FuncionarioHabilitado.Numero = reader.GetValue <string>("numero_habilitacao");
emissaoPTV.FuncionarioHabilitado.Registro = reader.GetValue <string>("numero_crea");
emissaoPTV.FuncionarioHabilitado.ArquivoId = reader.GetValue <int>("arquivo_id");
}
reader.Close();
}
#endregion
#region SQL PTVProduto
comando = bancoDeDados.CriarComando(@"select c.texto cultura,
cc.cultivar,
t.quantidade,
decode(t.origem_tipo, 1, (select cfo.numero from cre_cfo cfo where cfo.id = t.origem), '') as numero_cfo,
decode(t.origem_tipo, 2, (select cfoc.numero from cre_cfoc cfoc where cfoc.id = t.origem), '') as numero_cfoc,
decode(t.origem_tipo, 3, (select ptv.numero from tab_ptv ptv where ptv.id = t.origem), 4, (select ptv.numero from tab_ptv_outrouf ptv where ptv.id = t.origem), '') as numero_ptv,
decode(t.origem_tipo, 5, t.numero_origem, '') as numero_cf_cfr,
decode(t.origem_tipo, 6, t.numero_origem, '') as numero_tf,
u.texto as unidade_medida,
nvl(t.origem, 0) origem,
t.origem_tipo,
t.cultura cultura_id,
t.cultivar cultivar_id
from {0}tab_ptv_produto t,
{0}tab_ptv p,
{0}tab_cultura c,
{0}tab_cultura_cultivar cc,
lov_crt_uni_prod_uni_medida u
where c.id = t.cultura
and cc.id = t.cultivar
and p.id = t.ptv
and u.id = t.unidade_medida
and t.ptv = :ptv" , EsquemaBanco);
comando.AdicionarParametroEntrada("ptv", emissaoPTV.Id, DbType.Int32);
using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
{
while (reader.Read())
{
emissaoPTV.Produtos.Add(new PTVProdutoRelatorio()
{
CulturaTexto = reader.GetValue <string>("cultura"),
CulturaId = reader.GetValue <int>("cultura_id"),
CultivarTexto = reader.GetValue <string>("cultivar"),
CultivarId = reader.GetValue <int>("cultivar_id"),
Quantidade = reader.GetValue <decimal>("quantidade"),
NumeroCFO = reader.GetValue <string>("numero_cfo"),
NumeroCFOC = reader.GetValue <string>("numero_cfoc"),
NumeroPTV = reader.GetValue <string>("numero_ptv"),
NumeroCFCFR = reader.GetValue <string>("numero_cf_cfr"),
NumeroTF = reader.GetValue <string>("numero_tf"),
UnidadeMedida = reader.GetValue <string>("unidade_medida"),
Origem = reader.GetValue <int>("origem"),
OrigemTipo = reader.GetValue <int>("origem_tipo")
});
}
reader.Close();
}
List <LaudoLaboratorial> laudoLaboratoriais = ObterLaudoLaboratorial(emissaoPTV.Produtos);
emissaoPTV.LaboratorioNome = Mensagem.Concatenar(laudoLaboratoriais.Select(x => x.Nome).ToList());
emissaoPTV.NumeroLaudo = Mensagem.Concatenar(laudoLaboratoriais.Select(x => x.LaudoResultadoAnalise).ToList());
emissaoPTV.LaboratorioMunicipio = Mensagem.Concatenar(laudoLaboratoriais.Select(x => x.MunicipioTexto).ToList());
emissaoPTV.LaboratorioUF = Mensagem.Concatenar(laudoLaboratoriais.Select(x => x.EstadoTexto).ToList());
foreach (var item in emissaoPTV.Produtos.Where(xx => (xx.OrigemTipo == (int)eDocumentoFitossanitarioTipo.CFO || xx.OrigemTipo == (int)eDocumentoFitossanitarioTipo.CFOC || xx.OrigemTipo == (int)eDocumentoFitossanitarioTipo.PTV)).ToList())
{
List <String> listDeclaracoesAdicionaisAux = ObterDeclaracaoAdicional(item.Origem, item.OrigemTipo, (int)ValidacoesGenericasBus.ObterTipoProducao(item.UnidadeMedida), item.CultivarId);
item.DeclaracaoAdicional = String.Join(" ", listDeclaracoesAdicionaisAux.Distinct().ToList());
listDeclaracoesAdicionais.AddRange(listDeclaracoesAdicionaisAux);
}
emissaoPTV.DeclaracaoAdicionalHtml = String.Join(" ", listDeclaracoesAdicionais.Distinct().ToList());
#endregion
#region Tratamento Fitossanitário
emissaoPTV.Tratamentos = TratamentoFitossanitario(emissaoPTV.Produtos);
if (emissaoPTV.Tratamentos == null || emissaoPTV.Tratamentos.Count <= 0)
{
emissaoPTV.Tratamentos = new List <TratamentosRelatorio>()
{
new TratamentosRelatorio()
{
}
};
}
#endregion
#region Arquivo
if (emissaoPTV.FuncionarioHabilitado.ArquivoId.HasValue && emissaoPTV.FuncionarioHabilitado.ArquivoId > 0)
{
ArquivoBus _busArquivo = new ArquivoBus(eExecutorTipo.Interno);
emissaoPTV.AssinaturaDigital = _busArquivo.Obter(emissaoPTV.FuncionarioHabilitado.ArquivoId.Value);
}
#endregion
}
return(emissaoPTV);
}
public async Task EnviarMensagem(Mensagem mensagem)
{
await Clients.All.SendAsync("RecebendoMensagem", mensagem);
}
///<summary>Caso o nome inserido seja válido, remove o produto.</summary>
///<param name="produtoRecebido">Objeto do tipo ProdutoViewModel</param>
public static void Remover(ProdutoViewModel produtoRecebido)
{
listaDeProdutos.Remove(BuscarProdutoPorNome(produtoRecebido.Nome));
Mensagem.MostrarMensagem("Produto removido com sucesso!", TipoMensagemEnum.SUCESSO);
}
public void ReceberMensagemQuandoJsonEstiverCompleto()
{
#region Estimativa de Teste:
/*
* Estimativa Teste:
* Receber uma mensagemDto Json e enfileirar na fila de leitura;
* Cenário:
* - Instanciar um Listener (gerenciar as conexoes)
* - Instanciar 2 TcpClients (Efetuar a comunicação de conexão)
* - Montar as MensagemDTOs de NovoUsarioConectado
* - Serializar as Mensagens
* - Escrever cada mensagem no stream de seu respectivo tcp
* - Ler a Mensagem no stream
* - Processar Cada Mensagem e enfileirar na fila de leitura
* Resultado Estimado:
* - Deve ter sido possivel o enfileiramento das 2 mensagens dto recebidas
*/
#endregion
//Configurações do Servidor
IPAddress ipServidor = IPAddress.Parse("127.0.0.1");
const int portaServidor = 8000;
//Instanciar e iniciar o Servidor (Listener)
TcpListener servidor = new TcpListener(ipServidor, portaServidor);
servidor.Start();
Queue <MensagemDto> filaProcessamento = new Queue <MensagemDto>();
//Instanciar os Clientes (2x TcpClient)
TcpClient cliente1 = new TcpClient();
TcpClient cliente2 = new TcpClient();
const string login1 = "Joao";
const string login2 = "Pedro";
const string oidCronograma = "C1";
//Tentativa de conexao do cliente1
cliente1.Connect(ipServidor, portaServidor);
// Servidor aceitar a conexao do cliente1 e armazenar
TcpClient cliente1EmServidor = servidor.AcceptTcpClient();
//Tentativa de conexao do cliente2
cliente2.Connect(ipServidor, portaServidor);
// Servidor aceitar a conexao do cliente1 e armazenar
TcpClient cliente2EmServidor = servidor.AcceptTcpClient();
//Iniciar ConexaoCliente do cliente1
ConexaoClienteMock c1 = new ConexaoClienteMock(login1, cliente1EmServidor, filaProcessamento)
{
PermissaoDeEscrita = false
};
//Iniciar ConexaoCliente do cliente2
ConexaoClienteMock c2 = new ConexaoClienteMock(login2, cliente2EmServidor, filaProcessamento)
{
PermissaoDeEscrita = false
};
//Criar mensagemDto novoUsuarioConectado para o cliente1
MensagemDto m1 = Mensagem.RnCriarMensagemNovoUsuarioConectado(new string[] { login1 }, oidCronograma);
string m1Json = JsonConvert.SerializeObject(m1);
m1Json = TcpUtil.AdicionarStringProtecaoDeIntegridade(m1Json);
//Criar mensagemDto novoUsuarioConectado para o cliente2
MensagemDto m2 = Mensagem.RnCriarMensagemNovoUsuarioConectado(new string[] { login2 }, oidCronograma);
string m2Json = JsonConvert.SerializeObject(m2);
m2Json = TcpUtil.AdicionarStringProtecaoDeIntegridade(m2Json);
//Enviar a mensagem Json do primeiro cliente atráves do tcp cliente1;
TcpUtil.EnviarMensagemTcp(m1Json, cliente1);
ControleDeEsperaUtil.AguardarAte(() => { return(filaProcessamento.Count > 0); });
//Enviar a mensagem Json do segundo cliente atráves do tcp cliente2;
TcpUtil.EnviarMensagemTcp(m2Json, cliente2);
ControleDeEsperaUtil.AguardarAte(() => { return(filaProcessamento.Count > 1); });
Assert.AreEqual(2, filaProcessamento.Count, "Deveria ser enfileirada 2 objetos MensagemDto");
#region Testes:
//Verificar see enfileirou as mensagens recebidas
// Assert.AreEqual(2, filaProcessamento.Count, "Deveria possuir 2 mensagens enfileiradas");
//Checar se não há nenhuma mensagem incompleta no buffer de mensagens das conexões
// Assert.IsTrue(string.IsNullOrEmpty(conexaoCliente.Buffer), "Buffer deveria estar vazio pois as mensagens json eram mensagens válidas");
// Assert.IsTrue(string.IsNullOrEmpty(conexaoCliente2.Buffer), "Buffer deveria estar vazio pois as mensagens json eram mensagens válidas");
#endregion
#region Finalização Cenário
c1.Desconectar();
c2.Desconectar();
servidor.Stop();
cliente1.Close();
cliente2.Close();
cliente1EmServidor.Close();
cliente2EmServidor.Close();
#endregion
}
public MensagemModel(Mensagem mensagem)
{
this.Mensagem = mensagem.Texto;
this.Data = mensagem.DataHora;
this.Remetente = mensagem.Iniciador.Id;
}
public bool Finalizar(int id)
{
List <string> lstCadastroVazio = _da.TemCadastroVazio(id);
ProjetoGeografico projetoGeo = new ProjetoGeografico();
Infracao infracao = new Infracao();
LocalInfracao localInfracao = new LocalInfracao();
localInfracao = _localInfracaoDa.Obter(id);
FuncionarioBus funcBus = new FuncionarioBus();
List <Setor> setoresFunc = funcBus.ObterSetoresFuncionario();
if (!setoresFunc.Any(x => x.Id == localInfracao.SetorId))
{
Validacao.Add(Mensagem.Fiscalizacao.SetorNaoPertenceFuncionario);
}
//bool contemProjGeo = !lstCadastroVazio.Contains("Projeto Geografico");
bool contemProjGeo = _da.PossuiProjetoGeo(id);
if (!contemProjGeo && lstCadastroVazio.Exists(x => x.Contains("Projeto Geografico")))
{
lstCadastroVazio.Remove(lstCadastroVazio.First(x => x.Contains("Projeto Geografico")));
}
if (lstCadastroVazio.Count > 0)
{
Validacao.Add(Mensagem.Fiscalizacao.CadastroObrigatorio(Mensagem.Concatenar(lstCadastroVazio)));
return(Validacao.EhValido);
}
if (contemProjGeo)
{
projetoGeo = _projetoGeoDa.ObterProjetoGeograficoPorFiscalizacao(id);
projetoGeo.FiscalizacaoEasting = localInfracao.LonEastingToDecimal;
projetoGeo.FiscalizacaoNorthing = localInfracao.LatNorthingToDecimal;
if (!_projetoGeoDa.VerificarProjetoGeograficoProcessado(projetoGeo.Id))
{
Validacao.Add(Mensagem.Fiscalizacao.ProjetoGeoProcessado);
}
else
{
if (!projetoGeo.FiscalizacaoEstaDentroAreaAbrangencia)
{
Validacao.Add(Mensagem.ProjetoGeografico.EmpreendimentoForaAbrangencia);
}
}
}
infracao = _infracaoDa.Obter(id);
if (_infracaoDa.ConfigAlterada(infracao.ConfiguracaoId, infracao.ConfiguracaoTid))
{
Validacao.Add(Mensagem.InfracaoMsg.ConfigAlteradaConcluir);
}
if (_infracaoDa.PerguntaRespostaAlterada(infracao))
{
Validacao.Add(Mensagem.InfracaoMsg.ConfigAlteradaConcluir);
}
return(Validacao.EhValido);
}
internal Resultados <EmpreendimentoAtividade> Filtrar(Dictionary <string, DadoFiltro> filtros)
{
Resultados <EmpreendimentoAtividade> retorno = new Resultados <EmpreendimentoAtividade>();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia())
{
string comandtxt = string.Empty;
Comando comando = bancoDeDados.CriarComando("");
#region Adicionando Filtros
if (filtros.ContainsKey("secao"))
{
comandtxt += " and upper(secao) like upper(:secao)";
comando.AdicionarParametroEntrada("secao", filtros["secao"].Valor + "%", filtros["secao"].Tipo);
}
if (filtros.ContainsKey("divisao"))
{
comandtxt += " and divisao = :divisao ";
comando.AdicionarParametroEntrada("divisao", filtros["divisao"].Valor, filtros["divisao"].Tipo);
}
if (filtros.ContainsKey("atividade"))
{
comandtxt += " and upper(atividade) like upper(:atividade)";
comando.AdicionarParametroEntrada("atividade", filtros["atividade"].Valor + "%", filtros["atividade"].Tipo);
}
if (filtros.ContainsKey("cnae"))
{
comandtxt += " and upper(cod_cnae) like upper(:cnae)";
comando.AdicionarParametroEntrada("cnae", filtros["cnae"].Valor + "%", filtros["cnae"].Tipo);
}
List <String> ordenar = new List <String>();
List <String> colunas = new List <String>()
{
"cod_cnae", "atividade"
};
if (filtros.ContainsKey("ordenar"))
{
ordenar.Add(filtros["ordenar"].Valor.ToString());
}
else
{
ordenar.Add("cod_cnae");
}
#endregion
#region Quantidade de registro do resultado
comando.DbCommand.CommandText = String.Format("select count(*) from {0}tab_empreendimento_atividade a where a.id > 0" + comandtxt, (string.IsNullOrEmpty(EsquemaBanco) ? "" : "."));
retorno.Quantidade = Convert.ToInt32(bancoDeDados.ExecutarScalar(comando));
if (retorno.Quantidade < 1)
{
Mensagem msgSemRegistros = Mensagem.Funcionario.NaoEncontrouRegistros;
Validacao.Add(msgSemRegistros);
}
if (filtros.ContainsKey("menor"))
{
comando.AdicionarParametroEntrada("menor", filtros["menor"].Valor, filtros["menor"].Tipo);
}
else
{
comando.AdicionarParametroEntrada("menor", 1, DbType.Int32);
}
if (filtros.ContainsKey("maior"))
{
comando.AdicionarParametroEntrada("maior", filtros["maior"].Valor, filtros["maior"].Tipo);
}
else
{
comando.AdicionarParametroEntrada("maior", 10, DbType.Int32);
}
comandtxt = String.Format(@"select a.id, a.secao, a.divisao, a.atividade, a.tid, a.cod_cnae from
{0}tab_empreendimento_atividade a where a.id > 0" + comandtxt + DaHelper.Ordenar(colunas, ordenar), (string.IsNullOrEmpty(EsquemaBanco) ? "" : "."));
comando.DbCommand.CommandText = @"select * from (select a.*, rownum rnum from ( " + comandtxt + @") a) where rnum <= :maior and rnum >= :menor";
#endregion
using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
{
#region Adicionando os dados na classe de retorno
EmpreendimentoAtividade atividade;
while (reader.Read())
{
atividade = new EmpreendimentoAtividade();
atividade.Id = Convert.ToInt32(reader["id"]);
atividade.Secao = reader["secao"].ToString();
atividade.CNAE = reader["cod_cnae"].ToString();
if (reader["divisao"] != null && !Convert.IsDBNull(reader["divisao"]))
{
atividade.Divisao = Convert.ToInt32(reader["divisao"]);
}
atividade.Atividade = reader["atividade"].ToString();
atividade.Tid = reader["tid"].ToString();
retorno.Itens.Add(atividade);
}
reader.Close();
#endregion
}
}
return(retorno);
}
public List <Roteiro> ObterRoteirosPorAtividades(List <Atividade> atividades, BancoDeDados bancoInterno)
{
List <Roteiro> roteiros = new List <Roteiro>();
if (atividades == null || atividades.Count <= 0)
{
return(roteiros);
}
Roteiro roteiroPadrao = ListaCredenciadoBus.RoteiroPadrao.FirstOrDefault(x => x.Setor == atividades[0].SetorId);
if (roteiroPadrao != null)
{
roteiroPadrao = ObterSimplificado(roteiroPadrao.Id, bancoInterno);
}
List <String> titulos = new List <String>();
foreach (var atividade in atividades)
{
foreach (var finalidade in atividade.Finalidades)
{
finalidade.AtividadeId = atividade.Id;
finalidade.AtividadeNome = atividade.NomeAtividade;
finalidade.AtividadeSetorId = atividade.SetorId;
String modeloTituloNaoAdicionadoRoteiro = _da.ModeloTituloNaoAdicionadoRoteiro(finalidade, bancoInterno);
if (!String.IsNullOrWhiteSpace(modeloTituloNaoAdicionadoRoteiro))
{
titulos.Add("\"" + modeloTituloNaoAdicionadoRoteiro + "\"");
continue;
}
Roteiro roteiroAux = _da.ObterRoteirosPorAtividades(finalidade, bancoInterno);
if (roteiroAux == null)
{
roteiroPadrao.AtividadeTexto = atividade.NomeAtividade;
roteiros.Add(roteiroPadrao);
continue;
}
roteiros.Add(roteiroAux);
}
}
if (titulos.Count > 0)
{
Validacao.Add(Mensagem.Roteiro.TituloNaoAdicionadoRoteiroCredenciado(Mensagem.Concatenar(titulos)));
}
#region Faz a magica de agrupar os resultados
roteiros = roteiros.GroupBy(x => x.Id).Select(y => new Roteiro
{
Id = y.First().Id,
Nome = y.First().Nome,
VersaoAtual = y.First().VersaoAtual,
Tid = y.First().Tid,
AtividadeTexto = y.Select(w => w.AtividadeTexto).Distinct().Aggregate((total, atual) => total + " / " + atual)
}).ToList();
#endregion
return(roteiros);
}
public bool Salvar()
{
bool retorno = false;
Usuario usuario = ((principal)this.Master).usuarioLogado;
if (usuario != null)
{
Aluno aluno = new Aluno().SelecionarPorPessoa(usuario.Pessoa);
if (aluno == null)
{
Mensagem.Aviso("Usuário logado não está relacionado a um aluno. Usuário sem acesso!");
}
else
{
if (!cbxConcorda.Checked)
{
Mensagem.Aviso("Para finalizar o cadastro é preciso aceitar os termos da matrícula.");
}
else
{
aluno.Pessoa.Nome = txtNome.Text;
aluno.Sites = cbxSites.Checked;
aluno.Medicar = cbxMedicar.Checked;
Endereco endereco = new Endereco().SelecionarCep(Convert.ToInt32(Comum.RetiraMascaraCEP(txtCep.Text)));
aluno.Pessoa.Endereco = endereco;
if (txtComplemento.Text.Trim() != "")
{
aluno.Pessoa.Complemento = txtComplemento.Text;
}
aluno.Pessoa.Predical = Convert.ToInt32(txtNumero.Text);
if (txtEmail.Text != "")
{
aluno.Pessoa.Email = txtEmail.Text;
}
else
{
aluno.Pessoa.Email = null;
}
if (txtTelefone.Text.Trim() != "")
{
aluno.Pessoa.Telefone = Convert.ToDecimal(Comum.RetiraMascaraTelefone(txtTelefone.Text));
}
else
{
aluno.Pessoa.Telefone = null;
}
aluno.Emergencia = Convert.ToDecimal(Comum.RetiraMascaraTelefone(txtEmergencia.Text));
aluno.Contato = txtFalarCom.Text;
aluno.ConvenioMedico = txtConvenioMedico.Text;
if (txtTelefoneMedico.Text.Trim() != "")
{
aluno.TelefoneConvenio = Convert.ToDecimal(Comum.RetiraMascaraTelefone(txtTelefoneMedico.Text));
}
else
{
aluno.TelefoneConvenio = null;
}
aluno.CarteirinhaConvenio = txtCarteirinha.Text;
aluno.Alergias = txtAlergia.Text;
aluno.Medicamentos = txtMedicamentos.Text;
aluno.Pessoa.Complemento = txtComplemento.Text;
if (aluno.Situacao == "I")
{
aluno.Situacao = "A";
}
try
{
retorno = aluno.Confirmar();
}
catch (Model.Base.GepexException.EBancoDados ex)
{
Mensagem.Aviso(Comum.TraduzirMensagem(ex));
}
catch (Model.Base.GepexException.ERegraNegocio ex)
{
Mensagem.Aviso(ex.Message);
}
catch (Exception ex)
{
throw ex;
}
}
}
}
return(retorno);
}
public void Inserir(Mensagem mensagem)
{
context.Mensagem.Add(mensagem);
context.SaveChanges();
}
/// <summary>
/// Responsável por sinalizar o manager de que foi encerrada a edição de uma tarefa
/// </summary>
/// <param name="oidTarefa">guid da tarefa que estava em edição</param>
public virtual void RnComunicarFimEdicaoTarefa(string oidTarefa)
{
MensagemDto mensagem = Mensagem.RnCriarMensagemFinalizarEdicaoTarefa(oidTarefa, Login, OidCronograma);
RnEnviarMensagem(mensagem);
}
