/// <summary>
/// Ocorre ao exibir a base de dados de acerto.
/// </summary>
protected override void AoExibir(bool primeiraVez)
{
base.AoExibir();
bool liberarPrazo = true;
foreach (Entidades.Relacionamento.Saída.Saída saída in acerto.Saídas)
if (!(liberarPrazo &= saída.ObterTravadoEmCache()))
break;
if (liberarPrazo)
{
botãoLiberarPrevisão.Text = "Liberar mais prazo";
informaçõesAcerto.PermitirAlteração = true;
informaçõesAcerto.LiberarPrazo = false;
}
else
{
botãoLiberarPrevisão.Text = "Alterar";
informaçõesAcerto.PermitirAlteração = false;
informaçõesAcerto.LiberarPrazo = true;
}
botãoLiberarPrevisão.Visible = true;
if (!primeiraVez)
{
acerto = AcertoConsignado.ObterAcerto(acerto.Código);
listaDocumentosAcerto.Recarregar(acerto);
}
simulaçãoAcerto1.Carregar(acerto);
}
/// <summary>
/// Obtém vendas vinculadas a um acerto.
/// </summary>
public static List<VendaAcerto> ObterVendas(AcertoConsignado acerto)
{
List<VendaAcerto> vendas = Mapear<VendaAcerto>(
"SELECT codigo, data FROM venda WHERE acerto = " + DbTransformar(acerto.Código));
return vendas;
}
public void Carregar(AcertoConsignado acerto)
{
this.acerto = acerto;
if (!bg.IsBusy)
bg.RunWorkerAsync();
}
public void Recarregar(AcertoConsignado acerto)
{
AcertoConsignado = acerto;
exibiçãoDocumentos1.Recarregar(acerto);
exibiçãoDocumentos2.Recarregar(acerto);
exibiçãoDocumentos3.Recarregar(acerto);
}
private JanelaEscolhaAcerto(Entidades.Pessoa.Pessoa cliente, AcertoConsignado[] acertos)
{
InitializeComponent();
this.pessoa = cliente;
foreach (AcertoConsignado acerto in acertos)
AdicionarAcerto(acerto);
lblInstrução.Text = string.Format(
lblInstrução.Text, cliente.Nome);
}
public void Recarregar(AcertoConsignado acerto)
{
this.acerto = acerto;
if (!bg.IsBusy)
{
flowLayoutPanel.SuspendLayout();
flowLayoutPanel.Controls.Clear();
bg.RunWorkerAsync();
}
}
private int CompararAcerto(AcertoConsignado a, AcertoConsignado b)
{
if (a.Previsão.HasValue && b.Previsão.HasValue)
return a.Previsão.Value.CompareTo(b.Previsão.Value);
else if (a.Previsão.HasValue)
return 1;
else if (b.Previsão.HasValue)
return -1;
else
return a.DataMarcação.CompareTo(b.DataMarcação);
}
private ListViewItem ConstruirItem(AcertoConsignado acerto)
{
ListViewItem item = new ListViewItem();
item.Text = acerto.Código.ToString();
item.SubItems.Add(acerto.Cliente.Nome);
item.SubItems.Add(acerto.DataMarcação.ToString("dd/MM/yyyy"));
item.SubItems.Add(acerto.Previsão.HasValue ? acerto.Previsão.Value.ToString("dd/MM/yyyy") : "Não marcado");
//item.SubItems.Add(acerto.CalcularValorMercadorias().ToString("C"));
item.Group = ObterGrupo(acerto);
item.Tag = acerto;
return item;
}
/// <summary>
/// Adiciona acerto à lista.
/// </summary>
private void AdicionarAcerto(AcertoConsignado acerto)
{
ListViewItem item = new ListViewItem();
item.Text = acerto.Código.ToString();
if (acerto.Previsão.HasValue)
item.SubItems.Add(acerto.Previsão.Value.ToLongDateString());
else
item.SubItems.Add("Sem previsão");
if (acerto.DataEfetiva.HasValue)
item.ForeColor = SystemColors.GrayText;
lstAcertos.Items.Add(item);
item.Tag = acerto;
}
public void MostrarAcertos(AcertoConsignado[] value)
{
acertos = new List<AcertoConsignado>(value);
acertos.Sort(new Comparison<AcertoConsignado>(CompararAcerto));
lst.Items.Clear();
ListViewItem[] itens = new ListViewItem[acertos.Count];
int x = 0;
foreach (AcertoConsignado acerto in acertos)
itens[x++] = ConstruirItem(acerto);
lst.Items.AddRange(itens);
lst.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
}
/// <summary>
/// Dado uma chave (ref, peso),
/// retorna o objeto ÍndiceSaídaMercadoria, contendo a lista de indices daquela mercadoria.
/// </summary>
public static Dictionary<string, ÍndicesSaídaMercadoria> ObterHashÍndicesSaídas(AcertoConsignado acerto)
{
Dictionary<string, ÍndicesSaídaMercadoria> hash = new Dictionary<string, ÍndicesSaídaMercadoria>(StringComparer.Ordinal);
using (IDbCommand cmd = Conexão.CreateCommand())
{
cmd.CommandText = " select referencia,peso,indice from saidaitem, saida where "
+ " saidaitem.saida=saida.codigo "
+ " and acerto= " + acerto.Código.ToString()
+ " group by referencia, peso, indice having sum(quantidade) > 0 ";
using (IDataReader leitor = cmd.ExecuteReader())
{
while (leitor.Read())
{
string referencia = leitor.GetString(0);
double peso = leitor.GetDouble(1);
double indice = Math.Round(leitor.GetDouble(2), 2);
string chave = GerarChave(referencia, peso);
ÍndicesSaídaMercadoria item = null;
if (!hash.TryGetValue(chave, out item))
{
item = new ÍndicesSaídaMercadoria(referencia, peso);
hash.Add(chave, item);
}
if (!item.Índices.Contains(indice))
item.Índices.Add(indice);
}
leitor.Close();
}
}
return hash;
}
public void Carregar(AcertoConsignado acerto)
{
this.acerto = acerto;
double totalÍndiceSaída;
double totalÍndiceVendidoMenosDevolvido;
double totalVendaPeça;
double porcentagemObtida;
double porcentagemDada;
desconto =
acerto.CalcularDesconto(out totalÍndiceSaída,
out totalÍndiceVendidoMenosDevolvido,
out totalVendaPeça,
out porcentagemObtida,
out porcentagemDada);
txtDesconto.Text = desconto.ToString("C");
txtPorcentagemVendida.Text = porcentagemObtida.ToString() + " % ";
txtÍndiceLevado.Text = totalÍndiceSaída.ToString();
txtÍndiceVendido.Text = totalÍndiceVendidoMenosDevolvido.ToString();
txtÍndiceVendidoPeça.Text = totalVendaPeça.ToString();
txtPorcentagemDesconto.Text = porcentagemDada.ToString() + " %";
}
internal void DefinirAcertoConsignado(AcertoConsignado value)
{
acertoConsignado = value;
DefinirDesatualizado();
}
/// <summary>
/// Obtém retornos vinculados a um acerto.
/// </summary>
public static List<Retorno> ObterRetornos(AcertoConsignado acerto)
{
List<Retorno> retornos = Mapear<Retorno>(
"SELECT * FROM retorno WHERE acerto = " + DbTransformar(acerto.Código));
// Itens serão recuperados quando necessário.
//RecuperarColeções(retornos);
return retornos;
}
/// <summary>
/// Dado a numeração dos documentos,
/// recupera todas as mercadorias que compõe o acerto
/// </summary>
public ControleAcertoMercadorias(AcertoConsignado acerto)
{
this.acerto = acerto;
this.hash = new Dictionary<string, SaquinhoAcerto>(StringComparer.Ordinal);
Entidades.Relacionamento.Saída.Saída.ObterAcerto(CódigoSaídas, hash, acerto.FórmulaAcerto);
Entidades.Relacionamento.Retorno.Retorno.ObterAcerto(CódigoRetornos, hash, acerto.FórmulaAcerto);
Entidades.Relacionamento.Venda.Venda.ObterAcerto(CódigoVendas, hash, acerto.FórmulaAcerto);
}
/// <summary>
/// Restringe a verificação às mercadorias relacionadas
/// como saída para um acerto.
/// </summary>
/// <param name="acerto">Acerto a ser considerado.</param>
/// <remarks>
/// Processo realizado em segundo plano.
/// </remarks>
public void Restringir(AcertoConsignado acerto)
{
mercadorias = null;
foreach (DigitaçãoComum controle in controles)
DesmarcarMercadorias(controle);
if (acerto != null)
mercadorias = ÍndicesSaídaMercadoria.ObterHashÍndicesSaídas(acerto);
if (ligado)
{
foreach (DigitaçãoComum controle in controles)
MarcarMercadorias(controle);
}
}
/// <summary>
/// Cadastra novo acerto.
/// </summary>
private static AcertoConsignado CadastrarAcerto(Entidades.Pessoa.Pessoa pessoa, DateTime? previsão)
{
AcertoConsignado acerto = new AcertoConsignado();
acerto.Previsão = previsão;
acerto.FuncConsignado = Funcionário.FuncionárioAtual;
acerto.Cliente = pessoa;
return acerto;
}
public void Carregar(AcertoConsignado acerto)
{
this.acerto = acerto;
if (Representante.ÉRepresentante(acerto.Cliente))
opçãoLançarVendas.Enabled = false;
else
opçãoLançarVendas.Enabled &= !acerto.Acertado;
opçãoZerarAcerto.Enabled &= !acerto.Acertado;
}
public static List<Saída> ObterSaídas(AcertoConsignado acerto)
{
List<Saída> saídas = Mapear<Saída>(
"SELECT * FROM saida WHERE acerto = " + DbTransformar(acerto.Código));
return saídas;
}
private ListViewGroup ObterGrupo(AcertoConsignado acerto)
{
ListViewGroup grupo;
if (!acerto.Previsão.HasValue)
return lst.Groups[0];
else if (!hashGrupo.TryGetValue(acerto.Previsão.Value, out grupo))
{
grupo = new ListViewGroup("Acerto para " + acerto.Previsão.Value.ToLongDateString());
lst.Groups.Add(grupo);
hashGrupo.Add(acerto.Previsão.Value, grupo);
}
return grupo;
}
private static List<AcertoConsignado> Obter(string consulta, int inicioAcertoConsignado, int inicioPessoa, int inicioPessoaFisica)
{
List<AcertoConsignado> lista = new List<AcertoConsignado>();
IDataReader leitor = null;
IDbConnection conexão = Conexão;
lock (conexão)
{
using (IDbCommand cmd = conexão.CreateCommand())
{
cmd.CommandText = consulta;
try
{
using (leitor = cmd.ExecuteReader())
{
while (leitor.Read())
{
AcertoConsignado entidade = new AcertoConsignado();
entidade.código = (ulong)leitor.GetInt64(inicioAcertoConsignado);
entidade.cliente = Pessoa.Pessoa.ObterPessoa(leitor, inicioPessoa, inicioPessoaFisica, 0);
entidade.funcConsignado = Funcionário.ObterPessoa((ulong)leitor.GetInt64(inicioAcertoConsignado + 2));
if (leitor["funcAcerto"] != DBNull.Value)
entidade.funcAcerto = Funcionário.ObterPessoa((ulong)leitor.GetInt64(inicioAcertoConsignado + 3));
if (leitor["previsao"] != DBNull.Value)
entidade.previsão = leitor.GetDateTime(inicioAcertoConsignado + 4);
if (leitor["dataEfetiva"] != DBNull.Value)
entidade.dataEfetiva = leitor.GetDateTime(inicioAcertoConsignado + 5);
entidade.dataMarcação = leitor.GetDateTime(inicioAcertoConsignado + 6);
if (leitor["cotacao"] != DBNull.Value)
entidade.cotação = leitor.GetDouble(inicioAcertoConsignado + 7);
entidade.fórmulaAcerto = (FórmulaAcerto)Enum.ToObject(typeof(FórmulaAcerto), leitor.GetInt32(inicioAcertoConsignado + 8));
entidade.DefinirCadastrado();
entidade.DefinirAtualizado();
lista.Add(entidade);
}
}
}
finally
{
if (leitor != null)
leitor.Close();
}
}
}
return lista;
}