public ActionResult Index()
{
ViewBag.Title = "Home Page";
ClientesServico.Create(new Clientes
{
CliCPF = 11482196689,
CliEmail = "*****@*****.**",
CliNome = "Marcos",
CliSenha = "123456",
CliTelefone = 31991335853
});
var categoria = new Categoria
{
Descricao = "Romance",
Nome = "Romance"
};
CategoriaServico.Create(categoria);
var livro = new Livro
{
Autor = "Reis Fofinho",
Editora = "Mateus marido",
Titulo = "Romance Eterno",
};
LivroServico.Create(livro);
return(View());
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Nome")] CategoriaServico categoriaServico)
{
if (id != categoriaServico.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(categoriaServico);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CategoriaServicoExists(categoriaServico.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(categoriaServico));
}
public void Popular()
{
if (_context.CategoriaProduto.Any() || _context.Produto.Any())
{
return; //O banco de dados já foi populado
}
//Categorias de produtos
CategoriaProduto catProd1 = new CategoriaProduto(1, "Shampoo");
CategoriaProduto catProd2 = new CategoriaProduto(2, "Condicionador");
CategoriaProduto catProd3 = new CategoriaProduto(3, "Alisante");
CategoriaProduto catProd4 = new CategoriaProduto(4, "Pente");
//Produtos
Produto prod1 = new Produto(1, "Seda Ceramidas", 10.75, 5, catProd1);
Produto prod2 = new Produto(2, "Palmolive", 9.50, 8, catProd1);
Produto prod3 = new Produto(3, "Seda Ceramidas", 8.20, 6, catProd2);
Produto prod4 = new Produto(4, "Salon Line", 15.30, 9, catProd3);
Produto prod5 = new Produto(5, "Taiff", 12.90, 4, catProd4);
CategoriaServico catServ1 = new CategoriaServico(1, "Prancha");
CategoriaServico catServ2 = new CategoriaServico(2, "Escova Pequena");
CategoriaServico catServ3 = new CategoriaServico(3, "Escova Média");
CategoriaServico catServ4 = new CategoriaServico(4, "Escova Grande");
CategoriaServico catServ5 = new CategoriaServico(5, "Alisamento");
CategoriaServico catServ6 = new CategoriaServico(6, "Mechas");
CategoriaServico catServ7 = new CategoriaServico(7, "Rolinho");
//adiciona os objetos criados nas tabelas
_context.CategoriaProduto.AddRange(catProd1, catProd2, catProd3, catProd4);
_context.Produto.AddRange(prod1, prod2, prod3, prod4, prod5);
_context.CategoriaServico.AddRange(catServ1, catServ2, catServ3, catServ4, catServ5, catServ6, catServ7);
_context.SaveChanges();
}
public frmCategoria()
{
InitializeComponent();
_categoria = new Categoria();
_categoria.Id = 0;
_categoriaServico = new CategoriaServico();
}
public Task <int> EditAsync(CategoriaServico cadastro)
{
Task <int> T = new Task <int>(() => { return(Edit(cadastro)); });
T.Start();
return(T);
}
public DespesaDiretasController(ControlePessoalContext context)
{
_context = context;
listaDespDiretaServico = new ListaDespDiretaServico(context);
categoriaServicos = new CategoriaServico(context);
formaServicos = new FormaPagamentoServico(context);
statusServicos = new StatusCompraServico(context);
}
public static CategoriaServicoViewModel Create(CategoriaServico Categoria, List <SubCategoriaServico> SubCategorias)
{
var categoria = Create(Categoria);
categoria.SubCategorias = SubCategorias.Select(SubCategoria => SubCategoriaServicoViewModel.Create(SubCategoria)).ToList();
return(categoria);
}
public long Adicionar(CategoriaApp instancia)
{
var modelDominio = Mapper.Map <Categoria>(instancia);
var result = CategoriaServico.Adicionar(modelDominio);
return(result);
}
public async Task <long> AdicionarAsync(CategoriaApp instancia)
{
var instanciaDominio = Mapper.Map <Categoria>(instancia);
var resultado = await CategoriaServico.AdicionarAsync(instanciaDominio);
return(resultado);
}
public Task <List <SubCategoriaServico> > GetAsync(CategoriaServico categoria)
{
Task <List <SubCategoriaServico> > T = new Task <List <SubCategoriaServico> >(() => { return(Get(categoria)); });
T.Start();
return(T);
}
public async Task <CategoriaApp> PegarAsync(long id)
{
var resultadoDominio = await CategoriaServico.PegarAsync(id);
var resultado = Mapper.Map <CategoriaApp>(resultadoDominio);
return(resultado);
}
public ListaMercadosController(ControlePessoalContext context)
{
_context = context;
mercadoServicos = new ListaMercadoServicos(context);
categoriaServicos = new CategoriaServico(context);
formaServicos = new FormaPagamentoServico(context);
statusServicos = new StatusCompraServico(context);
}
public frmCategoria(int id)
{
InitializeComponent();
_categoria = new Categoria();
_categoriaServico = new CategoriaServico();
_categoria = _categoriaServico.Selecionar(id);
txtCategoria.Text = _categoria.Nome;
btnExcluir.Visible = true;
}
public Servico(string nome, int minutosParaExecucao, decimal preco, CategoriaServico categoria)
{
Id = IdAutoIncremente;
IdAutoIncremente++;
Nome = nome;
MinutosParaExecucao = minutosParaExecucao;
Preco = preco;
Categotia = categoria;
}
public static CategoriaServicoViewModel Create(CategoriaServico Categoria)
{
if (Categoria == null)
{
return(null);
}
return(new CategoriaServicoViewModel(Categoria.Id, Categoria.Descricao, Categoria.LinkImagem));
}
public async Task <IActionResult> Create([Bind("Id,Nome")] CategoriaServico categoriaServico)
{
if (ModelState.IsValid)
{
_context.Add(categoriaServico);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(categoriaServico));
}
public CategoriaServico Find(string Id)
{
CategoriaServico servicocategory = servicoscategories.Find(s => s.Id == Id);
if (servicocategory != null)
{
return(servicocategory);
}
else
{
throw new Exception("Servicos nao encontrado");
}
}
public ActionResult Delete(string Id)
{
CategoriaServico servicoscategoriesToDelete = context.Find(Id);
if (servicoscategoriesToDelete == null)
{
return(HttpNotFound());
}
else
{
return(View(servicoscategoriesToDelete));
}
}
public ActionResult Edit(string Id)
{
CategoriaServico servicoscategories = context.Find(Id);
if (servicoscategories == null)
{
return(HttpNotFound());
}
else
{
return(View(servicoscategories));
}
}
public void Delete(string Id)
{
CategoriaServico servicoscategoriesToDelete = servicoscategories.Find(s => s.Id == Id);
if (servicoscategoriesToDelete != null)
{
servicoscategories.Remove(servicoscategoriesToDelete);
}
else
{
throw new Exception("Servicos nao encontrado");
}
}
public void Update(CategoriaServico servicocategory)
{
CategoriaServico servicoscategoriesToUpdate = servicoscategories.Find(s => s.Id == servicocategory.Id);
if (servicoscategoriesToUpdate != null)
{
servicoscategoriesToUpdate = servicocategory;
}
else
{
throw new Exception("Servicos nao encontrado");
}
}
public ActionResult Create(CategoriaServico servicoscategories)
{
if (!ModelState.IsValid)
{
return(View(servicoscategories));
}
else
{
context.Insert(servicoscategories);
context.Commit();
return(RedirectToAction("Index"));
}
}
public ActionResult ConfirmDelete(string Id)
{
CategoriaServico servicoscategoriesToDelete = context.Find(Id);
if (servicoscategoriesToDelete == null)
{
return(HttpNotFound());
}
else
{
context.Delete(Id);
context.Commit();
return(RedirectToAction("Index"));
}
}
public int Add(CategoriaServico cadastro)
{
try
{
cadastro.Id = FlatLira.CadastroCategoriaServico.Count > 0 ? FlatLira.CadastroCategoriaServico.Max(X => X.Id) + 1 : 1;
FlatLira.CadastroCategoriaServico.Add(cadastro);
FlatLira.SetCadastro <CategoriaServico>(FlatLira.CadastroCategoriaServico, FlatLira.ArqCategoriaServico);
return(1);
}
catch (Exception ex)
{
return(0);
}
}
public void LoadCBO()
{
CategoriaServico _categoriaServico = new CategoriaServico();
foreach (var categoria in _categoriaServico.Listar())
{
var item = new KeyValuePair <int, string>(categoria.Id, categoria.Nome);
cboCategoria.Items.Add(item);
}
cboCategoria.DisplayMember = "Value";
cboCategoria.ValueMember = "Key";
if (_produto.Id != 0)
{
cboMarca.SelectedIndex = cboMarca.FindString(_produto.Marca.Nome);
cboCategoria.SelectedIndex = cboCategoria.FindStringExact(_produto.Categoria.Nome);
}
}
public PaginadoOrdenado <CategoriaApp> Listar(PaginadoOrdenado <CategoriaApp> consulta)
{
var consultaDominio = new PaginadoOrdenado <Categoria>()
{
ItensPorPagina = consulta.ItensPorPagina,
PaginaAtual = consulta.PaginaAtual,
OrdemDirecao = consulta.OrdemDirecao,
};
switch (consulta.OrdemNome)
{
case "Id":
consultaDominio.OrdemNome = "CategoriaId";
break;
case "Nome":
consultaDominio.OrdemNome = "CategoriaNome";
break;
}
var resultadoDominio = CategoriaServico.Listar(consultaDominio);
var resultado = new PaginadoOrdenado <CategoriaApp>()
{
ItensPorPagina = resultadoDominio.ItensPorPagina,
ContagemDePaginas = resultadoDominio.ContagemDePaginas,
ContagemDeLinhas = resultadoDominio.ContagemDeLinhas,
PaginaAtual = resultadoDominio.PaginaAtual,
Itens = Mapper.Map <List <CategoriaApp> >(resultadoDominio.Itens),
OrdemDirecao = resultadoDominio.OrdemDirecao
};
switch (resultadoDominio.OrdemNome)
{
case "CategoriaId":
resultado.OrdemNome = "Id";
break;
case "CategoriaNome":
resultado.OrdemNome = "Nome";
break;
}
return(resultado);
}
public void PegarTeste()
{
var instancia = new Categoria()
{
CategoriaNome = "Juvenil"
};
try
{
var result = CategoriaServico.Adicionar(instancia);
Assert.IsTrue(result > 0);
}
catch (AppException ex)
{
Assert.IsTrue(ex.ValidationResults.Any());
}
}
public void LoadDgv()
{
MarcaServico marcaServico = new MarcaServico();
CategoriaServico categoriaServico = new CategoriaServico();
var listaProdutos = _produtoServico.Listar <Produto>(r => r.Categoria, r => r.Marca);
if (dgvListaProdutos.Rows.Count > 0)
{
dgvListaProdutos.Rows.Clear();
}
foreach (var produto in listaProdutos)
{
dgvListaProdutos.Rows.Add(produto.Id, produto.Nome, produto.Descricao,
produto.Cor, produto.Quantidade,
produto.Marca.Nome, produto.Categoria.Nome);
}
}
public void ListarTeste()
{
var consulta = new PaginadoOrdenado <Categoria>()
{
ItensPorPagina = 4,
PaginaAtual = 5
};
try
{
var result = CategoriaServico.Listar(consulta);
Assert.IsTrue(result.Itens.Count() > 0);
}
catch (AppException ex)
{
Assert.IsTrue(ex.ValidationResults.Any());
}
}
public async Task <IActionResult> Edit([FromBody] CategoriaServico categoria)
{
try
{
if (categoria != null)
{
await CategoriaServicoCRUD.EditAsync(categoria);
return(Ok());
}
else
{
return(NotFound(ExtencaoController.GetRetorno(RetornoRequisicao.CategoriaNaoInformada)));
}
}
catch (Exception ex)
{
return(NotFound(ExtencaoController.GetRetorno(RetornoRequisicao.ErroNaoIdentificado, ex)));
}
}
public IList<Servico> Consultar(string nomeAnimal, CategoriaServico? categoriaServico, DateTime? dataHoraServico, string nomeFuncionario, long? id)
{
try
{
var servicos =
_repServico.Pesquisar(p => p.AnimalCliente.Nome.Contains(!string.IsNullOrWhiteSpace(nomeAnimal) ? nomeAnimal : p.AnimalCliente.Nome) &&
p.CategoriaServico == (categoriaServico ?? p.CategoriaServico) &&
p.DataHoraServico == (dataHoraServico ?? p.DataHoraServico) &&
p.Funcionario.Nome.Contains(!string.IsNullOrWhiteSpace(nomeFuncionario) ? nomeFuncionario : p.Funcionario.Nome) &&
p.Id != (id ?? 0))
.OrderBy(o => o.Id)
.ToList();
return servicos;
}
catch (Exception)
{
return null;
}
}