/// <summary>
/// Muestra los productos segun la categoria seleccionada
/// </summary>
/// <param name="categoria">La categoria seleccionada</param>
public void MostrarProductoPorCategoria(TipoCategoria categoria)
{
switch (categoria)
{
case TipoCategoria.Electricidad:
MostrarProductos(Productos.FindAll(x => x.TipoCategoria == categoria));
break;
case TipoCategoria.Construccion:
MostrarProductos(Productos.FindAll(x => x.TipoCategoria == categoria));
break;
case TipoCategoria.Plomeria:
MostrarProductos(Productos.FindAll(x => x.TipoCategoria == categoria));
break;
case TipoCategoria.Herramientas:
MostrarProductos(Productos.FindAll(x => x.TipoCategoria == categoria));
break;
default:
MostrarProductos();
break;
}
}
public IEnumerable <ArticulosModel> GetArticulosBusquedas(TipoCategoria flujo = TipoCategoria.Ambas)
{
using (var con = new SqlConnection(_db.Database.Connection.ConnectionString))
{
using (var cmd = new SqlCommand(CadenaBusquedaArticulos(flujo), con))
{
cmd.Parameters.Add(new SqlParameter("@empresa", Empresa));
using (var ad = new SqlDataAdapter(cmd))
{
var tabla = new DataTable();
ad.Fill(tabla);
foreach (DataRow row in tabla.Rows)
{
yield return(new ArticulosModel()
{
Id = Funciones.Qnull(row["id"]),
Familia = Funciones.Qnull(row["Fkfamilias"]),
FamiliaDescripcion = Funciones.Qnull(row["Familias"]),
Materiales = Funciones.Qnull(row["Fkmateriales"]),
MaterialesDescripcion = Funciones.Qnull(row["Materiales"]),
Caracteristicas = Funciones.Qnull(row["Fkcaracteristicas"]),
CaracteristicasDescripcion = Funciones.Qnull(row["Caracteristicas"]),
Grosores = Funciones.Qnull(row["Fkgrosores"]),
GrosoresDescripcion = Funciones.Qnull(row["Grosores"]),
Acabados = Funciones.Qnull(row["Fkacabados"]),
AcabadosDescripcion = Funciones.Qnull(row["Acabados"]),
Descripcion = Funciones.Qnull(row["Descripcion"])
});
}
}
}
}
}
// GET
public IActionResult CreateOrEdit(int?id, TipoCategoria tipo, int?subCategoriaId = null, string returnUrl = "Index")
{
var categoriaViewModel = new CategoriaViewModel();
if (id > 0)
{
Categoria categoria = _context.Categorias.SingleOrDefault(m => m.CategoriaId == id && m.TipoCategoria == tipo);
if (categoria == null)
{
return(NotFound());
}
// AUTO MAPPER
categoriaViewModel = Mapper.Map <CategoriaViewModel>(categoria);
subCategoriaId = categoriaViewModel.SubCategoriaId; // SUBCATEGORIA SELECIONADA
}
ViewData["CategoriaId"] = new SelectList(_context.GetViewCategorias(id, true).Where(x => x.TipoCategoria == tipo), "CategoriaId", "Nome", subCategoriaId);
ViewData["returnUrl"] = returnUrl;
ViewBag.Tipo = tipo;
return(View(categoriaViewModel));
}
public static Categoria GetCategoria(TipoCategoria tipo)
{
switch (tipo)
{
case TipoCategoria.AlimentoGranel:
return(new Categoria("Alimento Granel", tipo));
case TipoCategoria.AlimentoUnitario:
return(new Categoria("Alimento Unitário", tipo));
case TipoCategoria.HigieneBeleza:
return(new Categoria("Higiene e Beleza", tipo));
case TipoCategoria.Duraveis:
return(new Categoria("Duraveis", tipo));
case TipoCategoria.Vestuario:
return(new Categoria("Vestuario", tipo));
case TipoCategoria.Farmacia:
return(new Categoria("Farmacia", tipo));
default:
return(new Categoria("Outro", TipoCategoria.Outro));
}
}
public ActionResult DeleteConfirmed(int id)
{
TipoCategoria tipoCategoria = db.TipoCategoria.Find(id);
db.TipoCategoria.Remove(tipoCategoria);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public IActionResult Index(TipoCategoria tipo, string filtro)
{
ViewData["Filtro"] = filtro;
var categorias = _context.GetViewCategorias().Where(x => x.TipoCategoria == tipo).Filtro(filtro);
var categoriasViewModel = Mapper.Map <IEnumerable <CategoriaViewModel> >(categorias);
ViewBag.Tipo = tipo;
return(View(categoriasViewModel));
}
public ActionResult Edit([Bind(Include = "ID,Nombre")] TipoCategoria tipoCategoria)
{
if (ModelState.IsValid)
{
db.Entry(tipoCategoria).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(tipoCategoria));
}
public ActionResult Create([Bind(Include = "ID,Nombre")] TipoCategoria tipoCategoria)
{
if (ModelState.IsValid)
{
db.TipoCategoria.Add(tipoCategoria);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(tipoCategoria));
}
// GET: /TipoCategorias/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TipoCategoria tipoCategoria = db.TipoCategoria.Find(id);
if (tipoCategoria == null)
{
return(HttpNotFound());
}
return(View(tipoCategoria));
}
public JsonResult ObterCategoriaPorId(TipoCategoria tipo, int id)
{
var categoria = _context.Categorias.Where(x => x.TipoCategoria == tipo).FirstOrDefault(x => x.CategoriaId == id);
if (categoria == null)
{
return new JsonResult("")
{
StatusCode = (int)HttpStatusCode.NotFound
}
}
;
var categoriaViewModel = Mapper.Map <CategoriaViewModel>(categoria);
return(new JsonResult(categoriaViewModel));
}
public TipoCategoria tiposCategoriaId(int id)
{
TipoCategoria result = new TipoCategoria();
using (db = new DMS.db.DB_DMsEntities())
{
result = (from da in db.CAT_Categoria
where da.IdCategoria == id
select new TipoCategoria
{
Codigo = da.IdCategoria,
Nombre = da.Nombre,
EsquemaFisico = da.Esquema
}).ToList().FirstOrDefault();
}
return(result);
}
public IActionResult Get(TipoCategoria categoria)
{
var veiculos = _veiculoRepository.ListarVeiculosPorCategoria((int)categoria);
var veiculosRetorno = new List <Veiculo>();
if (veiculos.Count > 0)
{
foreach (VeiculoDB veiculoDB in veiculos)
{
var modelo = _modeloRepository.ObterModeloPorId(veiculoDB.ModeloId);
var modeloRetorno = new Modelo(modelo.Id, modelo.Nome, _marcaRepository.ObterMarcaPorId(modelo.MarcaId));
var marca = _marcaRepository.ObterMarcaPorId(veiculoDB.MarcaId);
var veiculo = new Veiculo(veiculoDB, marca.Nome, modeloRetorno.Nome);
veiculosRetorno.Add(veiculo);
}
}
return(new OkObjectResult(veiculosRetorno));
}
public JsonResult ObterCategoriasPorTexto(TipoCategoria tipo, string q)
{
q = q != null?q.ToLower() : "";
var categorias = _context.GetViewCategorias().Where(x => x.TipoCategoria == tipo).Filtro(q);
if (categorias == null)
{
return new JsonResult("")
{
StatusCode = (int)HttpStatusCode.NotFound
}
}
;
var categoriasViewModel = Mapper.Map <List <CategoriaViewModel> >(categorias);
return(new JsonResult(categoriasViewModel));
}
public void asignarCategoria(TipoCategoria tc)
{
using (contextData cdt = new contextData())
{
cdt.Configuration.LazyLoadingEnabled = false;
try
{
cdt.TipoCategoria.Add(tc);
cdt.SaveChanges();
}
catch (Exception e)
{
string mensaje = "";
Log.Error(e, System.Reflection.MethodBase.GetCurrentMethod(), ref mensaje);
throw;
}
}
}
private string CadenaBusquedaArticulos(TipoCategoria flujo)
{
var sb = new StringBuilder();
sb.Append("select art.id,art.descripcionabreviada as Descripcion,SUBSTRING(art.id,0,3) as Fkfamilias, fp.descripcion as Familias ");
sb.Append(" ,SUBSTRING(art.id,3,3) as Fkmateriales, mp.descripcion as Materiales ");
sb.Append(" ,SUBSTRING(art.id,6,2) as Fkcaracteristicas, cp.descripcion as Caracteristicas ");
sb.Append(" ,SUBSTRING(art.id,8,2) as Fkgrosores, gp.descripcion as Grosores ");
sb.Append(" ,SUBSTRING(art.id,10,2) as Fkacabados, ap.descripcion as Acabados ");
sb.Append(" from articulos as art ");
sb.Append(" left join Familiasproductos as fp on fp.empresa=art.empresa and fp.id=SUBSTRING(art.id,0,3) ");
sb.Append(" left join Materiales as mp on mp.empresa=art.empresa and mp.id=SUBSTRING(art.id,3,3) ");
sb.Append(" left join Caracteristicaslin as cp on cp.empresa=art.empresa and cp.fkcaracteristicas=SUBSTRING(art.id,0,3) AND cp.id=SUBSTRING(art.id,6,2) ");
sb.Append(" left join Grosores as gp on gp.empresa = art.empresa and gp.id=SUBSTRING(art.id,8,2) ");
sb.Append(" left join Acabados as ap on ap.empresa = art.empresa and ap.id=SUBSTRING(art.id,10,2) ");
sb.AppendFormat(" Where art.empresa=@empresa and (art.categoria=0 or art.categoria={0})", (int)flujo);
var a = sb.ToString();
return(a);
}
public IActionResult CreateOrEdit(int id, CategoriaViewModel categoriaViewModel, string returnUrl = null)
{
ViewData["returnUrl"] = returnUrl;
if (!ModelState.IsValid)
{
TipoCategoria tipo = categoriaViewModel.TipoCategoria;
ViewBag.Tipo = tipo;
ViewData["CategoriaId"] = new SelectList(_context.GetViewCategorias(id, true).Where(x => x.TipoCategoria == tipo), "CategoriaId", "Nome", categoriaViewModel.SubCategoriaId);
return(View(categoriaViewModel));
}
var categoria = Mapper.Map <Categoria>(categoriaViewModel);
try
{
_context.Categorias.Update(categoria);
_context.SaveChanges();
TempData["alert-success"] = "Operação realizada com sucesso!";
}
catch (DbUpdateConcurrencyException)
{
if (!_context.Categorias.Any(x => x.CategoriaId == categoria.CategoriaId))
{
return(NotFound());
}
else
{
throw;
}
}
if ((!string.IsNullOrEmpty(returnUrl)) && Url.IsLocalUrl("/" + returnUrl))
{
return(RedirectToAction(returnUrl, new { subCategoriaId = categoriaViewModel.SubCategoriaId })); // RETORNA COM A CATEGORIA SELECIONADA
}
return(RedirectToAction(nameof(Index)));
}
public IList <CalculoTimeAnoCategoria> CalcularTimeAnoCategoria(int anoInicio, int anoFim, Time time, TipoCategoria categoria)
{
throw new NotImplementedException();
}
public IEnumerable <Categoria> BuscarPorTipoCategoria(TipoCategoria tipoCategoria)
{
return(_repositorio.Query(categoria => categoria.TipoCategoria == tipoCategoria));
}
public Categoria(string nome, TipoCategoria tipo)
{
this.Nome = nome;
this.Tipo = tipo;
}
/// <summary>
/// Busca la categoria indicada
/// </summary>
/// <param name="pTipoCategoria">Tipo de categoria</param>
/// <returns></returns>
public static Categoria BuscarCategoria(TipoCategoria pTipoCategoria)
{
return(ModeloFachada.GetInstancia().BuscarCategoria(pTipoCategoria));
}
public IList <CalculoTimeAnoCategoria> CalcularTimeAnoCategoria(int anoInicio, int anoFim, Time time, TipoCategoria categoria)
{
var temporadaTimes = _temporadaTimeService.GetAll().Where(x => x.Ano >= anoInicio && x.Ano <= anoFim).ToList();
var temporadaTime = new List <TemporadaTime>();
temporadaTime = temporadaTimes.Select(x => new TemporadaTime
{
Ano = x.Ano,
Id = x.Id,
Times = x.Times.Where(y => y.Time_ID == time.Id).ToList()
}).ToList();
var calculoTime = ObterEstatisticaTime(categoria, temporadaTime);
var calculoTemporadaMediaTime = ObterEstatisticaTime(categoria, temporadaTimes);
var listaCalculoTime = new List <CalculoTimeAnoCategoria>();
foreach (var item in calculoTemporadaMediaTime)
{
var calculoTemporada = new CalculoTimeAnoCategoria();
calculoTemporada.Ano = item.Ano;
calculoTemporada.EstatisticaMedia = item.ValorEstatistica;
listaCalculoTime.Add(calculoTemporada);
}
foreach (var item in calculoTime)
{
listaCalculoTime.Find(x => x.Ano == item.Ano).EstatisticaTime = item.ValorEstatistica;
}
return(listaCalculoTime);
}
/// <summary>
/// Constructor de la clase
/// </summary>
public Categoria(TipoCategoria pTipo, Categoria pCategoriaPadre = null)
{
this.NombreCategoria = pTipo.ToString();
this.CategoriaPadre = pCategoriaPadre;
this.ListaTutoriales = new List <Tutorial>();
}
/// <summary>
/// Obtiene una determinada categoria
/// </summary>
/// <param name="pTipoCategoria"></param>
/// <returns></returns>
public Categoria BuscarCategoria(TipoCategoria pTipoCategoria)
{
return(iUnidadDeTrabajo.RepositorioCategoria.Get(cat => cat.NombreCategoria == pTipoCategoria.ToString()).FirstOrDefault());
}
private double ObterValorEstatistica(TipoCategoria tipoCategoria, EstatisticaPer36 estatistica)
{
switch (tipoCategoria)
{
case TipoCategoria.Arremessos2Pontos:
{
return(estatistica.Arremessos2Pontos);
}
case TipoCategoria.Arremessos2PontosTentados:
{
return(estatistica.Arremessos2PontosTentados);
}
case TipoCategoria.Arremessos3Pontos:
{
return(estatistica.Arremessos3Pontos);
}
case TipoCategoria.Arremessos3PontosTentados:
{
return(estatistica.Arremessos3PontosTentados);
}
case TipoCategoria.ArremessosConvertidos:
{
return(estatistica.ArremessosConvertidos);
}
case TipoCategoria.ArremessosTentados:
{
return(estatistica.ArremessosTentados);
}
case TipoCategoria.Assistencias:
{
return(estatistica.Assistencias);
}
case TipoCategoria.DesperdiciosBola:
{
return(estatistica.DesperdiciosBola);
}
case TipoCategoria.Faltas:
{
return(estatistica.Faltas);
}
case TipoCategoria.LancesLivres:
{
return(estatistica.LancesLivres);
}
case TipoCategoria.LancesLivresTentados:
{
return(estatistica.LancesLivresTentados);
}
case TipoCategoria.Pontos:
{
return(estatistica.Pontos);
}
case TipoCategoria.Porcentagem2Pontos:
{
return(estatistica.Porcentagem2Pontos);
}
case TipoCategoria.Porcentagem3Pontos:
{
return(estatistica.Porcentagem3Pontos);
}
case TipoCategoria.PorcentagemArremessos:
{
return(estatistica.PorcentagemArremessos);
}
case TipoCategoria.PorcentagemLancesLivres:
{
return(estatistica.PorcentagemLancesLivres);
}
case TipoCategoria.RebotesDefensivos:
{
return(estatistica.RebotesDefensivos);
}
case TipoCategoria.RebotesOfensivos:
{
return(estatistica.RebotesOfensivos);
}
case TipoCategoria.RoubosBola:
{
return(estatistica.RoubosBola);
}
case TipoCategoria.Tocos:
{
return(estatistica.Tocos);
}
case TipoCategoria.TotalRebotes:
{
return(estatistica.TotalRebotes);
}
default:
return(0);
}
}
private IList <TemporadaBaseCalculo> ObterEstatisticaOponenteTime(TipoCategoria tipoCategoria, IList <TemporadaTime> temporadaTime)
{
var temporadaTimeCalculo = new List <TemporadaBaseCalculo>();
switch (tipoCategoria)
{
case TipoCategoria.Arremessos2Pontos:
{
temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
{
Ano = x.Ano,
ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.Arremessos2Pontos).Average(), 2)
}).ToList();
break;
}
case TipoCategoria.Arremessos2PontosTentados:
{
temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
{
Ano = x.Ano,
ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.Arremessos2PontosTentados).Average(), 2)
}).ToList();
break;
}
case TipoCategoria.Arremessos3Pontos:
{
temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
{
Ano = x.Ano,
ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.Arremessos3Pontos).Average(), 2)
}).ToList();
break;
}
case TipoCategoria.Arremessos3PontosTentados:
{
temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
{
Ano = x.Ano,
ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.Arremessos3PontosTentados).Average(), 2)
}).ToList();
break;
}
case TipoCategoria.ArremessosConvertidos:
{
temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
{
Ano = x.Ano,
ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.ArremessosConvertidos).Average(), 2)
}).ToList();
break;
}
case TipoCategoria.ArremessosTentados:
{
temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
{
Ano = x.Ano,
ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.ArremessosTentados).Average(), 2)
}).ToList();
break;
}
case TipoCategoria.Assistencias:
{
temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
{
Ano = x.Ano,
ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.Assistencias).Average(), 2)
}).ToList();
break;
}
case TipoCategoria.DesperdiciosBola:
{
temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
{
Ano = x.Ano,
ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.DesperdiciosBola).Average(), 2)
}).ToList();
break;
}
case TipoCategoria.Faltas:
{
temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
{
Ano = x.Ano,
ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.Faltas).Average(), 2)
}).ToList();
break;
}
case TipoCategoria.LancesLivres:
{
temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
{
Ano = x.Ano,
ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.LancesLivres).Average(), 2)
}).ToList();
break;
}
case TipoCategoria.LancesLivresTentados:
{
temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
{
Ano = x.Ano,
ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.LancesLivresTentados).Average(), 2)
}).ToList();
break;
}
case TipoCategoria.Pontos:
{
temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
{
Ano = x.Ano,
ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.Pontos).Average(), 2)
}).ToList();
break;
}
case TipoCategoria.Porcentagem2Pontos:
{
temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
{
Ano = x.Ano,
ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.Porcentagem2Pontos).Average(), 2)
}).ToList();
break;
}
case TipoCategoria.Porcentagem3Pontos:
{
temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
{
Ano = x.Ano,
ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.Porcentagem3Pontos).Average(), 2)
}).ToList();
break;
}
case TipoCategoria.PorcentagemArremessos:
{
temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
{
Ano = x.Ano,
ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.PorcentagemArremessos).Average(), 2)
}).ToList();
break;
}
case TipoCategoria.PorcentagemLancesLivres:
{
temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
{
Ano = x.Ano,
ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.PorcentagemLancesLivres).Average(), 2)
}).ToList();
break;
}
case TipoCategoria.RebotesDefensivos:
{
temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
{
Ano = x.Ano,
ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.RebotesDefensivos).Average(), 2)
}).ToList();
break;
}
case TipoCategoria.RebotesOfensivos:
{
temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
{
Ano = x.Ano,
ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.RebotesOfensivos).Average(), 2)
}).ToList();
break;
}
case TipoCategoria.RoubosBola:
{
temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
{
Ano = x.Ano,
ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.RoubosBola).Average(), 2)
}).ToList();
break;
}
case TipoCategoria.Tocos:
{
temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
{
Ano = x.Ano,
ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.Tocos).Average(), 2)
}).ToList();
break;
}
case TipoCategoria.TotalRebotes:
{
temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
{
Ano = x.Ano,
ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.TotalRebotes).Average(), 2)
}).ToList();
break;
}
default:
return(null);
}
return(temporadaTimeCalculo);
}
public IList <CalculoTimeAnoCategoria> CalcularTimeAnoCategoria(int anoInicio, int anoFim, Time time, TipoCategoria categoria)
{
return(_calculoTimeService.CalcularTimeAnoCategoria(anoInicio, anoFim, time, categoria));
}
public void asignarCategoria(TipoCategoria tc)
{
reposi.asignarCategoria(tc);
}