private async Task ValidarNovaEncomenda(Encomenda encomenda)
{
if (!await _empresaService.ExistePontoRetirada(encomenda.PontoRetiradaId))
{
throw new RecebaFacilException("Ponto de Retirada inválido");
}
if (!await _empresaService.ExistePontoVenda(encomenda.PontoVendaId))
{
throw new RecebaFacilException("Ponto de Venda inválido");
}
if (DateTime.Now.CompareTo(encomenda.DataPedido) < 0)
{
throw new RecebaFacilException("Data do pedido inválida");
}
if (string.IsNullOrWhiteSpace(encomenda.NumeroPedido))
{
throw new RecebaFacilException("Número do pedido é obrigatório");
}
if (await _repositoryEncomenda.Existe(x => x.NumeroPedido == encomenda.NumeroPedido))
{
throw new RecebaFacilException($"Já existe uma encomenda com este número de pedido: {encomenda.NumeroPedido}");
}
}
/// <summary>
/// Generates order details for a given order
/// </summary>
/// <param name="idCliente">Unique identifier for a client</param>
/// <param name="idEncomenda">Unique identifier for a single order</param>
public void GerarFatura(int idCliente, int idEncomenda)
{
Cliente cliente = _context.Clientes.Find(idCliente);
Encomenda enc = _context.Encomendas.Find(idEncomenda);
enc.gerarFatura(cliente);
}
//GET: EncomendaProduto
public ActionResult Index()
{
Encomenda encomenda = getStandBy();
var ehp = encomenda.Encomenda_has_Produto;
return(View(ehp));
}
public ActionResult RecusarEncomenda(int?idEnc)
{
if (!User.Identity.IsAuthenticated)
{
return(RedirectToAction("Index", "Autenticacao"));
}
if (idEnc == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Encomenda encomenda = db.Encomendas.Find(idEnc);
if (encomenda == null)
{
return(HttpNotFound());
}
//remoçºao da encomenda em si
db.Encomendas.Remove(encomenda);
//remoçºao de todas as entradas associadas à encomenda a remover
var enc_rem = db.Encomenda_Produto.Where(e => e.idEnc == idEnc).ToList();
foreach (var m in enc_rem)
{
db.Encomenda_Produto.Remove(m);
}
db.SaveChanges();
return(RedirectToAction("Ocasionais"));
}
/// <summary>
/// choose an employee to deliver the order with id idEncomenda with destino(destiny) adress
/// </summary>
/// <param name="idEncomenda"></param>
/// <param name="destino"></param>
/// <returns>return the id of Funcionario(employee) choosen</returns>
public int DelegarFuncionario(int idEncomenda, string destino)
{
int idResp = -1;
int nEncResp = 0;
int nRespT = Int32.MaxValue;
int dZona = GetZona(destino);
List <Utilizador> utilizadores = _context.Utilizadores.ToList();
foreach (Utilizador utilizador in utilizadores)
{
if (utilizador is Funcionario)
{
Funcionario func = (Funcionario)utilizador;
int fZona = func.ZonaTrabalho;
nEncResp = func.NroEnc;
if (idResp == -1 || fZona == dZona && nRespT > nEncResp)
{
idResp = func.UtilizadorID;
nRespT = nEncResp;
}
}
}
Encomenda enc = _context.Encomendas.Find(idEncomenda);
enc.setFuncionarioID(idResp);
return(idResp);
}
public ActionResult AceitarEncomenda(int?idEnc)
{
if (!User.Identity.IsAuthenticated)
{
return(RedirectToAction("Index", "Autenticacao"));
}
if (idEnc == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Encomenda encomenda = db.Encomendas.Find(idEnc);
if (encomenda == null)
{
return(HttpNotFound());
}
encomenda.estado = "confirmada";
if (ModelState.IsValid)
{
db.Entry(encomenda).State = EntityState.Modified;
db.SaveChanges();
}
return(RedirectToAction("Ocasionais"));
}
public void CriarEncomendas(int quantidade)
{
//ICollection<Cliente> clientes = _db.Clientes.Include(c => c.Enderecos).ToList();
//ICollection<Produto> produtos = _db.Produtos.ToList();
for (int i = 0; i < quantidade; i++)
{
bool passada = random.NextDouble() < 0.85;
Encomenda enc = new Encomenda()
{
Cliente = GetRandomFromArray(clientes.ToArray()),
DataHoraEntrega = passada ? DateTime.Now.AddDays(-random.NextDouble() * 150) : DateTime.Now.AddDays(random.NextDouble() * 30),
DataRecebimento = passada ? DateTime.Now.AddDays(-random.NextDouble() * 180) : DateTime.Now,
Status = passada ? StatusEncomenda.FINALIZADA : StatusEncomenda.ATIVA
};
enc.EncomendaProduto = new List <EncomendaProduto>()
{
new EncomendaProduto(
enc,
GetRandomFromArray(produtos.ToArray()),
random.NextDouble() * 10
)
};
enc.EnderecoEntrega = enc.Cliente.Enderecos.ToArray()[0];
_db.Encomendas.Add(enc);
}
_db.SaveChanges();
}
public async Task <IHttpActionResult> PutEncomenda(int id, Encomenda encomenda)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != encomenda.EncomendaId)
{
return(BadRequest());
}
db.Entry(encomenda).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EncomendaExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
//select
public Encomenda Select(int id)
{
Encomenda obj = null;
System.Data.IDbConnection objConexao;
System.Data.IDbCommand objCommand;
System.Data.IDataReader objDataReader;
objConexao = Mapped.Connection();
objCommand = Mapped.Command("SELECT * FROM tbl_encomenda WHERE enc_codigo = ?codigo", objConexao);
objCommand.Parameters.Add(Mapped.Parameter("?codigo", id));
objDataReader = objCommand.ExecuteReader();
while (objDataReader.Read())
{
obj = new Encomenda();
obj.Codigo = Convert.ToInt32(objDataReader["enc_codigo"]);
obj.Produto = Convert.ToString(objDataReader["enc_produto"]);
obj.Valor = Convert.ToDouble(objDataReader["enc_valor"]);
obj.Cliente = Convert.ToString(objDataReader["enc_cliente"]);
obj.DataPedido = Convert.ToDateTime(objDataReader["enc_datapedido"]);
}
objDataReader.Close();
objConexao.Close();
objCommand.Dispose();
objConexao.Dispose();
objDataReader.Dispose();
return(obj);
}
private void btnFinalizar_Click(object sender, EventArgs e)
{
int r = 0;
for (int i = 0; i < encomendas.Count; i++)
{
encomendaController = new EncomendaController();
encomenda = new Encomenda
{
Nome_Fornecedor = encomendas[i].Nome_Fornecedor,
Med_Encomenda = encomendas[i].Med_Encomenda,
Qtde_Encomenda = encomendas[i].Qtde_Encomenda,
Preco_Encomenda = encomendas[i].Preco_Encomenda,
Data_Encomenda = encomendas[i].Data_Encomenda,
Data_Entrega_Encomenda = encomendas[i].Data_Entrega_Encomenda,
N_Lote_Encomenda = encomendas[i].N_Lote_Encomenda,
Status_Encomenda = encomendas[i].Status_Encomenda,
Id_Usuario = encomendas[i].Id_Usuario,
Id_Fornecedor = encomendas[i].Id_Fornecedor
};
r += encomendaController.RealizarEncomenda(encomenda);
}
if (r == encomendas.Count)
{
MessageBox.Show("Compras realizadas com sucesso!");
//lstCompras.Items.Clear();
//encomendas = new List<Encomenda>();
frmPrincipal.Focus();
this.Close();
}
}
public async Task PostPedidosAsync(Encomenda encomenda, PlataformaRepository plataformaRepository)
{
RestClientFactory restClientFactory = new RestClientFactory(this._config);
try
{
IRestResponse response = await restClientFactory.RestAPI("newOrder", Method.POST, encomenda);
if (response.IsSuccessful)
{
await plataformaRepository.CommitPedidosAsync(encomenda.Pedido, encomenda.DocFiscalNFe.NfeNumero, GerarTrackingUrl(encomenda));
string retorno = $"OrderId: {encomenda.Pedido} - Incluido.";
Console.WriteLine(retorno);
}
else
{
await GerarLog(encomenda, response.Content);
}
}
catch (Exception e)
{
await GerarLog(encomenda, e.Message);
}
}
/// <summary>
/// Updates the cost associated with a given order
/// </summary>
/// <param name="idEncomenda">Unique identifier for a single order</param>
/// <param name="custoInput">Cost of the order</param>
public void UpdateCustoEnc(int idEncomenda, float custoInput)
{
Encomenda enc = _context.Encomendas.Find(idEncomenda);
enc.custo += custoInput;
_context.SaveChanges();
}
public ActionResult DeleteConfirmed(int id)
{
Encomenda encomenda = db.Encomendas.Find(id);
db.Encomendas.Remove(encomenda);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public Tarefa(MaquinaResource maquina1, ComponentesDosArtigo components, Encomenda encomenda)
{
this.maquina1 = maquina1;
this.components = components;
this.encomenda = encomenda;
this.Molde = maquina1.maquina.Molde;
this.TipoMaquina = maquina1.Tipo;
}
/// <summary>
/// Registers a new order on the database
/// </summary>
/// <param name="idCliente">Unique identifier of the client</param>
/// <param name="fornecedor"></param>
/// <param name="morada">Destination of the order</param>
/// <param name="dia">Day of delivery</param>
/// <param name="hora">Time of delivery</param>
/// <param name="numCartCredito">Credit card number for payment</param>
/// <param name="mes">Month of expiration of the credit card</param>
/// <param name="ano">Year of expiration of the credit card</param>
/// <param name="cvv">Security code of credit card</param>
/// <param name="pais">Country of credit card</param>
public void SetEncomenda(int idCliente, string fornecedor, string morada, Date dia, Time hora, long numCartCredito, int mes, int ano, int cvv, string pais)
{
Encomenda nEncomenda = _context.newEncomenda(1, morada, dia, hora, _fController.IdForn(fornecedor), idCliente, 1, numCartCredito);
CartaoCredito nCartaoCredito = _context.newCartaoCredito(numCartCredito, mes, ano, cvv, pais);
_context.Cartoes.Add(nCartaoCredito);
_context.Encomendas.Add(nEncomenda);
_context.SaveChanges();
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
Encomenda encomenda = await db.Encomendas.FindAsync(id);
db.Encomendas.Remove(encomenda);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "Id,DataRecebimento,DataHoraEntrega,Observacoes")] Encomenda encomenda)
{
if (ModelState.IsValid)
{
db.Entry(encomenda).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(encomenda));
}
/// <summary>
/// Registers a service rating referring to a given order
/// </summary>
/// <param name="idEncomenda">Unique identifier for a single order</param>
/// <param name="classServicoEntrega">Rating relating to the employee</param>
/// <param name="classEstadoEncomenda">Rating relating to the order</param>
public void avalia(int idEncomenda, int classServicoEntrega, int classEstadoEncomenda)
{
Encomenda enc = _eController.getEncomenda(idEncomenda);
int idFun = enc.getFuncionarioID();
Funcionario funcionario = _fController.getFuncionario(idFun);
enc.setAvaliacao(classEstadoEncomenda);
funcionario.AtualizaAvaliacao(classServicoEntrega);
_context.SaveChanges();
}
/// <summary>
/// Changes the status of an order
/// </summary>
/// <param name="idEncomenda">Unique identifier for a single order</param>
public void UpdateEstadoEnc(int idEncomenda)
{
Encomenda enc = _context.Encomendas.Find(idEncomenda);
if (enc.estado > 0 && enc.estado < 4)
{
enc.estado++;
}
_context.SaveChanges();
}
public async Task <ActionResult> Edit([Bind(Include = "EncomendaId,Data")] Encomenda encomenda)
{
if (ModelState.IsValid)
{
db.Entry(encomenda).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(encomenda));
}
public async Task <IHttpActionResult> GetEncomenda(int id)
{
Encomenda encomenda = await db.Encomendas.FindAsync(id);
if (encomenda == null)
{
return(NotFound());
}
return(Ok(encomenda));
}
public ActionResult RegistrarEncomenda(EncomendaViewModel vm)
{
var encomenda = Encomenda.Criar(vm.Descricao, vm.Fragil, vm.NomeResponsavel, User.Identity.GetUserId());
unitOfWork.Encomendas.Complete(encomenda);
unitOfWork.Complete();
vm.Sucesso = true;
NotificarEncomenda(encomenda);
return(View("Index", vm));
}
public IHttpActionResult GetEncomenda(int id)
{
Encomenda encomenda = db.Encomenda.Find(id);
if (encomenda == null)
{
return(NotFound());
}
return(Ok(encomenda));
}
/// <summary>
/// Checks whether an order has been delivered
/// </summary>
/// <param name="idEncomenda">Unique identifier for a single order</param>
/// <returns>TRUE if delivered else FALSE</returns>
public bool EncomendaEntregue(int idEncomenda)
{
Encomenda enc = _context.Encomendas.Find(idEncomenda);
bool ret = false;
int estado = enc.estado;
if (estado == 4)
{
ret = true;
}
return(ret);
}
public async Task <IHttpActionResult> PostEncomenda(Encomenda encomenda)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Encomendas.Add(encomenda);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = encomenda.EncomendaId }, encomenda));
}
public ActionResult AddProdutos(int num_enc, string produto, int quantidade)
{
if (!User.Identity.IsAuthenticated)
{
return(RedirectToAction("Index", "Autenticacao"));
}
string[] words = produto.Split('-');
string key_enc = null;
if (num_enc == 1)
{
key_enc = "enc1";
}
if (num_enc == 2)
{
key_enc = "enc2";
}
if (num_enc == 3)
{
key_enc = "enc3";
}
if (num_enc == 4)
{
key_enc = "enc4";
}
if (num_enc == 5)
{
key_enc = "enc5";
}
if (((Hashtable)HttpContext.Session["encs"]).ContainsKey(key_enc))
{
Encomenda enc = (Encomenda)((Hashtable)HttpContext.Session["encs"])[key_enc];
double preco = db.Produtoes.Find(Int32.Parse(words[0])).preco;
Encomenda enc_db = db.Encomendas.Find(enc.idEnc);
enc_db.custo = enc_db.custo + preco * quantidade;
Encomenda_Produto enc_prod = new Encomenda_Produto
{
idEnc = enc.idEnc,
idProd = Int32.Parse(words[0]),
quant = quantidade,
estado = "pendente"
};
if (ModelState.IsValid)
{
db.Entry(enc_db).State = EntityState.Modified;
db.Encomenda_Produto.Add(enc_prod);
db.SaveChanges();
}
}
return(RedirectToAction("SubBronzeProdutos"));
}
public ActionResult DeleteConfirmedEncomenda(int id)
{
if (!User.Identity.IsAuthenticated)
{
return(RedirectToAction("Index", "Autenticacao"));
}
Encomenda encomenda = db.Encomendas.Find(id);
db.Encomendas.Remove(encomenda);
db.SaveChanges();
return(RedirectToAction("IndexEncomenda"));
}
public async Task <ActionResult> Create([Bind(Include = "EncomendaId,Data")] Encomenda encomenda)
{
if (ModelState.IsValid)
{
db.Encomendas.Add(encomenda);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(encomenda));
}
//ADICIONA UMA ENCOMENDA
public ActionResult AdicionaEnc(string hora, string dataEnt)
{
if (!User.Identity.IsAuthenticated)
{
return(RedirectToAction("Index", "Autenticacao"));
}
var user_mail = System.Web.HttpContext.Current.User.Identity.Name;
var cliente = db.Clientes.Where(c => c.email.Equals(user_mail) && c.estadoConta.Equals("ativo")).ToList()[0];
Encomenda encomenda = new Encomenda();
encomenda.estado = "pendente";
encomenda.custo = (float)Session["Total"];
encomenda.idCli = cliente.idCli;
encomenda.numPorta = cliente.numPorta;
encomenda.rua = cliente.rua;
encomenda.codPostal = cliente.codPostal;
encomenda.cidade = cliente.cidade;
encomenda.idFunc = "E001";
encomenda.obs = null;
encomenda.freguesia = cliente.freguesia;
encomenda.dataPag = null;
encomenda.modoPag = null;
encomenda.fatura = null;
encomenda.tipoEnc = "ocasional";
string[] words = dataEnt.Split('-');
string[] hour = hora.Split(':');
encomenda.dataEnt = new DateTime(Int32.Parse(words[0]), Int32.Parse(words[1]), Int32.Parse(words[2]), Int32.Parse(hour[0]), 0, 0);
List <Tuple <int, String, float, int> > aux = (List <Tuple <int, String, float, int> >)Session["Carrinho"];
List <Tuple <int, int> > produtos = new List <Tuple <int, int> >();
foreach (var item in aux)
{
produtos.Add(new Tuple <int, int>(item.Item1, item.Item4));
}
db.Encomendas.Add(encomenda);
db.SaveChanges();
//inserir associação entre a encomenda e os produtos
adicionaProdEnc(produtos, encomenda.idEnc);
Session["Carrinho"] = new List <Tuple <int, String, float, int> >();
Session["Total"] = 0.0f;
return(RedirectToAction("PagaEncomendas", "Manutencao", new { id = cliente.idCli }));
}
public ActionResult Edit([Bind(Include = "id,estado,email,morada,inicio,fim,custoTotal,detalhes,Fatura_referencia")] Encomenda encomenda)
{
if (ModelState.IsValid)
{
db.Entry(encomenda).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.Fatura_referencia = new SelectList(db.Faturas, "referencia", "metodoPagamento", encomenda.Fatura_referencia);
ViewBag.morada = new SelectList(db.Moradas, "id", "cidade", encomenda.morada);
ViewBag.email = new SelectList(db.Utilizadors, "email", "password", encomenda.email);
return(View(encomenda));
}
public ArrayList getListaEncomendas(ComunicacaoBD comunicacaoBD)
{
Encomenda encomenda = null;
ArrayList listaEncomendas = new ArrayList();
string query = "SELECT Encomenda.idEncomenda, Encomenda.idCliente, Encomenda.valorTotal, Encomenda.dataCriacao, " +
" Utilizador.username " +
" FROM Utilizador ,Cliente, Encomenda " +
" WHERE " +
" Utilizador.idUtilizador = Cliente.idCliente " +
" AND " +
" Cliente.idCliente = Encomenda.idCliente";
SqlCommand comando = new SqlCommand(query);
SqlDataReader resposta = invocaQueryLeitura(comando, comunicacaoBD);
while (resposta.Read() == true)
{
encomenda = new Encomenda();
encomenda.Cliente = new Cliente();
encomenda.IdEncomenda = (string)resposta["idEncomenda"];
encomenda.IdCliente = (string)resposta["idCliente"];
encomenda.ValorTotal = double.Parse((string)resposta["valorTotal"]);
encomenda.DataCriacao = (string)resposta["dataCriacao"];
encomenda.Cliente.Username = (string)resposta["username"];
listaEncomendas.Add(encomenda);
}
if (resposta != null)
resposta.Close();
return listaEncomendas;
}
public Encomenda[] HistoricoComprasEncomenda(string username)
{
ComunicacaoBD comunicacaoBD = new ComunicacaoBD();
int jEnc = 0;
ArrayList aux = new ArrayList();
Encomenda[] encomendas = null;
ArrayList listaEncomendas = this.MostraEncomendas("todas");
Cliente cliente = servico.getDadosCliente(username, comunicacaoBD);
if (cliente != null)
{
foreach (Encomenda enc in listaEncomendas)
{
if (enc.IdCliente == cliente.IdCliente && enc.Estado.Trim() == "entregue")
{
aux.Add(enc);
}
}
encomendas = new Encomenda[aux.Count];
foreach (Encomenda encomenda in aux)
{
encomendas[jEnc++] = encomenda;
}
}
else {
comunicacaoBD.Transacao.Rollback();
return null;
}
comunicacaoBD.Transacao.Commit();
return encomendas;
}
public Encomenda[] MostraEncomendasCliente(string username)
{
ComunicacaoBD comunicacaoBD = new ComunicacaoBD();
int jEnc = 0;
ArrayList aux = new ArrayList();
Encomenda[] encomendas = null;
ArrayList listaEncomendas = this.MostraEncomendas("todas");
Cliente cliente = servico.getDadosCliente(username, comunicacaoBD);
if (cliente != null)
{
foreach (Encomenda enc in listaEncomendas)
{
if (enc.IdCliente == cliente.IdCliente)
{
aux.Add(enc);
}
}
encomendas = new Encomenda[aux.Count];
foreach (Encomenda encomenda in aux)
{
encomendas[jEnc++] = encomenda;
}
}
return encomendas;
}
public Encomenda[] MostraEncomendasEntregues()
{
int jEnc = 0;
ArrayList listaEncomendas = this.MostraEncomendas("entregue");
Encomenda[] encomendas = new Encomenda[listaEncomendas.Count];
foreach (Encomenda encomenda in listaEncomendas)
{
encomendas[jEnc++] = encomenda;
}
return encomendas;
}
public Encomenda[] MostraEncomendasLivro(string ISBN)
{
ComunicacaoBD comunicacaoBD = new ComunicacaoBD();
int jEnc = 0;
ArrayList aux = new ArrayList();
Encomenda[] encomendas = null;
ArrayList listaEncomendas = this.MostraEncomendas("todas");
foreach (Encomenda enc in listaEncomendas)
{
foreach (Livro liv in enc.ListaLivros) {
if (liv.ISBN.Trim() == ISBN) {
aux.Add(enc);
}
}
}
encomendas = new Encomenda[aux.Count];
foreach (Encomenda encomenda in aux)
{
encomendas[jEnc++] = encomenda;
}
return encomendas;
}
public ArrayList getListaEncomendas(ComunicacaoBD comunicacaoBD)
{
Encomenda encomenda = null;
ArrayList listaEncomendas = new ArrayList();
string query = "SELECT idEncomenda, valorTotal, estado, tempoEspera " +
" FROM Encomenda ";
SqlCommand comando = new SqlCommand(query);
SqlDataReader resposta = invocaQueryLeitura(comando, comunicacaoBD);
while (resposta.Read() == true)
{
encomenda = new Encomenda();
encomenda.IdEncomenda = (string)resposta["idEncomenda"];
encomenda.ValorTotal = double.Parse((string)resposta["valorTotal"]);
encomenda.Estado = (string)resposta["estado"];
encomenda.TempoEspera = (int)resposta["tempoEspera"];
listaEncomendas.Add(encomenda);
}
if (resposta != null)
resposta.Close();
return listaEncomendas;
}
//ENCOMENDA
public void InsereEncomenda(ref Encomenda encomenda)
{
ComunicacaoBD comunicacaoBD = new ComunicacaoBD();
int tempoEspera = 0;
try
{
servico.insereEncomenda(encomenda.IdEncomenda, encomenda.ValorTotal + "", "colocada", encomenda.NomeCliente,
encomenda.Numero, encomenda.Address, encomenda.City, encomenda.State,
encomenda.ZIPcode, encomenda.Country, 0, comunicacaoBD);
encomenda.TempoEspera = 0;
foreach (Livro livro in encomenda.ListaLivros) {
tempoEspera = CalculaTempoEntrega(livro.TempoEntrega);
if (encomenda.TempoEspera < tempoEspera) {
encomenda.TempoEspera = tempoEspera;
}
servico.guardaLivro(encomenda.IdEncomenda, livro.ISBN, livro.Titulo, livro.PrecoVenda.Replace(".", ","),
livro.TempoEntrega, livro.NomeFornecedor, livro.Quantidade, comunicacaoBD);
}
}
catch (SqlException e)
{
comunicacaoBD.Transacao.Rollback();
throw new Exception("ERRO: encomenda nao pode ser atendida");
}
comunicacaoBD.Transacao.Commit();
}
public void TempoVidaEncomenda(object aux)
{
WEBooksDistribuidorAp.LogMensagens text = new WEBooksDistribuidorAp.LogMensagens();
Encomenda encomenda = new Encomenda(EncomendaWEBooks);
ComunicacaoFila comFila = new ComunicacaoFila();
InsereEncomenda(ref encomenda); //fica logo no estado colocada
//Envia mensagem de aviso de mensagem colocada, na WEBooks fica pendente
if (encomenda.TempoEspera != 0) {
PendenteEncomenda(encomenda.IdEncomenda);
//Espera 5 segundos antes de enviar a resposta a WEBooks
EncomendaWEBooks.TipoMensagem = "pendente";
Thread.Sleep(new TimeSpan(0,0,5));
comFila.escreveFilaWeb(EncomendaWEBooks);
text.escreveNoLog = "Enviada: " + EncomendaWEBooks.TipoMensagem;
}
Thread.Sleep(new TimeSpan(0, 0, encomenda.TempoEspera));//vai esperar que fiquem todos os livros disponiveis
try
{
EncomendaWEBooks.TipoMensagem = "entregue";
Thread.Sleep(new TimeSpan(0, 0, 5));
comFila.escreveFilaWeb(EncomendaWEBooks);
EntregueEncomenda(encomenda.IdEncomenda);
text.actualizaLog(EncomendaWEBooks.TipoMensagem, false);
}
catch (Exception) {
//nao faz nada, significa que mensagem foi cancelada anteriormente
}
//fim do tempo de vida da encomenda
}
