// GET: Ordems/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Ordem ordem = db.Ordems.Find(id);
if (ordem == null)
{
return(HttpNotFound());
}
return(View(ordem));
}
public IHttpActionResult DeleteOrdem(int id)
{
Ordem ordem = db.Ordem.Find(id);
if (ordem == null)
{
return(NotFound());
}
db.Ordem.Remove(ordem);
db.SaveChanges();
return(Ok(ordem));
}
// GET: Ordems/Details/5
public async Task <ActionResult> Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Ordem ordem = await db.Ordems.FindAsync(id);
if (ordem == null)
{
return(HttpNotFound());
}
return(View(ordem));
}
public async Task <IHttpActionResult> DeleteOrdem(string id)
{
Ordem ordem = await db.Ordem.FindAsync(id);
if (ordem == null)
{
return(NotFound());
}
db.Ordem.Remove(ordem);
await db.SaveChangesAsync();
return(Ok(ordem));
}
public async Task <IHttpActionResult> PutOrdem(long id_usuario, Ordem ordem)
{
string mensagem = config.Confirmar_venda(ordem.ordem1, id_usuario, ordem.observacao);
try
{
await db.SaveChangesAsync();
}
catch
{
}
return(Ok(mensagem));
}
public ActionResult Continuar(Models.CheckoutDetalhesViewModel detalhes)
{
if (ModelState.IsValid)
{
if (detalhes.CcValidade <= DateTime.Now)
{
ModelState.AddModelError("", "Cartão de crédito expirado");
}
if (ModelState.IsValid)
{
var ordem = new Ordem
{
DataDeCriacao = DateTime.Now,
DataDeEntrega = DateTime.Now.AddDays(5),
ClienteId = User.Identity.GetUserId(),
Endereco = detalhes.Endereco,
CEP = detalhes.CEP,
CcNumero = detalhes.CcNumero,
CcValidade = detalhes.CcValidade,
OrdemItems = CarrinhoDeCompras.Itens.Values.Select(i => new OrdemItem
{
Preco = i.PrecoTotal,
ProdutoId = i.ProdutoId,
Quantidade = i.Quantidade
}).ToArray()
};
_ctx.Ordens.Add(ordem);
_ctx.SaveChanges();
CarrinhoDeCompras.Limpar();
return(RedirectToAction("CompraRealizadaComSucesso", new { ordemId = ordem.Id }));
}
}
var errors = new List <ModelError>();
foreach (var modelState in ViewData.ModelState.Values)
{
foreach (ModelError error in modelState.Errors)
{
errors.Add(error);
}
}
return(View(detalhes));
}
// GET: Ordems/Edit/5
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Ordem ordem = await db.Ordems.FindAsync(id);
if (ordem == null)
{
return(HttpNotFound());
}
ViewBag.ClasseID = new SelectList(db.Classes, "ID", "Nome", ordem.ClasseID);
return(View(ordem));
}
// GET: OrdemAPI/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Ordem ordem = db.Ordem.Find(id);
if (ordem == null)
{
return(HttpNotFound());
}
ViewBag.CustomizarId = new SelectList(db.Customizars, "CustomizarId", "Nome", ordem.CustomizarId);
return(View(ordem));
}
// GET: Ordens/Edit/5
public async Task <ActionResult> Edit(Guid?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Ordem ordem = await db.Ordens.FindAsync(id);
if (ordem == null)
{
return(HttpNotFound());
}
await AcoesViewBag();
return(View(ordem));
}
public NovoPedidoForm(Ordem ordem = null)
{
InitializeComponent();
groupBebida.Enabled = false;
groupBoxTroco.Visible = false;
checkBoxTroco.Visible = false;
PopulaComboPagamento();
var saborRepositorio = new SaborRepositorio(new PizzariaContext());
_saborServico = new SaborServico(saborRepositorio);
AtualizarSaborPizza();
this.AtualizarSaborBebida();
}
static void Main(string[] args)
{
Console.WriteLine("Enter Client Data");
Console.WriteLine("Name:");
string nome = Console.ReadLine();
Console.WriteLine("Email");
string email = Console.ReadLine();
Console.Write("Birh date (DD/MM/YYY)");
DateTime birthd = DateTime.Parse(Console.ReadLine());
Client Cal = new Client(nome, email, birthd);
Console.WriteLine("Enter the order status");
OrderStatus orderStatus = Enum.Parse <OrderStatus>(Console.ReadLine().ToUpper());
Ordem order = new Ordem(DateTime.Now, orderStatus, Cal);
Console.WriteLine("How many items to this order?");
int n = int.Parse(Console.ReadLine());
for (int i = 1; i <= n; i++)
{
Console.WriteLine("Enter order#" + i + " item data");
Console.WriteLine("Name of the Product");
string nam = Console.ReadLine();
Console.WriteLine("Enter product price");
double price = double.Parse(Console.ReadLine());
Console.WriteLine("Quantity:");
int quant = int.Parse(Console.ReadLine());
Product p = new Product(nam, price);
OrderItem orderItem = new OrderItem(quant, price, p);
order.AddItem(orderItem);
}
Console.WriteLine();
Console.WriteLine("ORDER SUMMARY:");
Console.WriteLine(order);
Console.ReadLine();
}
private void ExibirOrdenado(Ordem ordem)
{
var ordemDescricao = ordem == Ordem.Asc ? "crescente" : "descendente";
Console.WriteLine($"Imprimir todos os números da lista na ordem {ordemDescricao}.");
if (ordem == Ordem.Asc)
{
listaDeInteiros.OrderBy(x => x).ToList().ForEach(n => Console.WriteLine(n));
}
else
{
listaDeInteiros.OrderByDescending(x => x).ToList().ForEach(n => Console.WriteLine(n));
}
Console.ReadLine();
}
public ActionResult Venda(Ordem ordem)
{
ViewBag.IDAtivoCompra = new SelectList(ordxativCompra, "Ativo.IDAtivo", "Ativo.Descricao");
ordem.IDOrdem = ordens.Count + 1;
ordem.TipoOrdem = "Venda";
ordens.Add(ordem);
historico = (from ord in ordens
join ativ in ativos on ord.IDAtivo equals ativ.IDAtivo into ordxativ
from ativ in ordxativ.DefaultIfEmpty()
select new OrdemXAtivoModel {
Ordem = ord, Ativo = ativ
});
ordxativ.AddRange(historico);
return(View("Index"));
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
IList <Contrato> lContratos = ContratoBLL.Instance.Listar(Ordem <Contrato> .ASC(x => x.DataConcessao), Ordem <Contrato> .ASC(x => x.Empregado.Nome));
IList <Contrato> lContratosLiberados = new List <Contrato>();
foreach (Contrato lContrato in lContratos)
{
if (lContrato.Situacao == ESituacaoContrato.Liberado)
{
lContratosLiberados.Add(lContrato);
}
}
GridSolicitados.DataSource = lContratosLiberados;
GridSolicitados.DataBind();
if (GridSolicitados.Rows.Count == 0)
{
lblMsgSolicitados.Visible = true;
}
}
if (Request.QueryString["acao"] != null)
{
if (Request.QueryString["acao"].Equals("confirmar"))
{
try
{
Contrato lContrato = ContratoBLL.Instance.BuscarPorId(Convert.ToInt32(Request.QueryString["id"]));
if (lContrato.Situacao == ESituacaoContrato.Liberado)
{
lContrato.Situacao = ESituacaoContrato.Ativo;
ContratoBLL.Instance.Persistir(lContrato);
Web.ExibeAlerta(Page, "Pagamento Confirmado. Contrato Ativo!", "PagamentoConcessao.aspx");
}
else
{
throw new OperacaoNaoRealizadaException();
}
}
catch (BusinessException ex)
{
Web.ExibeAlerta(Page, ex.Message);
}
}
}
}
public SpreadPorMoedaResult ObtemSpreadPorMoeda(IEnumerable <OrdensPorCorretora> requestModel)
{
var ordensSpread = new Dictionary <string, Ordem>();
foreach (var ordensCorretora in requestModel)
{
var precoTop = ordensCorretora.Ordens.First().Preco;
var quantidadeTop = ordensCorretora.Ordens.Where(o => o.Preco == precoTop).Sum(o => o.Quantidade);
Ordem topOrdemCorretora = new Ordem(precoTop, quantidadeTop);
ordensSpread.Add(ordensCorretora.Corretora, topOrdemCorretora);
}
CarregaOportunidades(ordensSpread);
return(new SpreadPorMoedaResult());
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
IList <Contrato> lContratos = ContratoBLL.Instance.Listar(Ordem <Contrato> .ASC(x => x.DataConcessao), Ordem <Contrato> .ASC(x => x.Empregado.Nome));
IList <Contrato> lContratosSolicitados = new List <Contrato>();
foreach (Contrato lContrato in lContratos)
{
if (lContrato.Situacao == ESituacaoContrato.Solicitado)
{
lContratosSolicitados.Add(lContrato);
}
}
GridSolicitados.DataSource = lContratosSolicitados;
GridSolicitados.DataBind();
if (GridSolicitados.Rows.Count == 0)
{
lblMsgSolicitados.Visible = true;
}
}
if (Request.QueryString["acao"] != null)
{
if (Request.QueryString["acao"].Equals("liberar"))
{
try
{
Contrato lContrato = ContratoBLL.Instance.BuscarPorId(Convert.ToInt32(Request.QueryString["id"]));
ContratoBLL.Instance.LiberarContrato(lContrato);
string lArquivo = ContratoBLL.Instance.GerarTxt(lContrato);
var fi = new FileInfo(lArquivo);
Response.Clear();
Response.ContentType = "text/txt";
Response.AddHeader("Content-Disposition", "attachment; filename=" + fi.Name);
Response.WriteFile(lArquivo);
Web.ExibeAlerta(Page, "Contrato Liberado!");
Response.End();
}
catch (BusinessException ex)
{
Web.ExibeAlerta(Page, ex.Message);
}
}
}
}
public async Task <Ordem> CriarOrdemAsync(string emailComprador, string cestaId)
{
// Obter cesta de compras
CestaCliente cesta = await _basketRepository.GetBasketAsync(cestaId);
// Obter itens
var itens = new List <VagaAlugada>();
foreach (BasketItem item in cesta.ItensCestaCliente)
{
//Estacionamento estacionamento = await _dataContext.Estacionamentos.FindAsync(item.Id);
//Estacionamento estacionamento = await _context.Estacionamentos.Include(e => e.Endereco).FirstOrDefaultAsync(x => x.Id == item.Id);
var spec = new EstacionamentoComEnderecoSpecification(item.Id);
Estacionamento estacionamento = await _unitOfWork.Repositorio <Estacionamento>().ObterEntidadeComSpec(spec);
VagaOrdenada vagaOrdenada = new VagaOrdenada(estacionamento.NomeEstacionamento, estacionamento.Endereco.NomeLogradouro, estacionamento.Endereco.Numero, estacionamento.Endereco.Cep, estacionamento.Endereco.Bairro, estacionamento.Endereco.Cidade, estacionamento.Endereco.Estado);
VagaAlugada vagaAlugada = new VagaAlugada(vagaOrdenada, (decimal)estacionamento.PrecoHora, item.Quantidade);
itens.Add(vagaAlugada);
}
// Calcular total
var total = itens.Sum(ItensCestaCliente => ItensCestaCliente.Preco * ItensCestaCliente.Quantidade);
// verificar se a ordem já existe
// Criar ordem nova
Ordem ordem = new Ordem(itens, emailComprador, total /*cestaCliente.PaymentIntentId*/);
_unitOfWork.Repositorio <Ordem>().Adicionar(ordem);
// salvar no banco de dados
var resultado = await _unitOfWork.Complete();
// Se o resultado for zero retornar null
if (resultado <= 0)
{
return(null);
}
// Deletar cesta de compras (por que a ordem já foi retornada e salva)
await _basketRepository.DeleteBasketAsync(cestaId);
//retorna nova ordem
return(ordem);
}
public async Task <ActionResult> Compra([Bind(Include = "OrdemId,Tipo,Preco,Quantidade,AcaoId")] Ordem ordem)
{
if (ModelState.IsValid)
{
var rd = new Random((int)DateTime.Now.Ticks);
var acao = await db.Acoes.FindAsync(ordem.AcaoId);
ordem.OrdemId = Guid.NewGuid();
ordem.UsuarioId = Guid.Parse(User.Identity.GetUserId());
ordem.DataHora = DateTime.Now;
ordem.Chance = OrdensChances.Compra(acao.Preco, ordem.Preco);
var percentual = (decimal)rd.NextDouble() * 100;
if (ordem.Chance >= percentual)
{
db.UsuariosAcoes.Add(new UsuarioAcao()
{
UsuarioAcaoId = Guid.NewGuid(),
AcaoId = ordem.AcaoId,
Ativo = true,
Compra = DateTime.Now,
Preco = ordem.Preco,
UsuarioId = ordem.UsuarioId,
Quantidade = ordem.Quantidade,
Total = ordem.Preco * ordem.Quantidade,
OrdensUsuariosAcoes = new List <OrdemUsuarioAcao>()
{
new OrdemUsuarioAcao
{
OrdemUsuarioAcaoId = Guid.NewGuid(),
OrdemId = ordem.OrdemId
}
}
});
}
db.Ordens.Add(ordem);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
await AcoesViewBag();
return(View(ordem));
}
public async Task <SaveOrdemResponse> SaveAsync(Ordem ordem)
{
try
{
await _ordemRepository.AddAsync(ordem);
if (_ordemValidator.CheckOrdemRules(ordem))
{
await _unitOfWork.CompleteAsync();
}
return(new SaveOrdemResponse(ordem));
}
catch (Exception ex)
{
return(new SaveOrdemResponse($"Error : {ex.Message}"));
}
}
private static Ordem ConstruirOrdens(string digitos, int indiceDaClasse)
{
Ordem ordemAtual = null;
for (var indiceDaOrdem = 0; indiceDaOrdem < ObterNumeroDeOrdens(digitos, indiceDaClasse); indiceDaOrdem++)
{
var tipoOrdemAtual = _ordens[indiceDaOrdem];
if (digitos.Contains('-'))
{
digitos = digitos.Replace("-", "");
}
var digitoParaEncapsular = digitos.ObterDigitoPorOrdemEClasse(indiceDaClasse, indiceDaOrdem);
ordemAtual = tipoOrdemAtual.Construir <Ordem>(digitoParaEncapsular, ordemAtual);
}
return(ordemAtual);
}
public async Task <IActionResult> CreateByVM(Ordem ordem, string tipoOrdem)
{
var tipoOrdemId = Convert.ToInt32(tipoOrdem);
if (tipoOrdemId <= 0)
{
return(View(this.ordemVM));
}
ordem.TipoOrdem = this.context.TipoOrdens.FirstOrDefault(to => to.Id.Equals(tipoOrdemId));
if (ModelState.IsValid)
{
this.uof.OrdemRepository.Add(ordem);
return(RedirectToAction(nameof(Index)));
}
return(View(this.ordemVM));
}
public async Task <IActionResult> Post(Ordem model)
{
//Verifica se a quantidade é multipla do Lote minimo
Ativo query =
(from ativo in _context.Ativo
where ativo.IdAtivo == model.FkIdAtivo
select ativo)
.First();
if (model.Quantidade % query.LoteMinimo != 0)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "A quantidade deve ser multipla do lote minimo"));
}
//Verifica se a ClasseNegociacao eh "C" ou "V" desconsiderando diferenca entre maiusculas e minusculas
if (String.Compare(model.ClasseNegociacao, "C", true) != 0)
{
if (String.Compare(model.ClasseNegociacao, "V", true) != 0)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Classe negociacao deve ser C- Compra ou V venda"));
}
else
{
model.Quantidade = model.Quantidade * (-1);
}
}
try
{
_repo.Add(model);
if (await _repo.SaveChangesAsync())
{
return(Created($"/api/Ordens/{model.IdOrdem}", model));
}
}
catch (System.Exception)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Banco de Dados falhou"));
}
return(BadRequest());
}
static void Main(string[] args)
{
Console.WriteLine("Entre com os dados do cliente:");
Console.Write("Nome: ");
string nome = Console.ReadLine();
Console.Write("Email: ");
string email = Console.ReadLine();
Console.Write("Data de nascimento(DD/MM/YYYY): ");
DateTime dataNascimento = DateTime.Parse(Console.ReadLine());
Console.WriteLine("Entre com a ordem dos dados: ");
Console.Write("Status: ");
OrderStatus status = Enum.Parse <OrderStatus>(Console.ReadLine());
Cliente cliente = new Cliente(nome, email, dataNascimento);
Ordem ordem = new Ordem(DateTime.Now, status, cliente);
Console.Write("Numero da ordem dos items: ");
int n = int.Parse(Console.ReadLine());
for (int i = 1; i <= n; i++)
{
Console.WriteLine($"Entre #{i} dados do item:");
Console.Write("Nome do produto: ");
string nome1 = Console.ReadLine();
Console.Write("Preço do produto: ");
double preco = double.Parse(Console.ReadLine(), CultureInfo.InvariantCulture);
Produto produto = new Produto(nome1, preco);
Console.Write("Quantidade: ");
int quantidade = int.Parse(Console.ReadLine());
OrdemItem item = new OrdemItem(quantidade, preco, produto);
ordem.AddItems(item);
}
Console.WriteLine();
Console.WriteLine("RESUMO DA ORDEM:");
Console.WriteLine(ordem);
}
public async Task <IActionResult> Create([Bind("Nome,Id")] Ordem ordem, string tipoOrdem)
{
var tipoOrdemId = Convert.ToInt32(tipoOrdem);
if (tipoOrdemId <= 0)
{
ViewBag.TipoOrdem = new SelectList(this.context.TipoOrdens, "Id", "Nome");
return(View());
}
ordem.TipoOrdem = this.context.TipoOrdens.FirstOrDefault(to => to.Id.Equals(tipoOrdemId));
if (ModelState.IsValid)
{
this.uof.OrdemRepository.Add(ordem);
return(RedirectToAction(nameof(Index)));
}
return(View(ordem));
}
public IHttpActionResult Gravar(Ordem request)
{
OrdemResponse response = null;
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
response = repositorio.Gravar(request);
}
catch (Exception)
{
throw;
}
return(Ok(response));
}
public async Task <ValidationResult> Handle(RegistrarOrdemCommand message, CancellationToken cancellationToken)
{
if (!message.EhValido())
{
return(message.ValidationResult);
}
var ordem = new Ordem(
message.Id, message.IdSolicitante, message.IdSolicitacao,
message.CodDepartamento, message.Descricao, message.Solucao, message.DataCadastro, message.DataSolucao);
_ordemRepository.Adicionar(ordem);
ordem.AdicionarEvento(
new OrdemRegistradaEvent(
message.Id, message.IdSolicitante, message.IdSolicitacao,
message.CodDepartamento, message.Descricao, message.Solucao,
message.DataCadastro, message.DataSolucao));
return(await PersistirDados(_ordemRepository.UnitOfWork));
}
public Ordem Create(Ordem ordem)
{
var result = _context.Ordem.Any(p => p.Numero.Equals(ordem.Numero));
if (result == true)
{
return(null);
}
try
{
ordem.Id = Guid.NewGuid().ToString();
_context.Ordem.Add(ordem);
_context.SaveChanges();
}
catch (Exception ex)
{
throw ex;
}
return(ordem);
}
public IEnumerable <SelectListItem> DeterminarOrdemViewBag(Ordem ordem)
{
List <SelectListItem> itens = new List <SelectListItem>();
var todosItem = new SelectListItem {
Text = "Todos", Value = "Todos"
};
var recenteItem = new SelectListItem {
Text = "Recente", Value = "Recente"
};
var novoItem = new SelectListItem {
Text = "Novo", Value = "Novo"
};
itens.Add(todosItem);
itens.Add(recenteItem);
itens.Add(novoItem);
IEnumerable <SelectListItem> listaEnumerada = (IEnumerable <SelectListItem>)itens;
return(itens);
}
/// <summary>
/// Método que busca no banco de dados todas ordens efetuadas em uma determinada data
/// </summary>
/// <param name="data"></param>
/// <returns description="Retorna uma lista com as ordens buscadas no banco de dados"></returns>
public List <Ordem> getOrdem(DateTime data)
{
using (SqlConnection conn = new SqlConnection(conString))
{
try
{ //Lista de ativos a ser retornada
List <Ordem> listaOrdens = new List <Ordem>();
//Conexao aberta
conn.Open();
//Query para selecionar todos os ativos em uma determinada data
SqlCommand cmd = new SqlCommand("SELECT O.quantidade AS [quantidade],O.preco AS [preco],FORMAT(O.data,'dd/MM/yyyy') AS [data], O.classe_negociacao AS [negociacao],A.descricao AS [Ativo],O.id_ordem FROM dbo.Ordem as O INNER JOIN dbo.Ativo AS A ON O.fk_id_ativo = A.id_ativo WHERE O.data = @novadata ORDER BY O.data", conn);
cmd.Parameters.AddWithValue("@novadata", data);
SqlDataReader dataReader = cmd.ExecuteReader();
//Loop linha a linha do resultado da query no banco de dados
while (dataReader.Read())
{
int index = 0;
Ordem ordem = new Ordem();
ordem.quantidade = Convert.ToInt32(dataReader.GetDouble(index++));
ordem.preco = dataReader.GetDouble(index++);
ordem.data = dataReader.GetString(index++);
ordem.negociacao = Convert.ToChar(dataReader.GetString(index++));
ordem.nomeAtivo = dataReader.GetString(index++);
ordem.id = dataReader.GetInt32(index++);
listaOrdens.Add(ordem);
}
dataReader.Close();
return(listaOrdens);
}
catch (Exception e)
{
throw e;
}
finally
{
conn.Close();
}
}
}
public async Task <IActionResult> Create([Bind("ID,data,hora,qdte")] Ordem ordem, IFormCollection collection)
{
int idProduto = Convert.ToInt16(collection["Produto"]);
int idCliente = Convert.ToInt16(collection["Cliente"]);
if (ModelState.IsValid)
{
var prod = await _context.Produto.FindAsync(idProduto);
ordem.produto = prod;
var cli = await _context.Cliente.FindAsync(idCliente);
ordem.cliente = cli;
_context.Add(ordem);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(ordem));
}
public PrimeiraClasse(Ordem ordem, Classe classeAnterior = null)
{
Ordem = ordem;
}
public static List<Saldo> Obter(bool incluirPeso, bool incluirReferências,
Entidades.Fornecedor fornecedorÚnico, Ordem ordem, bool usarPesoMédio)
{
if (!incluirPeso && !incluirReferências)
return new List<Saldo>();
StringBuilder consulta = new StringBuilder();
consulta.Append("select v.inicio, v.referenciafornecedor as referenciafornecedor, v.foradelinha, m.referencia, ");
consulta.Append(usarPesoMédio ? " m.peso " : " ifnull(e.peso, m.peso) " );
consulta.Append(" as peso, sum(ifnull(e.entrada,0)) as entrada,sum(ifnull(e.venda,0)) as venda ,sum(ifnull(e.devolucao,0)) as devolucao,sum(ifnull(e.saldo,0)) as saldo, " +
" m.depeso, v.fornecedor from mercadoria m left join estoque_saldo e " +
" on e.referencia=m.referencia " +
" join vinculomercadoriafornecedor v on m.referencia=v.mercadoria " +
" WHERE m.foradelinha=0 AND " +
(fornecedorÚnico != null ? " v.fornecedor= " + DbTransformar(fornecedorÚnico.Código) + " AND " : "") +
" ( m.depeso=" + (incluirPeso ? "1" : "0") +
" or m.depeso=" + (incluirReferências ? "0" : "1") +
" ) ");
consulta.Append(" GROUP BY ");
string peso = (usarPesoMédio ? "m.peso" : "e.peso");
consulta.Append(" m.referencia,");
consulta.Append(peso);
consulta.Append(", inicio, referenciafornecedor, v.fornecedor ");
consulta.Append(" ORDER BY ");
consulta.Append((ordem == Ordem.FornecedorReferênciaPeso ? " v.fornecedor , " : " "));
consulta.Append(" m.referencia, ");
consulta.Append(peso);
return Mapear<Saldo>(consulta.ToString());
}
