Ejemplo n.º 1
0
        public int Ofertar(List <Produto> estoque) //  Oferecer produtos ao cliente, podendo ele comprar ou não. Add in pedidos
        {
            int valorRam = 0, index, quant;

            try{
                Random rand = new Random();
                System.Threading.Thread.Sleep(50);
                valorRam = (rand.Next(1, 100));
                if ((valorRam <= tendencia) && (estoque.Count > 0))
                {
                    index = valorRam % estoque.Count;
                    quant = valorRam % 50;
                    pedidos.Add(new Produto(
                                    estoque[index].getTipo(),
                                    quant,
                                    estoque[index].getCusto(),
                                    estoque[index].getPeso(),
                                    estoque[index].getVolume()
                                    ));
                    return(2);
                }
            }
            catch (IndexOutOfRangeException e) {
                LogisticaException.ExceptionGrave("LE_IndexOutOfRangeException", e, "Cliente", "Ofertar");
                return(0);
            }
            catch (Exception e) {
                LogisticaException.ExceptionGrave("LE_ExceptionNaoTratada", e, "Cliente", "Ofertar");
                return(0);
            }
            return(1);
        }
Ejemplo n.º 2
0
        //Métodos responsaveis por realizar os GETs
        private void CarregarProdutos()
        {
            string lendo = "";

            try {
                using (Stream FileIn = File.Open(fileProdutos, FileMode.Open)){
                    using (StreamReader Carregar = new StreamReader(FileIn)){
                        do
                        {
                            lendo = Carregar.ReadLine();
                            if (lendo == "--")
                            {
                                produtos.Add(new Produto(
                                                 Carregar.ReadLine(),
                                                 int.Parse(Carregar.ReadLine()),
                                                 double.Parse(Carregar.ReadLine()),
                                                 double.Parse(Carregar.ReadLine()),
                                                 double.Parse(Carregar.ReadLine())
                                                 ));
                                //Console.WriteLine(produtos.Count + lendo); //  TESTE
                            }
                        } while (lendo != null);
                    }
                }
            }
            catch (FileNotFoundException) {} //  Nada a ser feito, o fluxo de dados se corrigirá sozinho
            catch (Exception e) {
                LogisticaException.ExceptionGrave("LE_Save", e, "Save", "CarregarProdutos");
            }
        }
Ejemplo n.º 3
0
 private void GuardarLogException(DadosLogException newException)
 {
     try {
         using (StreamWriter Salvar = File.AppendText(fileLogException)) {
             Salvar.WriteLine("Exceptions inesperada: ");
             Salvar.Write("Classe: ");
             Salvar.WriteLine(newException.classe);
             Salvar.Write("Método: ");
             Salvar.WriteLine(newException.metodo);
             Salvar.Write("Instante: ");
             Salvar.WriteLine(newException.data);
             Salvar.Write("Nota do usuário: ");
             Salvar.WriteLine(newException.nota);
             if (newException.notaAdm.Length > 0)
             {
                 Salvar.WriteLine(newException.notaAdm);
             }
             Salvar.Write("Mensagem:");
             Salvar.WriteLine(newException.mensagem);
             Salvar.Write("\n\n");
         }
     }
     catch (Exception e) {
         LogisticaException.ExceptionGrave("LE_Save_Exception", e, "Save", "GuardarLogException");
     } //IO Exception
 }
Ejemplo n.º 4
0
 private void GuardarClientes()
 {
     try {
         using (StreamWriter Salvar = File.AppendText(fileClientes)) {
             double[] coord = new double[2];
             coord = cli.getCoord();
             Salvar.WriteLine("--");
             Salvar.WriteLine(cli.getId());
             Salvar.WriteLine(cli.getNome());
             Salvar.WriteLine(coord[0]);
             Salvar.WriteLine(coord[1]);
             Salvar.WriteLine(cli.getTendencia());
             foreach (Produto p in pedidos)
             {
                 Salvar.WriteLine("-#");
                 Salvar.WriteLine(p.getTipo());
                 Salvar.WriteLine(p.getQuantidade());
                 Salvar.WriteLine(p.getCusto());
                 Salvar.WriteLine(p.getPeso());
                 Salvar.WriteLine(p.getVolume());
             }
         }
     }
     catch (Exception e) {
         LogisticaException.ExceptionGrave("LE_Save", e, "Save", "GuardarClientes");
     }
 }
Ejemplo n.º 5
0
 private void GuardarEntregas()
 {
     try {
         using (StreamWriter Salvar = File.AppendText(fileEntregas)) {
             foreach (Encomenda e in entregas)
             {
                 Salvar.WriteLine("--");
                 //Salvar.WriteLine(e.getId());
                 Salvar.WriteLine(e.getCliente());
                 Salvar.WriteLine(e.getFrete());
                 Salvar.WriteLine(e.getPrazo());
                 Salvar.WriteLine(e.getDataCompra());
                 foreach (Produto p in e.getPacote())
                 {
                     Salvar.WriteLine("-#");
                     Salvar.WriteLine(p.getTipo());
                     Salvar.WriteLine(p.getQuantidade());
                     Salvar.WriteLine(p.getCusto());
                     Salvar.WriteLine(p.getPeso());
                     Salvar.WriteLine(p.getVolume());
                 }
             }
         }
     }
     catch (Exception e) {
         LogisticaException.ExceptionGrave("LE_Save", e, "Save", "GuardarEntregas");
     }
 }
Ejemplo n.º 6
0
        //  PRODUTOS
        ////////////////////////////////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////////////////////////////////
        //  CLIENTES
        public void NovoCliente(string nome) //  Cadastrar novo cliente para a distribuidora - localização aleatória
        {
            Random rand = new Random();

            List <int> ids = new List <int>();

            ids.Add(0);
            foreach (Cliente c in clientes)
            {
                ids.Add(c.getId());
            }

            try{
                clientes.Add(new Cliente(ids.Max() + 1, nome, rand.Next(-4000, 4000) / 100, rand.Next(-8000, 8000) / 100)); //  Novo cliente
                coord = clientes[clientes.Count - 1].getCoord();
                Console.WriteLine("Novo cliente: {0} - lat: {1}, lon: {2}", nome, coord[0], coord[1]);
                Salvar();
            }
            catch (IndexOutOfRangeException e) {
                LogisticaException.ExceptionGrave("LE_IndexOutOfRangeException", e, "Distribuidora", "NovoCliente");
            }
            catch (Exception e) {
                LogisticaException.ExceptionGrave("LE_ExceptionNaoTratada", e, "Distribuidora", "NovoCliente");
            }
        }
Ejemplo n.º 7
0
        //  CLIENTES
        ////////////////////////////////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////////////////////////////////
        //  ENCOMENDAS
        private void OrganizarEncomendas() //  Ordena a lista de encomendas em ordem decrescente por lucratividade, considerando preço, volume e peso
        {
            int[]            auxIndex = new int[encomendas.Count];
            List <double>    coefMon  = new List <double>();
            List <Encomenda> auxEnc   = new List <Encomenda>();

            try{
                foreach (Encomenda e in encomendas)
                {
                    coefMon.Add((((e.getPreco() - e.getFrete()) / e.getPesoEnc() / 0) / (e.getVolumeEnc())) * 1000);
                }
                for (int i = 0; i < encomendas.Count; i++)
                {
                    auxIndex[i] = coefMon.IndexOf(coefMon.Max());
                    coefMon[coefMon.IndexOf(coefMon.Max())] = -1;
                }
                for (int i = 0; i < encomendas.Count; i++)
                {
                    auxEnc.Add(encomendas[auxIndex[i]]);
                }
                encomendas.Clear();
                encomendas.AddRange(auxEnc);
            }
            catch (DivideByZeroException e) {
                LogisticaException.ExceptionGrave("LE_DivideByZeroException", e, "Distribuidora", "OrganizarEncomendas");
            }
            catch (IndexOutOfRangeException e) {
                LogisticaException.ExceptionGrave("LE_IndexOutOfRangeException", e, "Distribuidora", "OrganizarEncomendas");
            }
            catch (Exception e) {
                LogisticaException.ExceptionGrave("LE_ExceptionNaoTratada", e, "Distribuidora", "OrganizarEncomendas");
            }
        }
Ejemplo n.º 8
0
 private void AtualizarMapa(bool sentido = false)
 {
     try {
         if (sentido)
         {
             for (int i = 0; i < maxLat * 2; i++)
             {
                 for (int j = 0; j < maxLon * 2; j++)
                 {
                     mapa2[i, j] = mapa[i, j];
                 }
             }
         }
         else
         {
             for (int i = 0; i < maxLat * 2; i++)
             {
                 for (int j = 0; j < maxLon * 2; j++)
                 {
                     mapa[i, j] = mapa2[i, j];
                 }
             }
         }
     }
     catch (IndexOutOfRangeException e) {
         LogisticaException.ExceptionGrave("LE_IndexOutOfRangeException", e, "Mapeamento", "AtualizarMapa");
         Distribuidora.statusMapeamento = false;
     }
     catch (Exception e) {
         LogisticaException.ExceptionGrave("LE_ExceptionNaoTratada", e, "Mapeamento", "AtualizarMapa");
         Distribuidora.statusMapeamento = false;
     }
 }
Ejemplo n.º 9
0
 public void Reset() //  Apagar todos os dados de todos os arquivos de armazenamento
 {
     try {
         System.Threading.Thread.Sleep(5);
         System.IO.File.Delete(fileProdutos);
         System.IO.File.Delete(fileEncomendas);
         System.IO.File.Delete(fileEntregas);
         System.IO.File.Delete(fileClientes);
         System.IO.File.Delete(fileRelatorio);
         CheckArquivo();
         Console.WriteLine("\nDados salvos apagados\n");
     }
     catch (FileNotFoundException) {} //  Nada a ser feito, o fluxo de dados se corrigirá sozinho
     catch (Exception e) {
         LogisticaException.ExceptionGrave("LE_Save", e, "Save", "Reset");
     }
     finally {
         CheckArquivo();
         System.Threading.Thread.Sleep(5);
         System.IO.File.Delete(fileProdutos);
         System.IO.File.Delete(fileEncomendas);
         System.IO.File.Delete(fileEntregas);
         System.IO.File.Delete(fileClientes);
         System.IO.File.Delete(fileRelatorio);
         CheckArquivo();
         Console.WriteLine("\nDados salvos apagados\n");
     }
 }
Ejemplo n.º 10
0
        private void NovoRelatorioEntrega(DadosLog dados, List <Cliente> CliEntrega) //  Cria um pacote de dados para gerar o relatório de entregas
        {
            List <int>       idClientes = new List <int>();
            List <int>       pacote     = new List <int>();
            List <Encomenda> auxEnc     = new List <Encomenda>();
            List <Cliente>   cliAux     = new List <Cliente>();
            string           posicao    = "";

            try {
                posicao = "for(CliEntrega)";
                for (int i = 0; i < CliEntrega.Count; i++)
                {
                    idClientes.Add(CliEntrega[dados.rota[i]].getId());
                }

                posicao = "foreach(encomendas)";
                foreach (Encomenda e in encomendas)
                {
                    if (idClientes.IndexOf(e.getCliente()) != -1)
                    {
                        pacote.Add(e.getId());
                        auxEnc.Add(e);
                    }
                }

                posicao = "foreach(auxEnc)";
                foreach (Encomenda e in auxEnc)
                {
                    encomendas.Remove(e);
                    e.setStatusEntrega(true);
                }
                entregas.AddRange(auxEnc);

                posicao = "foreach(dados.rota)";
                foreach (int r in dados.rota)
                {
                    cliAux.Add(CliEntrega[r]);
                }
                dados.cliOrdem = cliAux;

                posicao = "salvar";
                Salvar();

                posicao        = "diarioEntregas";
                diarioEntregas = new Relatorio(idClientes, pacote, dados.distancia, dados.custo, dados.lucro);
                Console.WriteLine("Novo relatório de entrega gerado.\n");
            }
            catch (IndexOutOfRangeException e) {
                LogisticaException.ExceptionGrave("LE_IndexOutOfRangeException", e, "Distribuidora", "NovoRelatorioEntrega/" + posicao);
            }
            catch (ArgumentNullException e) {
                LogisticaException.ExceptionGrave("LE_Distribuidora_NovoRelatorioEntrega_DiarioEntrega", e, "Distribuidora", "NovoRelatorioEntrega/" + posicao, true);
            }
            catch (Exception e) {
                LogisticaException.ExceptionGrave("LE_ExceptionNaoTratada", e, "Distribuidora", "NovoRelatorioEntrega/" + posicao);
            }
        }
Ejemplo n.º 11
0
        public List <Produto> Vender(List <Produto> estoque) //  Retorna o Encomenda.pacote
        {
            List <Produto> pacote = new List <Produto>();
            bool           venda = false, run;

            try {
                if (checkPedidos())
                {
                    foreach (Produto e in estoque) //  Validar os pedidos pelo estoque da Distribuidora
                    {
                        do
                        {
                            run = false;
                            for (int i = 0; i < pedidos.Count; i++) //  Registrar pedidos
                            {
                                if ((pedidos[i].getTipo() == e.getTipo()) && (pedidos[i].getQuantidade() <= e.getQuantidade()))
                                {
                                    pacote.Add(new Produto(
                                                   pedidos[i].getTipo(),
                                                   pedidos[i].getQuantidade(),
                                                   pedidos[i].getCusto(),
                                                   pedidos[i].getPeso(),
                                                   pedidos[i].getVolume()
                                                   ));
                                    e.downQuant(pedidos[i].getQuantidade());
                                    pedidos.RemoveAt(i);
                                    i--;
                                    run   = true;
                                    venda = true;
                                }
                                else if (pedidos[i].getTipo() == e.getTipo())
                                {
                                    Console.WriteLine("Produto não encontrado ou em falta ao vender: {0} - {1} - cli-ven", e.getTipo(), e.getQuantidade());
                                }
                            }
                        } while(run);
                    }
                    if (venda)
                    {
                        Console.WriteLine("Pedido aceito. Cliente: {0}", nome);
                    }
                }
            }
            catch (IndexOutOfRangeException e) {
                LogisticaException.ExceptionGrave("LE_IndexOutOfRangeException", e, "Cliente", "Vender");
            }
            catch (Exception e) {
                LogisticaException.ExceptionGrave("LE_ExceptionNaoTratada", e, "Cliente", "Vender");
            }

            return(pacote);
        }
Ejemplo n.º 12
0
        public static void CadastarProduto()
        {
            while (true)
            {
                Console.WriteLine("\nInforme os seguintes dados do novo produto:");
                Console.Write("\nNome: ");

                try{
                    string nome = Console.ReadLine();
                    if (nome.Length == 0)
                    {
                        throw new LogisticaException("LE_Main_NovoProdutoNomeVazio");
                    }
                    Console.Write("Preço de custo R$: ");
                    double custo = double.Parse(Console.ReadLine());
                    Console.Write("Peso em Kg: ");
                    double peso = double.Parse(Console.ReadLine());
                    Console.Write("Volume em metro cúbico: ");
                    double volume = double.Parse(Console.ReadLine());

                    if (mercado.NovoProduto(nome, custo, peso, volume) == true)
                    {
                        Console.WriteLine("\nProduto Cadastrado com Sucesso!\n");
                        break;
                    }
                    else
                    {
                        throw new LogisticaException("LE_Main_NovoProdutoNomeDuplicado");
                    }
                }
                catch (FormatException) {
                    Console.WriteLine("\nValor invalido detectado");
                }
                catch (LogisticaException) {}
                catch (Exception e) {
                    LogisticaException.ExceptionGrave("LE_ExceptionNaoTratada", e, "Main", "CadastarProduto", true);
                }

                Console.Write("\nDeseja Cadastrar outro Produto?(y/n)\n>>  ");
                if (Console.ReadLine().ToUpper() == "Y")
                {
                    Console.Clear();
                    Console.WriteLine(titulo);
                    CadastarProduto();
                }
                else
                {
                    Console.WriteLine("Fim da operação\n");
                }
                break;
            }
        }
Ejemplo n.º 13
0
        public bool ComprarProduto(string tipo, int n) //  Abastecer o estoque dos produtos cadastrados
        {
            bool prod = false, renda = false;

            try{
                foreach (Produto p in produtos) //  Buscar pelo produto solicitado
                {
                    if (tipo.ToUpper() == p.getTipo().ToUpper())
                    {
                        if ((carteira >= n * p.getCusto()) || carteiraInf)
                        {
                            p.upQuant(n); //  Atualizar estoque referente a compra dos produtos
                            if (!carteiraInf)
                            {
                                carteira -= n * p.getCusto();
                            }
                            renda = true;
                        }
                        else
                        {
                            Console.WriteLine("\nNão há renda suficiente: dis-ComPro");
                        }
                        prod = true;
                        break;
                    }
                }

                if (renda && prod) //  Relatórios de ação para o usuário
                {
                    Console.WriteLine("\nEstoque reabastecido");
                    Salvar();
                    return(true);
                }
                else if (!prod)
                {
                    Console.WriteLine("\nProduto não encontrado");
                    return(false);
                }
                else
                {
                    Console.WriteLine("\nVerba insuficiente");
                    return(false);
                }
            }
            catch (Exception e) {
                LogisticaException.ExceptionGrave("LE_ExceptionNaoTratada", e, "Distribuidora", "ComprarProduto");
                return(false);
            }
        }
Ejemplo n.º 14
0
        public void Vender() //  Aceitar pedidos realizados pelos clientes
        {
            List <Produto> pacote = new List <Produto>();
            List <int>     ids    = new List <int>();
            bool           venda  = false;

            try{
                foreach (Cliente c in clientes) //  O processo é realizado pra cada cliente individualmente
                {
                    pacote.Clear();
                    pacote.AddRange(c.Vender(produtos));

                    if (pacote.Count > 0)
                    {
                        double[] coord = new double[2];
                        coord = c.getCoord();
                        double frete = Caminhao.CalcularDistancia(0, coord[0], 0, coord[1]) * 0.60;
                        int    dist  = (int)(Caminhao.CalcularDistancia(0, coord[0], 0, coord[1]) * 0.60);
                        ids.Clear();
                        ids.Add(0);
                        foreach (Encomenda e in encomendas)
                        {
                            ids.Add(e.getId());
                        }
                        encomendas.Add(new Encomenda(ids.Max() + 1, pacote, getClientes(c.getNome()), coefLucro, frete, dist));
                        DownEstoque(pacote); // abater do estoque o que foi vendido
                        venda = true;
                    }
                }
                if (venda)
                {
                    //OrganizarEncomendas(); //  Otimizar encomendas, organizando em ordem decrescente por lucratividade
                    Salvar();
                    Console.WriteLine("Pedidos aceitos!\nEncomendas geradas!\n");
                }
                else
                {
                    Console.WriteLine("Não há pedidos pendentes\n");
                }
            }
            catch (IndexOutOfRangeException e) {
                LogisticaException.ExceptionGrave("LE_IndexOutOfRangeException", e, "Distribuidora", "Vender");
            }
            catch (Exception e) {
                LogisticaException.ExceptionGrave("LE_ExceptionNaoTratada", e, "Distribuidora", "Vender");
            }
        }
Ejemplo n.º 15
0
        //  MÉTODOS OPERACIONAIS
        ////////////////////////////////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////////////////////////////////
        //  MÉTODOS ADMINISTRATIVOS
        public static void CadastarCliente()
        {
            while (true)
            {
                try {
                    Console.Write("\nInforme o nome do cliente\nNome: ");
                    string nome = Console.ReadLine();

                    if (mercado.getClientes(nome) == -1)
                    {
                        if (nome.Length < 5)
                        {
                            throw new LogisticaException("LE_Main_NovoClienteNomeVazio");
                        }
                        else
                        {
                            mercado.NovoCliente(nome);
                            Console.WriteLine("Cliente Cadastrado com Sucesso!\n");
                            break;
                        }
                    }
                    else
                    {
                        throw new LogisticaException("LE_Main_NovoClienteNomeDuplicado");
                    }
                }
                catch (LogisticaException) {
                    Console.Write("\nDeseja Cadastrar outro cliente? (y/n):\n>> ");
                    if (Console.ReadLine().ToUpper() == "Y")
                    {
                        Console.Clear();
                        Console.WriteLine(titulo);
                        CadastarCliente();
                    }
                    else
                    {
                        Console.WriteLine("Fim da operação\n");
                    }
                    break;
                }
                catch (Exception e) {
                    LogisticaException.ExceptionGrave("LE_ExceptionNaoTratada", e, "Main", "CadastarCliente", true);
                }
            }
        }
Ejemplo n.º 16
0
 private void GuardarRelatorio(DadosLog dados)
 {
     try {
         using (StreamWriter Salvar = File.AppendText(fileRelatorio)) {
             foreach (string r in dados.relatorio)
             {
                 Salvar.Write(r);
             }
             foreach (string m in dados.mapa)
             {
                 Salvar.Write(m);
             }
         }
     }
     catch (Exception e) {
         LogisticaException.ExceptionGrave("LE_Save", e, "Save", "GuardarRelatorio");
     }
 }
Ejemplo n.º 17
0
        private void CarregarEntregas()
        {
            string lendo = "", data = "";
            int    id = 0, prazo = 0, cliente = 0;
            double frete = 0;

            try {
                using (Stream FileIn = File.Open(fileEntregas, FileMode.Open)){
                    using (StreamReader Carregar = new StreamReader(FileIn)){
                        lendo = Carregar.ReadLine();
                        do
                        {
                            List <Produto> produtosEn = new List <Produto>();
                            if (lendo == "--")
                            {
                                id      = int.Parse(Carregar.ReadLine());
                                cliente = int.Parse(Carregar.ReadLine());
                                frete   = double.Parse(Carregar.ReadLine());
                                prazo   = int.Parse(Carregar.ReadLine());
                                data    = Carregar.ReadLine();
                                lendo   = Carregar.ReadLine();

                                while (lendo == "-#")
                                {
                                    produtosEn.Add(
                                        new Produto(Carregar.ReadLine(),
                                                    int.Parse(Carregar.ReadLine()),
                                                    double.Parse(Carregar.ReadLine()),
                                                    double.Parse(Carregar.ReadLine()),
                                                    double.Parse(Carregar.ReadLine())
                                                    ));
                                    lendo = Carregar.ReadLine();
                                }
                                entregas.Add(new Encomenda(id, produtosEn, cliente, 0, frete, prazo, data));
                            }
                        } while (lendo != null);
                    }
                }
            }
            catch (FileNotFoundException) {} //  Nada a ser feito, o fluxo de dados se corrigirá sozinho
            catch (Exception e) {
                LogisticaException.ExceptionGrave("LE_Save", e, "Save", "CarregarEntregas");
            }
        }
Ejemplo n.º 18
0
 public void ListarProdutos() //  Mostrar ao usuário uma lista dos produtos cadastradod
 {
     if (produtos.Count == 0)
     {
         Console.WriteLine("Nenhum produto cadastrado\n");
     }
     else
     {
         try {
             foreach (Produto p in produtos)
             {
                 Console.WriteLine("{0}  |  {1}un  |  {2}kg |  {3}m^3", p.getTipo(), p.getQuantidade(), p.getPeso(), p.getVolume());
             }
         }
         catch (Exception e) {
             LogisticaException.ExceptionGrave("LE_ExceptionNaoTratada", e, "Distribuidora", "ListarProdutos");
         }
     }
 }
Ejemplo n.º 19
0
        //  ARMAZENAMENTO DE DADOS
        ////////////////////////////////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////////////////////////////////
        //  PRODUTOS
        public bool NovoProduto(string tipo, double custo, double peso, double volume) //  Produtos oferecidos pela distribuidora
        {
            try {
                foreach (Produto p in produtos)
                {
                    if (p.getTipo() == tipo)
                    {
                        return(false);
                    }
                }
                produtos.Add(new Produto(tipo, 5000, custo, double.Parse(Console.ReadLine()), volume));
                Salvar();
                return(true);
            }
            catch (Exception e) {
                LogisticaException.ExceptionGrave("LE_ExceptionNaoTratada", e, "Distribuidora", "NovoProduto");
                return(false);
            }
        }
Ejemplo n.º 20
0
        private string CarregarSenhas()
        {
            string senha = "";

            try {
                using (Stream FileIn = File.Open(fileSenhas, FileMode.Open)){
                    using (StreamReader Carregar = new StreamReader(FileIn)){
                        senha = Carregar.ReadLine();
                    }
                }
            }
            catch (NullReferenceException) { LogisticaException.ExceptionGrave("LE_Save_SenhaNaoEncontrada"); }
            catch (LogisticaException) {}
            catch (FileNotFoundException) {} //  Nada a ser feito, o fluxo de dados se corrigirá sozinho
            catch (Exception e) {
                LogisticaException.ExceptionGrave("LE_Save", e, "Save", "CarregarProdutos");
            }

            return(senha);
        }
Ejemplo n.º 21
0
 //Métodos responsaveis por realizar os SETs
 private void GuardarProdutos()
 {
     try {
         System.IO.File.Delete(fileProdutos);
         using (StreamWriter Salvar = File.AppendText(fileProdutos)) {
             foreach (Produto p in produtos)
             {
                 Salvar.WriteLine("--");
                 Salvar.WriteLine(p.getTipo());
                 Salvar.WriteLine(p.getQuantidade());
                 Salvar.WriteLine(p.getCusto());
                 Salvar.WriteLine(p.getPeso());
                 Salvar.WriteLine(p.getVolume());
             }
         }
     }
     catch (Exception e) {
         LogisticaException.ExceptionGrave("LE_Save", e, "Save", "GuardarProdutos");
     }
 }
Ejemplo n.º 22
0
 private bool DownEstoque(List <Produto> pacote) // abater do estoque o que foi vendido
 {
     try{
         foreach (Produto pac in pacote)
         {
             foreach (Produto pro in produtos)
             {
                 if (pac.getTipo() == pro.getTipo())
                 {
                     pro.downQuant(pac.getQuantidade());
                 }
             }
         }
         Salvar();
         return(true);
     }
     catch (Exception e) {
         LogisticaException.ExceptionGrave("LE_ExceptionNaoTratada", e, "Distribuidora", "DownEstoque");
         return(false);
     }
 }
Ejemplo n.º 23
0
        public static void CalcularViagen()
        {
            while (true)
            {
                Console.Write("\nQuantos containers deseja acoplar ao caminhão?\n>> ");
                try{
                    int containers = int.Parse(Console.ReadLine());
                    if (containers > 3)
                    {
                        throw new LogisticaException("LE_Main_LimiteContainers");
                    }
                    else
                    {
                        mercado.ComoViajar(containers);
                        break;
                    }
                }
                catch (LogisticaException) {}
                catch (FormatException) {
                    Console.WriteLine("\nValor invalido");
                }
                catch (Exception e) {
                    LogisticaException.ExceptionGrave("LE_ExceptionNaoTratada", e, "Main", "CalcularViagen");
                }

                Console.Write("\nDeseja tentar denovo?(y/n)\n>>  ");
                if (Console.ReadLine().ToUpper() == "Y")
                {
                    Console.Clear();
                    Console.WriteLine(titulo);
                    CalcularViagen();
                }
                else
                {
                    Console.WriteLine("Fim da operação\n");
                }
                break;
            }
        }
Ejemplo n.º 24
0
        public void Ofertar() //  Oferecer ao cliente os produtos, há operações randomicas envolvidas
        {
            bool compra = false, sucesso = false;
            int  oferta = 0;

            try{
                foreach (Cliente c in clientes)
                {
                    oferta = c.Ofertar(produtos);
                    compra = false;
                    if (oferta == 0)
                    {
                        Console.WriteLine("Erro ao ofertar produtos: dis-ofe");
                    }
                    else if (oferta == 2)
                    {
                        compra  = true;
                        sucesso = true;
                    }
                    if (compra)
                    {
                        Console.WriteLine("Cliente {0} comprou", c.getNome());
                    }
                }
            }
            catch (Exception e) {
                LogisticaException.ExceptionGrave("LE_ExceptionNaoTratada", e, "Distribuidora", "Ofertar");
            }

            if (sucesso)
            {
                Salvar();
                Console.WriteLine("Pedidos anotados!\n");
            }
            else
            {
                Console.WriteLine("Não houve novos pedidos\n");
            }
        }
Ejemplo n.º 25
0
        public static void ComprarProdutos()
        {
            while (true)
            {
                string nome = "";

                try{
                    Console.WriteLine("\nInforme os seguintes dados:");
                    Console.Write("\nNome: ");
                    nome = Console.ReadLine();
                    Console.Write("Quantidade: ");

                    int quant = int.Parse(Console.ReadLine());
                    if (mercado.ComprarProduto(nome, quant))
                    {
                    }
                }
                catch (FormatException) {
                    Console.WriteLine("\nQuantidade não aceita\n");
                }
                catch (Exception e) {
                    LogisticaException.ExceptionGrave("LE_ExceptionNaoTratada", e, "Main", "ComprarProdutos");
                }

                Console.Write("\nDeseja continuar comprando?(y/n)\n>>  ");
                if (Console.ReadLine().ToUpper() == "Y")
                {
                    Console.Clear();
                    Console.WriteLine(titulo);
                    ComprarProdutos();
                }
                else
                {
                    Console.WriteLine("Fim da operação\n");
                }
                break;
            }
        }
Ejemplo n.º 26
0
        private double CalcularDistanciaRota()
        {
            double dist     = 0;
            int    auxIndex = 0;

            AtualizarCliId();
            try {
                foreach (Posicao c in cliCheck)
                {
                    auxIndex = cliId.IndexOf(c.getIdDe());
                    dist    += c.getDist(cliCheck[auxIndex].getLat(), cliCheck[auxIndex].getLon());
                }
            }
            catch (IndexOutOfRangeException e) {
                LogisticaException.ExceptionGrave("LE_IndexOutOfRangeException", e, "Mapeamento", "CalcularDistanciaRota");
                Distribuidora.statusMapeamento = false;
            }
            catch (Exception e) {
                LogisticaException.ExceptionGrave("LE_ExceptionNaoTratada", e, "Mapeamento", "CalcularDistanciaRota");
                Distribuidora.statusMapeamento = false;
            }

            return(dist);
        }
Ejemplo n.º 27
0
        public bool SendEmailMessage(EmailMessage message)
        {
            var success = false;

            try
            {
                var smtp = new SmtpClient
                {
                    Host                  = _config.Host,
                    Port                  = _config.Port,
                    EnableSsl             = _config.Ssl,
                    DeliveryMethod        = SmtpDeliveryMethod.Network,
                    UseDefaultCredentials = false,
                    Credentials           = new NetworkCredential(_config.Username, _config.Password)
                };
                using (var smtpMessage = new MailMessage(_config.Username, message.ToEmail))
                {
                    smtpMessage.Subject    = message.Subject;
                    smtpMessage.Body       = message.Body;
                    smtpMessage.IsBodyHtml = message.IsHtml;
                    smtp.Send(smtpMessage);
                }
                success = true;
                Console.Write("\nEmail enviado\n");
            }
            catch (SmtpException) {
                LogisticaException.ExceptionGrave("LE_Save_SenhaNaoEncontrada");
                return(false);
            }
            catch (Exception e) {
                LogisticaException.ExceptionGrave("LE_EMail", e, "EMail", "EnviarEmail/SendEmailMessage");
                Console.Write("\nFalha no envio\n");
                return(false);
            }
            return(success);
        }
Ejemplo n.º 28
0
        private int[] getRota()
        {
            int origem = cliId.IndexOf(indexOrigem);
            int alvoAt = origem, i = 0;

            int[] rota = new int[range];

            AtualizarCliId();

            try {
                while (true)
                {
                    alvoAt = cliCheck[alvoAt].getIdDe();
                    if (cliId.IndexOf(alvoAt) != origem)
                    {
                        rota[i] = alvoAt - 1;
                    }
                    else
                    {
                        break;
                    }
                    alvoAt = cliId.IndexOf(alvoAt);
                    i++;
                }
            }
            catch (IndexOutOfRangeException e) {
                LogisticaException.ExceptionGrave("LE_IndexOutOfRangeException", e, "Mapeamento", "getRota");
                Distribuidora.statusMapeamento = false;
            }
            catch (Exception e) {
                LogisticaException.ExceptionGrave("LE_ExceptionNaoTratada", e, "Mapeamento", "getRota");
                Distribuidora.statusMapeamento = false;
            }

            return(rota);
        }
Ejemplo n.º 29
0
 public void setClientes(List <Cliente> c)
 {
     double[] coord = new double[2];
     if (c.Count > 0)
     {
         System.IO.File.Delete(fileClientes);
         CheckArquivo();
         System.Threading.Thread.Sleep(5);
         try {
             foreach (Cliente cl in c)
             {
                 coord = cl.getCoord();
                 cli   = new Cliente(cl.getId(), cl.getNome(), coord[0], coord[1], cl.getTendencia());
                 pedidos.Clear();
                 pedidos.AddRange(cl.getPedidos());
                 System.Threading.Thread.Sleep(1);
                 GuardarClientes();
             }
         }
         catch (Exception e) {
             LogisticaException.ExceptionGrave("LE_Save", e, "Save", "setClientes");
         }
     }
 }
Ejemplo n.º 30
0
        public void GerarRelatório(DadosLog dados)
        {
            List <string> impressao    = new List <string>();
            List <string> impressaoWeb = new List <string>();
            List <int>    idEnt        = new List <int>();
            List <int>    idCli        = new List <int>();

            int[] memoria = new int[2] {
                -1, -1
            };

            try {
                if (diarioEntregas.getClientes().Count > 0)
                {
                    foreach (Encomenda e in entregas)
                    {
                        idEnt.Add(e.getId());
                    }
                    foreach (Cliente c in clientes)
                    {
                        idCli.Add(c.getId());
                    }

                    impressao.Add("\n==========  DIÁRIO  DE  ENTREGA  ==========");
                    impressaoWeb.Add("<br/>==========&nbsp;&nbsp;DIÁRIO&nbsp;&nbsp;DE&nbsp;&nbsp;ENTREGA&nbsp;&nbsp;==========");

                    System.Threading.Thread.Sleep(20);
                    foreach (int c in diarioEntregas.getClientes())
                    {
                        if (memoria[1] != c)
                        {
                            if ((idCli.IndexOf(c) < 0) || (idCli.IndexOf(c) >= clientes.Count))
                            {
                                throw new LogisticaException("LE_Distribuidora_GerarRelatório_indexClientes");
                            }
                            double[] auxCoord = clientes[idCli.IndexOf(c)].getCoord();
                            impressao.Add("\n\nCliente: ");
                            impressaoWeb.Add("<br/><br/>Cliente: ");
                            impressao.Add(String.Format("{0}", clientes[idCli.IndexOf(c)].getNome()));
                            impressaoWeb.Add(String.Format("{0}", clientes[idCli.IndexOf(c)].getNome()));
                            impressao.Add(" - ID: ");
                            impressaoWeb.Add(" - ID: ");
                            impressao.Add(String.Format("{0}", clientes[idCli.IndexOf(c)].getId()));
                            impressaoWeb.Add(String.Format("{0}", clientes[idCli.IndexOf(c)].getId()));
                            impressao.Add(" | lat ");
                            impressaoWeb.Add(" | lat ");
                            impressao.Add(String.Format("{0}", auxCoord[0]));
                            impressaoWeb.Add(String.Format("{0}", auxCoord[0]));
                            impressao.Add(" - lon ");
                            impressaoWeb.Add(" - lon ");
                            impressao.Add(String.Format("{0}", auxCoord[1]));
                            impressaoWeb.Add(String.Format("{0}", auxCoord[1]));

                            foreach (int e in diarioEntregas.getEntregas())
                            {
                                System.Threading.Thread.Sleep(20);
                                if ((idEnt.IndexOf(e) >= 0) && (entregas[idEnt.IndexOf(e)].getCliente() == c))
                                {
                                    impressao.Add("\nLote ID: ");
                                    impressaoWeb.Add("<br/>Lote ID: ");
                                    impressao.Add(String.Format("{0}", e));
                                    impressaoWeb.Add(String.Format("{0}", e));

                                    foreach (Produto p in entregas[idEnt.IndexOf(e)].getPacote())
                                    {
                                        System.Threading.Thread.Sleep(20);
                                        impressao.Add("\nProduto: ");
                                        impressaoWeb.Add("<br/>Produto: ");
                                        impressao.Add(String.Format("{0}", p.getTipo()));
                                        impressaoWeb.Add(String.Format("{0}", p.getTipo()));
                                        impressao.Add(" | quant: ");
                                        impressaoWeb.Add(" | quant: ");
                                        impressao.Add(String.Format("{0}", p.getQuantidade()));
                                        impressaoWeb.Add(String.Format("{0}", p.getQuantidade()));
                                        impressao.Add(" - preço: ");
                                        impressaoWeb.Add(" - preço: ");
                                        impressao.Add(String.Format("{0}", p.getCusto() * p.getQuantidade()));
                                        impressaoWeb.Add(String.Format("{0}", p.getCusto() * p.getQuantidade()));
                                        impressao.Add(" - peso: ");
                                        impressaoWeb.Add(" - peso: ");
                                        impressao.Add(String.Format("{0}", p.getPeso() * p.getQuantidade()));
                                        impressaoWeb.Add(String.Format("{0}", p.getPeso() * p.getQuantidade()));
                                        impressao.Add(" - vol: ");
                                        impressaoWeb.Add(" - vol: ");
                                        impressao.Add(String.Format("{0}", p.getVolume() * p.getQuantidade()));
                                        impressaoWeb.Add(String.Format("{0}", p.getVolume() * p.getQuantidade()));
                                    }
                                }
                            }
                        }
                        memoria[1] = c;
                    }
                    impressao.Add("\n\nPeso Total: ");
                    impressaoWeb.Add("<br/><br/>Peso Total: ");
                    impressao.Add(String.Format("{0:0.00}", dados.peso));
                    impressaoWeb.Add(String.Format("{0:0.00}", dados.peso));
                    impressao.Add(" kg  | ");
                    impressaoWeb.Add(" kg  | ");
                    impressao.Add(String.Format("{0:0.00}", Caminhao.pesoPercent(dados.peso, dados.containers)));
                    impressaoWeb.Add(String.Format("{0:0.00}", Caminhao.pesoPercent(dados.peso, dados.containers)));

                    impressao.Add("%\nVolume Total: ");
                    impressaoWeb.Add("<br/><br/>Volume Total: ");
                    impressao.Add(String.Format("{0:0.00}", dados.volume));
                    impressaoWeb.Add(String.Format("{0:0.00}", dados.volume));
                    impressao.Add(" m^3  | ");
                    impressaoWeb.Add(" m^3  | ");
                    impressao.Add(String.Format("{0:0.00}", Caminhao.volumePercent(dados.volume, dados.containers)));
                    impressaoWeb.Add(String.Format("{0:0.00}", Caminhao.volumePercent(dados.volume, dados.containers)));

                    impressao.Add("%\nDistância: ");
                    impressaoWeb.Add("<br/><br/>Distância: ");
                    impressao.Add(String.Format("{0:0.00}", diarioEntregas.getDistancia()));
                    impressaoWeb.Add(String.Format("{0:0.00}", diarioEntregas.getDistancia()));
                    impressao.Add("km\nCusto total da viagem: R$:");
                    impressaoWeb.Add("km<br/>Custo total da viagem: R$:");
                    impressao.Add(String.Format("{0:0.00}", diarioEntregas.getCusto()));
                    impressaoWeb.Add(String.Format("{0:0.00}", diarioEntregas.getCusto()));
                    impressao.Add("\nLucro total liquido: R$:");
                    impressaoWeb.Add("<br/>Lucro total liquido: R$:");
                    impressao.Add(String.Format("{0:0.00}", diarioEntregas.getLucro()));
                    impressaoWeb.Add(String.Format("{0:0.00}", diarioEntregas.getLucro()));
                    impressao.Add("\n");
                    impressaoWeb.Add("<br/>");
                }
                else
                {
                    Console.WriteLine("Não há relatório a relatar");
                }

                dados.relatorio    = impressao;
                dados.relatorioWeb = impressaoWeb;
                file.setRelatorio(dados);
                Console.WriteLine("Relatório Impresso!\n");
            }
            catch (LogisticaException) {}
            catch (Exception e) {
                LogisticaException.ExceptionGrave("LE_ExceptionNaoTratada", e, "Distribuidora", "GerarRelatório");
            }
        }