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);
}
//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");
}
}
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
}
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");
}
}
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");
}
}
// 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");
}
}
// 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");
}
}
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;
}
}
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");
}
}
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);
}
}
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);
}
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;
}
}
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);
}
}
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");
}
}
// 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);
}
}
}
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");
}
}
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");
}
}
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");
}
}
}
// 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);
}
}
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);
}
//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");
}
}
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);
}
}
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;
}
}
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");
}
}
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;
}
}
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);
}
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);
}
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);
}
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");
}
}
}
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/>========== DIÁRIO DE ENTREGA ==========");
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");
}
}