public async Task <IActionResult> Edit(int id, [Bind("Id,Peso,Tipo_Mercadoria,Quantidade_Mercadoria,Nome_Mercadoria")] Mercadoria mercadoria)
{
if (id != mercadoria.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(mercadoria);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MercadoriaExists(mercadoria.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(mercadoria));
}
// GET: Mercadoria/Remover/5
public ActionResult Remover(int id)
{
Mercadoria mercadoria = mercadoriaRepository.Recuperar(id);
mercadoriaRepository.Remover(mercadoria);
return(RedirectToAction("Index"));
}
/// <summary>
/// Obtém no banco de dados as várias imagems para referência informada
/// e cria uma animação
/// </summary>
/// <param name="referênciaNumérica"></param>
/// <returns></returns>
public static Animação ObterAnimação(Mercadoria.Mercadoria mercadoria)
{
Console.WriteLine("Animação::ObterAnimação()");
IDataReader leitor = null;
ArrayList dados = new ArrayList();
Animação animação;
IDbConnection conexão = Conexão;
lock (conexão)
{
Usuários.UsuárioAtual.GerenciadorConexões.RemoverConexão(conexão);
using (IDbCommand cmd = conexão.CreateCommand())
{
cmd.CommandText = "SELECT foto FROM foto WHERE mercadoria = " + DbTransformar(mercadoria.ReferênciaNumérica);
using (leitor = cmd.ExecuteReader())
{
try
{
while (leitor.Read())
{
/* Para minimizar o tempo com a conexão presa,
* o processamento da imagem só será feito
* após recuperar todos os dados do banco de dados,
* liberando assim a conexão.
* -- Júlio, 18/11/2005
*/
dados.Add(leitor.GetValue(0));
}
}
finally
{
if (leitor != null)
leitor.Close();
Usuários.UsuárioAtual.GerenciadorConexões.AdicionarConexão(conexão);
}
}
}
}
if (dados.Count == 0)
return null;
animação = new Animação();
foreach (byte[] objFoto in dados)
{
Image imagem = (Image)new DbFoto(objFoto);
if (imagem != null)
animação.Imagens.Add(imagem);
}
Console.WriteLine("Fim Animação::ObterAnimação()");
return animação;
}
private async void BtnUpdate_Clicked(object sender, EventArgs e)
{
if (!string.IsNullOrEmpty(txtId.Text))
{
Mercadoria mercadoria = new Mercadoria()
{
Id = Convert.ToInt32(txtId.Text),
NomeMercadoria = txtNomeMercadoria.Text,
Peso = txtPeso.Text,
NomeProdutor = txtNomeProdutor.Text,
Email = txtEmail.Text,
NCM = txtNCM.Text
};
//Update Person
await App.SQLiteDb.SaveItemAsync(mercadoria);
Limpar();
await DisplayAlert("Successo", "Mercadoria Atualizada", "OK");
//Get All Persons
var mercadoriaList = await App.SQLiteDb.GetItemsAsync();
if (mercadoriaList != null)
{
lstMercadorias.ItemsSource = mercadoriaList;
}
}
else
{
await DisplayAlert("Erro", "É necessario o ID", "OK");
}
}
private async void BtnAdd_Clicked(object sender, EventArgs e)
{
if (!string.IsNullOrEmpty(txtNomeMercadoria.Text))
{
Mercadoria Mercadoria = new Mercadoria()
{
NomeMercadoria = txtNomeMercadoria.Text,
Peso = txtPeso.Text,
NomeProdutor = txtNomeProdutor.Text,
Email = txtEmail.Text,
NCM = txtNCM.Text
};
//Add New Mercadoria
await App.SQLiteDb.SaveItemAsync(Mercadoria);
Limpar();
await DisplayAlert("Successo", "Mercadoria Cadastrada", "OK");
//Get All Mercadorias
var mercadoriaList = await App.SQLiteDb.GetItemsAsync();
if (mercadoriaList != null)
{
lstMercadorias.ItemsSource = mercadoriaList;
}
}
else
{
await DisplayAlert("Erro", "Insira os dados corretos", "OK");
}
}
static public UserControl VisualizarMercadoria(Mercadoria mercadoria)
{
var pg = new MercadoriaUC();
pg.Mercadoria = (Mercadoria)mercadoria;
return(pg);
}
public IActionResult Edit(int id, [Bind("Id,Nome,Descricao,Tipo,Fabricante")] Mercadoria mercadoria)
{
if (id != mercadoria.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_repo.Update(mercadoria);
}
catch (DbUpdateConcurrencyException)
{
if (!_repo.MercadoriaExists(mercadoria.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
else
{
return(BadRequest());
}
// return View(mercadoria);
}
public static List<VinculoMercadoriaComponenteCusto> ObterVinculos(Mercadoria mercadoria)
{
string consulta = "select * from vinculomercadoriacomponentecusto where "
+ "mercadoria=" + DbTransformar(mercadoria.ReferênciaNumérica);
return Mapear<VinculoMercadoriaComponenteCusto>(consulta);
}
public static void GravarVinculos(List<VinculoMercadoriaComponenteCusto> lista, Mercadoria mercadoria)
{
string consulta = "delete from vinculomercadoriacomponentecusto where mercadoria=" + DbTransformar(mercadoria.ReferênciaNumérica) + ";";
if (lista.Count != 0)
{
consulta += " INSERT INTO vinculomercadoriacomponentecusto (mercadoria, componentecusto, quantidade) VALUES (";
bool primeiro = true;
foreach (VinculoMercadoriaComponenteCusto v in lista)
{
if (!primeiro)
consulta += "),(";
else
primeiro = false;
consulta += v.Mercadoria + "," + DbTransformar(v.Componente) + "," + DbTransformar(v.Quantidade);
}
consulta += ");";
}
IDbConnection conexão = Conexão;
lock (conexão)
{
var cmd = conexão.CreateCommand();
cmd.CommandText = consulta;
cmd.ExecuteNonQuery();
}
}
public async Task <IActionResult> Editar(int id, [Bind("MercadoriaID,Nome,NumeroRegistro,Tipo,Fabricante,Quantidade,Descricao")] Mercadoria mercadoria)
{
if (id != mercadoria.MercadoriaID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(mercadoria);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (mercadoria.MercadoriaID < 1)
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("Index"));
}
return(View(mercadoria));
}
static public UserControl VisualizarGrade(Mercadoria mercadoria)
{
var pg = new GradeViewUC();
pg.GradesSelecionadas = mercadoria.Grade;
return(pg);
}
public void CriarMercadoria(Mercadoria mercadoria, List <KeyValuePair <string, string> > tamanhos,
List <HttpPostedFileWrapper> arquivos)
{
mercadoria.Id = Guid.NewGuid();
mercadoria.DataDeCadastramento = DateTime.Now;
mercadoria.Produtos = FabricaDeProduto.Instancia().CriarProdutos(tamanhos, mercadoria.Preco);
}
public void Adicionar(Mercadoria mercadoria)
{
using (var context = new WebEstoqueContext())
{
context.Mercadorias.Add(mercadoria);
context.SaveChanges();
}
}
public void Atualizar(Mercadoria mercadoria)
{
using (var contexto = new WebEstoqueContext())
{
contexto.Entry(mercadoria).State = System.Data.Entity.EntityState.Modified;
contexto.SaveChanges();
}
}
private void usingButton_Click(object sender, EventArgs e)
{
using (var mercadoria = new Mercadoria())
{
mercadoria.Nome = "Borracha";
resultadoListBox.Items.Add(mercadoria.Nome);
}
}
public void Editar(Mercadoria mercadoria)
{
db.Mercadoria.Attach(mercadoria);
var entry = db.Entry(mercadoria);
entry.State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
public HistóricoRelacionamentoItem(Mercadoria.Mercadoria mercadoria, double quantidade, DateTime data, Entidades.Pessoa.Funcionário funcionário, double índice)
{
this.mercadoria = mercadoria;
this.quantidade = quantidade;
this.data = data;
this.funcionário = funcionário;
this.indice = índice;
}
public void Excluir(Mercadoria mercadoria)
{
db.Mercadoria.Attach(mercadoria);
var entry = db.Entry(mercadoria);
entry.State = System.Data.Entity.EntityState.Deleted;
db.SaveChanges();
}
public Object Post([FromBody]Mercadoria value)
{
_repository.Insert(value);
return new
{
Identity = value.ID
};
}
public ActionResult Cadastrar(Entrada entrada)
{
Mercadoria mercadoriaRecuperada = mercadoriaRepository.Recuperar(entrada.Mercadoria.Id);
entrada.Mercadoria = mercadoriaRecuperada;
entradaRepository.Salvar(entrada);
return(RedirectToAction("Index", "Inicial"));
}
private void disposeButton_Click(object sender, EventArgs e)
{
var mercadoria = new Mercadoria();
mercadoria.Nome = "Régua";
resultadoListBox.Items.Add(mercadoria.Nome);
mercadoria.Dispose();
}
public IActionResult Create([Bind("Nome,Descricao,Tipo,Fabricante")] Mercadoria mercadoria)
{
if (ModelState.IsValid)
{
_repo.Add(mercadoria);
return(RedirectToAction(nameof(Index)));
}
return(View(mercadoria));
}
public void carregaMercadoriaFiltro()
{
dgv_Mercadorias.Rows.Clear();
var mercadoria = new Mercadoria().retornaMercadoriaPorNome(tb_Filtro.Text);
foreach (var m in mercadoria)
{
dgv_Mercadorias.Rows.Add(m.CD_Referencia, m.NM_Nome, m.TG_Categoria, m.VL_ValorVenda, m.VL_Estoque);
}
}
public void carregarMercadorias()
{
dgv_Mercadorias.Rows.Clear();
var mercadoria = new Mercadoria().retornaTodaMercadoria();
foreach (var m in mercadoria)
{
dgv_Mercadorias.Rows.Add(m.CD_Referencia, m.NM_Nome, m.TG_Categoria, m.VL_ValorVenda, m.VL_Estoque);
}
}
public override HistóricoRelacionamentoItem Relacionar(Mercadoria.Mercadoria m, double quantidade, double índice)
{
Persistir();
HistóricoRelacionamentoItem relacionado = base.Relacionar(m, quantidade, índice);
venda.CalcularValor();
return relacionado;
}
private void bunifuThinButton21_Click(object sender, EventArgs e)
{
if (new Caixa().caixaAberto() != null)
{
lb_Status.ForeColor = Color.FromArgb(0, 128, 128);
lb_Status.Text = "processando";
MessageBox.Show(dgv_Mercadorias.RowCount.ToString());
// ---------------------------------------------------------
DateTime dataAgora = DateTime.Now;
VENDA venda = new VENDA();
venda.NM_Vendedor = "Rafael";
venda.DT_Data = dataAgora.ToString("dd/MM/yyyy HH:mm:ss");
venda.VL_ValorTotal = valorFinal;
venda.CD_ID = Convert.ToInt32(lb_ID.Text);
venda.CD_Cartao = cb_Cartao.Checked ? 1 : 0;
new Venda().cadastraVenda(venda);
lb_Status.Text = "venda criada";
// ---------------------------------------------------------
for (int i = 0; i < dgv_Mercadorias.RowCount - 1; i++)
{
int qtd = Convert.ToInt32(dgv_Mercadorias[2, i].Value);
int referencia = Convert.ToInt32(dgv_Mercadorias[0, i].Value);
MERCADORIA_VENDA mercadoria = new MERCADORIA_VENDA();
mercadoria.CD_Mercadoria = Convert.ToInt32(dgv_Mercadorias[0, i].Value);
mercadoria.CD_Venda = Convert.ToInt32(lb_ID.Text);
mercadoria.QT_Quantidade = Convert.ToInt32(dgv_Mercadorias[2, i].Value);
new Venda().cadastraMercadoriaVendida(mercadoria);
MERCADORIA mercadoria_alterada = new Mercadoria().retornaMercadoria(referencia);
mercadoria_alterada.VL_Estoque -= qtd;
new Mercadoria().alteraMercadoria(mercadoria_alterada);
lb_Status.Text = "mercadoria " + i + " OK";
}
// ---------------------------------------------------------
var caixa = new Caixa().caixaAberto();
if (cb_Cartao.Checked)
{
caixa.VL_ValorCartaoAdmin += valorFinal;
}
else
{
caixa.VL_ValorDinheiroAdmin += valorFinal;
}
new Caixa().AlteraCaixa(caixa);
lb_Status.Text = "inserida no caixa";
// ---------------------------------------------------------
lb_Status.Text = "Finalizada";
lb_Status.ForeColor = Color.YellowGreen;
}
else
{
MessageBox.Show("Erro: Caixa deve estar aberto para realizar a venda");
}
}
public async Task <IActionResult> Create([Bind("Id,Peso,Tipo_Mercadoria,Quantidade_Mercadoria,Nome_Mercadoria")] Mercadoria mercadoria)
{
if (ModelState.IsValid)
{
_context.Add(mercadoria);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(mercadoria));
}
public static Mercadoria Seleciona(int pCodigoMercadoria)
{
//Conexão com o Banco de Dados
AutoResendeDataContext oDB = new AutoResendeDataContext();
//String de Seleção
Mercadoria oMercadoria = (from Seleciona in oDB.Mercadorias where Seleciona.idMercadoria == pCodigoMercadoria select Seleciona).SingleOrDefault();
//Retorno da Ordem de Serviço
return(oMercadoria);
}
//Insert and Update new record
public Task <int> SaveItemAsync(Mercadoria mercadoria)
{
if (mercadoria.Id != 0)
{
return(db.UpdateAsync(mercadoria));
}
else
{
return(db.InsertAsync(mercadoria));
}
}
public double GetValorTotal()
{
double ValorTotal = 0;
foreach (MercadoriaModel Mercadoria in this.mercadorias)
{
ValorTotal += Mercadoria.GetValorTotal();
}
return(ValorTotal);
}
private void MercadoriasDataGrid_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
Mercadoria m = GradeViewModel.MercadoriaSelecionada;
UserControl page = PessoaViewFactory.VisualizarGrade(m);
while (MercadoriaContent.Children.Count > 0)
{
MercadoriaContent.Children.RemoveAt(0);
}
MercadoriaContent.Children.Add(page);
}
public void DeveRetornarMercadoriaInvalidaSeQuantidadeForaRange(double peso)
{
//Arrange
mercadoria = new Mercadoria(MercadoriaTipo.Container, peso, true);
//Act
bool valido = mercadoria.EhValido();
//Assert
Assert.False(valido);
Assert.True(mercadoria.ValidationResult.Errors.All(t => t.PropertyName == nameof(mercadoria.Peso)));
}
/// <summary>
/// Constrói a estrutura de preço com um índice personalizado.
/// </summary>
/// <param name="cotação">Cotação a ser usada.</param>
/// <param name="índice">Índice da mercadoria.</param>
public Preço(Mercadoria.Mercadoria mercadoria, Cotação cotação, double índice)
{
this.mercadoria = mercadoria;
this.cotação = cotação;
this.índice = índice;
this.fator = 1;
this.preço = 0;
this.dias = 0;
this.juros = Configuração.DadosGlobais.Instância.Juros;
CalcularPreço();
}
private void consMercadoriaVenda_Load(object sender, EventArgs e)
{
dgv_MercadoriaVendida.Rows.Clear();
var Mercvenda = new Venda().retornaMercadoriaVendida(idGlobal);
foreach (var v in Mercvenda)
{
var mercadoria = new Mercadoria().retornaMercadoria(Convert.ToInt32(v.CD_Mercadoria));
dgv_MercadoriaVendida.Rows.Add(mercadoria.CD_Referencia, mercadoria.NM_Nome, v.QT_Quantidade, mercadoria.VL_ValorVenda, v.QT_Quantidade * mercadoria.VL_ValorVenda);
}
}
public async Task <IActionResult> Adicionar(Mercadoria a)
{
if (!ModelState.IsValid)
{
return(View(a));
}
db.Add(a);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Inserir(
[Bind("MercadoriaID,Nome,NumeroRegistro,Tipo,Fabricante,Quantidade,Descricao")] Mercadoria mercadoria)
{
if (ModelState.IsValid)
{
_context.Add(mercadoria);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(mercadoria));
}
/// <summary>
/// Adiciona um item de relacionamento, seja inserção, seja remoção.
/// Já cadastra no banco de dados.
/// </summary>
public virtual HistóricoRelacionamentoItem Relacionar(Mercadoria.Mercadoria m, double quantidade, double índice)
{
HistóricoRelacionamentoItem novoItem;
DateTime agora = Configuração.DadosGlobais.Instância.HoraDataAtual;
novoItem = ConstruirItemHistórico(m, quantidade, agora, Entidades.Pessoa.Funcionário.FuncionárioAtual, índice);
entidadePai.DispararAntesDeCadastrarItem(novoItem);
if (!entidadePai.Cadastrado)
entidadePai.Cadastrar();
if (lista.Count != ContarItens())
throw new InvalidAsynchronousStateException();
novoItem.Cadastrar();
Adicionar(novoItem);
return novoItem;
}
public void Remover(Mercadoria.Mercadoria mercadoria)
{
uint códigoMiniatura;
string chave = GerarChave(mercadoria);
if (hashMercadoriaMiniatura.TryGetValue(chave, out códigoMiniatura))
{
hashMercadoriaMiniatura.Remove(chave);
Salvar();
}
}
protected override SaquinhoRelacionamento ConstuirItemAgrupado(Mercadoria.Mercadoria mercadoria, double quantidade, double índice)
{
return new SaquinhoDevolução(venda, mercadoria, quantidade, índice);
}
private static string ObterReferenciaComDigito(Mercadoria.Mercadoria m)
{
return m.ReferênciaNumérica + m.Dígito;
}
protected override ItemRelacionado ConstruirNovoItem(Mercadoria mercadoria, double quantidade)
{
return new ItemPedido(pedido, mercadoria, quantidade);
}
protected virtual SaquinhoRelacionamento ConstuirItemAgrupado(Mercadoria.Mercadoria mercadoria, double quantidade, double indice)
{
return new SaquinhoRelacionamento(mercadoria, quantidade, indice);
}
public SaquinhoVenda(Venda v, Mercadoria.Mercadoria m, double qtd, double índice)
: base(m, qtd, índice)
{
venda = v;
}
public SaquinhoAcertoAA(Mercadoria.Mercadoria m, double qtd, double peso, double índice)
: base(m, qtd, peso, índice)
{
}
public SaquinhoRelacionamento(Mercadoria.Mercadoria m, double qtd, double índice)
: base(m, qtd)
{
this.índice = índice;
}
private void bandejaAcerto_SeleçãoMudou(Mercadoria.Bandeja.Bandeja bandeja, Entidades.ISaquinho saquinho)
{
quadroRastro.Visible = saquinho != null;
}
/// <summary>
/// Constrói a estrutura de preço de uma mercadoria,
/// utilizando a cotação vigente carregada do banco de dados.
/// </summary>
public Preço(Mercadoria.Mercadoria mercadoria, Moeda moeda)
: this(mercadoria, Cotação.ObterCotaçãoVigente(moeda))
{ }
private static string GerarChave(Mercadoria.Mercadoria mercadoria)
{
return GerarChave(mercadoria.ReferênciaNumérica);
}
protected override HistóricoRelacionamentoItem ConstruirItemHistórico(Mercadoria.Mercadoria mercadoria, double quantidade, DateTime data, Entidades.Pessoa.Funcionário funcionário, double índice)
{
return new HistóricoDevoluçãoItem(mercadoria, quantidade, venda, data, funcionário, índice);
}
/// <summary>
/// Constrói um ItemPedido a partir de dados já adquiridos.
/// </summary>
/// <remarks>
public ItemPedido(Pedido pedido, Mercadoria mercadoria, double quantidade)
: base(mercadoria, quantidade)
{
this.pedido = pedido;
}
/// <summary>
/// Obtem a foto da cache.
/// Pode retornar nulo caso foto não exista.
/// </summary>
/// <param name="mercadoria"></param>
/// <returns></returns>
public DbFoto Obter(Mercadoria.Mercadoria mercadoria)
{
if (mercadoria == null)
return null;
uint códigoMiniatura;
if (hashMercadoriaMiniatura.TryGetValue(GerarChave(mercadoria), out códigoMiniatura))
return Obter(new Foto(códigoMiniatura, mercadoria.ReferênciaNumérica));
else
return null;
}
/// <summary>
/// Constrói um ItemPedido a partir de dados já adquiridos,
/// permitindo afirmar que os dados estão no banco de dados.
/// </summary>
/// <param name="cadastrado">Se os dados já estão cadastrados no BD.</param>
public ItemPedido(Pedido pedido, Mercadoria mercadoria, double quantidade, bool cadastrado)
: this(pedido, mercadoria, quantidade)
{
this.cadastrado = this.atualizado = cadastrado;
}
public SaquinhoDevolução(Venda v, Mercadoria.Mercadoria m, double qtd, double índice)
: base(m, qtd, índice)
{
venda = v;
this.índice = índice;
}
// public System.Data.DataSet ObterDataSetImpressão()
// {
// /* O CriarAdaptador está gerando a excessão que não consegue achar assembly.
// * Adicionei no references do Entidades o MysqlConnector enquanto o problema não é resolvido.
// */
//
// #region ideal
//
//// IDbConnection conexão = Conexão;
//// System.Data.DataSet ds = new System.Data.DataSet();
////
//// IDbDataAdapter adaptador = CriarAdaptador(conexão);
////
////
//// string c = "select concat(substr(itempedido.referencia, 1, 3), '.', substr(itempedido.referencia, 4, 3), '.', substr(itempedido.referencia, 7, 2), '.', substr(itempedido.referencia, 9, 3), '-', mercadoria.digito) as referencia, ";
//// c += "itempedido.peso, itempedido.indice, itempedido.quantidade ";
//// c += "from itempedido, mercadoria WHERE ";
//// c += "itempedido.referencia = mercadoria.referencia AND ";
//// c += "itempedido.pedido = " + DbTransformar(this.Código);
////
////
//// lock (conexão)
//// {
//// using (IDbCommand cmd = conexão.CreateCommand())
//// {
//// cmd.CommandText = c;
////
//// adaptador.Fill(ds, "Pedido");
//// }
//// }
////
//// return ds;
////
// #endregion
//
// #region temporário mas funciona
//
// System.Data.DataSet ds = new System.Data.DataSet();
// MySql.Data.MySqlClient.MySqlConnection conexão = null;
// MySql.Data.MySqlClient.MySqlDataAdapter adaptador;
//
// string strConexão = "Data Source=127.0.0.1";
// strConexão += ";Database=imjoias";
// strConexão += ";User Id=imjoias";
// strConexão += ";Password=b9r8hukl3";
//
// conexão = new MySql.Data.MySqlClient.MySqlConnection(strConexão);
//
// conexão.Open();
//
// MySql.Data.MySqlClient.MySqlCommand cmd = conexão.CreateCommand();
//
// string c = "select concat(substr(itempedido.referencia, 1, 3), '.', substr(itempedido.referencia, 4, 3), '.', substr(itempedido.referencia, 7, 2), '.', substr(itempedido.referencia, 9, 3), '-', mercadoria.digito) as referencia, ";
// c += "itempedido.peso, itempedido.indice, itempedido.quantidade ";
// c += "from itempedido, mercadoria WHERE ";
// c += "itempedido.referencia = mercadoria.referencia AND ";
// c += "itempedido.pedido = " + DbTransformar(this.Código);
//
// cmd.CommandText = c;
//
// adaptador = new MySql.Data.MySqlClient.MySqlDataAdapter(cmd);
// adaptador.Fill(ds, "Pedido");
//
// return ds;
//
// #endregion
// }
// Recuperação de dados
/// <summary>
/// Esta lista preenche 3 entidades de uma só vez:
/// - Pedido, ItemPedido, Mercadoria (do itemPedido)
///
/// Basicamente recupera todos os pedidos abertos não acertados.
/// Observe que existe uma coleção 'itens', atributo desta entidade.
/// a lista de itens é obtida também por essa consulta.
/// Cada pedidoitem possui uma mercadoria, que alias, é o que diferencia um item de outro.
/// A mercadoria também é criada nesta consulta.
/// </summary>
/// <returns> lista de Entidade.Pedido </returns>
public static Pedido [] ObterPedidosNãoAcertados()
{
// Obtém os pedidos sem os itens, e cria uma hash para auxiliar futuramente
ArrayList pedidos = ObterPedidosNãoAcertadosSemItens();
IDbConnection conexão = Conexão;
IDataReader leitor = null;
Hashtable pedidosCódigo = new Hashtable();
foreach (Pedido p in pedidos)
pedidosCódigo.Add(p.Código, p);
lock (conexão)
{
using (IDbCommand cmd = conexão.CreateCommand())
{
cmd.CommandText =
"SELECT pedido.codigo, itempedido.referencia, itempedido.peso, itempedido.quantidade, mercadoria.* from pedido, itemPedido LEFT JOIN mercadoria ON itempedido.referencia = mercadoria.referencia where itempedido.pedido = pedido.codigo AND pedido.acertado = 0 order by pedido.codigo, itempedido.referencia";
try
{
long códigoÚltimoPedido = -1;
long códigoAtualPedido;
bool novoPedido;
Pedido pedido = null;
ItemPedido item = null;
Mercadoria merc = null;
leitor = cmd.ExecuteReader();
while (leitor.Read())
{
códigoAtualPedido = leitor.GetInt32((int) Ordem.Código);
novoPedido = (códigoAtualPedido != códigoÚltimoPedido);
if (novoPedido)
{
pedido = (Pedido) pedidosCódigo[códigoAtualPedido];
códigoÚltimoPedido = códigoAtualPedido;
pedido.cadastrado = true;
pedido.atualizado = true;
}
// A cada item lido, existe uma nova mercadoria e um novo itempedido
#region Recupera a mercadoria deste itempedido
/* não deve-se fazer hash da mercadoria obtida,
* uma vez que serão o mesmo objeto para vários pedidos,
* daí uma alteração em um acarreta em alteração nos outros!
*/
string referência = leitor.GetString((int) Ordem.Referencia);
double peso = leitor.GetDouble((int) Ordem.PesoPedido);
// string hash = referência + peso.ToString();
if (referência != null)
{
if (!leitor.IsDBNull((int) Ordem.Digito))
merc = new Mercadoria(referência, Convert.ToInt32(leitor.GetValue((int) Ordem.Digito)), peso);
else
merc = new Mercadoria(referência, -1, peso);
merc.Coeficiente = leitor.GetDouble((int) Ordem.Coeficiente);
if (!leitor.IsDBNull((int) Ordem.DePeso))
merc.DePeso = leitor.GetBoolean((int) Ordem.DePeso);
merc.Descrição = leitor.GetString((int) Ordem.Nome);
if (!leitor.IsDBNull((int) Ordem.Faixa))
merc.Faixa = leitor.GetChar((int) Ordem.Faixa);
if (!leitor.IsDBNull((int) Ordem.ForaDeLinha))
merc.ForaDeLinha = leitor.GetBoolean((int) Ordem.ForaDeLinha);
if (!leitor.IsDBNull((int) Ordem.Grupo))
merc.Grupo = leitor.GetInt32((int) Ordem.Grupo);
if (!leitor.IsDBNull((int) Ordem.Teor))
merc.Teor = Convert.ToSingle(leitor.GetInt32((int) Ordem.Teor));
merc.ForçarCadastrada();
}
else
{
merc = new Mercadoria(referência);
merc.Peso = peso;
}
#endregion
item = new ItemPedido(
pedido,
merc,
leitor.GetDouble((int) Ordem.Quantidade),
true);
pedido.Itens.Adicionar(item);
}
}
finally
{
if (leitor != null)
leitor.Close();
}
}
}
return (Pedido []) pedidos.ToArray(typeof(Pedido));
}
protected abstract HistóricoRelacionamentoItem ConstruirItemHistórico(Mercadoria.Mercadoria mercadoria, double quantidade, DateTime data, Pessoa.Funcionário funcionário, double índice);
/// <summary>
/// Constrói a estrutura de preço de uma mercadoria.
/// </summary>
/// <param name="cotação">Cotação a ser utilizada.</param>
public Preço(Mercadoria.Mercadoria mercadoria, Cotação cotação)
: this(mercadoria, cotação, mercadoria.ÍndiceArredondado)
{ }
