public ViewResult FormUpdateServico(string id)
{
ServicoViewModel modelo = new ServicoViewModel();
modelo.servico = new Servico();
modelo.servico.id = new Guid(id);
Servico retorno = new Servico();
if (!String.IsNullOrEmpty(id))
{
retorno = servicoData.Get(modelo.servico.id);
//TODO Formata campos
if (retorno != null)
{
modelo.servico = retorno;
//apresenta mensagem de registro atualizado com sucesso
modelo.StatusMessage = StatusMessage;
}
}
return(View(modelo));
}
public ActionResult Atualizar(int?id)
{
if (id == null)
{
return(RedirectToAction(nameof(Index)));
}
var servico = _servicoRepositorio.ObterServicoPorId(id.Value);
if (servico == null)
{
RegistroNaoEncontrado();
}
var viewModel = new ServicoViewModel
{
Id = servico.Id,
Descricao = servico.Descricao,
Status = servico.Status,
RecintoAlfandegado = servico.RecintoAlfandegado,
Operador = servico.Operador,
Redex = servico.Redex,
ServicosVinculados = servico.ServicosVinculados
};
PopularServicos(viewModel);
PopularServicosVinculados(viewModel);
return(View(viewModel));
}
//Metodo Get Serviço
public IActionResult Create()
{
var fornecedores = _FornecedorService.FindAll();
var viewModel = new ServicoViewModel {
Fornecedor = fornecedores
};
return(View(viewModel));
}
public IActionResult AttachServico(Guid vendaId)
{
ServicoViewModel viewModel = new ServicoViewModel
{
VendaId = vendaId
};
return(View(viewModel));
}
public async Task <IActionResult> Create([FromBody] ServicoViewModel model)
{
servicoFactory = ServicoFactory.Create(this.isolationLevel);
ServicoAbstract Servico = servicoFactory.getServico();
IServicoDominio servicoDominio = ServicoConfiguracao.converterServicoViewModelParaIServicoDominio(model);
var resultado = await Servico.Incluir(servicoDominio);
return(Json(resultado.Succeeded));
}
public ActionResult Edit(ServicoViewModel servicoViewModel)
{
if (ModelState.IsValid)
{
_appService.Update(servicoViewModel);
return(RedirectToAction("Index"));
}
return(View(servicoViewModel));
}
public ActionResult Alterar(ServicoViewModel servico)
{
if (ModelState.IsValid)
{
var serv = Mapper.Map <ServicoViewModel, Servico>(servico);
_servicoRep.Alterar(serv);
}
return(RedirectToAction("Index"));
}
private void PopularServicosVinculados(ServicoViewModel viewModel)
{
var servicos = viewModel.ServicosSelecionados ?? viewModel.ServicosVinculados.Select(c => c.Id).ToArray();
if (servicos.Length > 0)
{
viewModel.ServicosVinculados = _servicoFaturamentoRepositorio
.ObterServicos(servicos)
.ToList();
}
}
public ViewResult FormCreateServico()
{
ServicoViewModel modelo = new ServicoViewModel();
modelo.servico = new Servico();
modelo.contexto = contexto;
modelo.servico.criadoEm = DateTime.Now;
modelo.servico.criadoPorName = contexto.nomeUsuario;
return(View(modelo));
}
public ActionResult Cadastrar()
{
var viewModel = new ServicoViewModel
{
Status = Status.ATIVO
};
PopularServicos(viewModel);
return(View(viewModel));
}
private ServicoViewModel getViewModel(Servicos servico)
{
var model = new ServicoViewModel()
{
Nome = servico.Nome,
Descricao = servico.Descricao,
IDServico = servico.IDServico,
isSoftware = servico.isSoftware
};
return(model);
}
public static bool ServicoUpdate(ServicoViewModel entrada, out Servico servico)
{
servico = new Servico();
//************ Objetos de controle de acesso *******************
servico = entrada.servico;
servico.modificadoEm = DateTime.Now;
servico.modificadoPor = entrada.contexto.idUsuario;
servico.modificadoPorName = entrada.contexto.nomeUsuario;
//************ FIM Objetos de controle de acesso ***************
return(true);
}
public ActionResult Atualizar([Bind(Include = "Id, Descricao, Status, RecintoAlfandegado, Operador, Redex, ServicosSelecionados")] ServicoViewModel viewModel, int?id)
{
if (id == null)
{
return(RedirectToAction(nameof(Index)));
}
var servico = _servicoRepositorio.ObterServicoPorId(id.Value);
if (servico == null)
{
RegistroNaoEncontrado();
}
var servicoBusca = _servicoRepositorio.ObterServicoPorDescricao(viewModel.Descricao, servico.Id);
if (servicoBusca != null)
{
ModelState.AddModelError(string.Empty, "Já existe um serviço cadastrado com a mesma descrição.");
}
if (ModelState.IsValid)
{
servico.Alterar(new Servico(
viewModel.Descricao,
viewModel.Status,
viewModel.RecintoAlfandegado,
viewModel.Operador,
viewModel.Redex
));
servico.ServicosVinculados.Clear();
foreach (var servicoSelecionado in viewModel.ServicosSelecionados)
{
servico.AdicionarServicoVinculado(new ServicoFaturamento(servicoSelecionado));
}
if (Validar(servico))
{
_servicoRepositorio.Atualizar(servico);
TempData["Sucesso"] = true;
GravarLogAuditoria(TipoLogAuditoria.UPDATE, servico);
}
}
PopularServicos(viewModel);
PopularServicosVinculados(viewModel);
return(View(viewModel));
}
public async Task <IActionResult> Create(ServicoViewModel servicoViewModel)
{
if (!ModelState.IsValid)
{
await CarregarListas(servicoViewModel);
return(View(servicoViewModel));
}
await _servicoRepository.Adicionar(_mapper.Map <Servico>(servicoViewModel));
return(RedirectToAction(nameof(Index)));
}
public IActionResult Atualizar(int servicoId, ServicoViewModel model)
{
try
{
model.ServicoId = servicoId;
_servicoServices.AtualizarOrSalvar(model);
return(Ok());
}
catch (Exception ex)
{
return(StatusCode(500, ex));
}
}
private async Task <ServicoViewModel> CarregarListas(ServicoViewModel servicoViewModel = null)
{
if (servicoViewModel == null)
{
servicoViewModel = new ServicoViewModel();
}
servicoViewModel.Atendentes = _mapper.Map <IEnumerable <AtendenteViewModel> >(await _atendenteRepository.ListarTodos());
servicoViewModel.Veiculos = _mapper.Map <IEnumerable <VeiculoViewModel> >(await _veiculoRepository.ListarTodos());
servicoViewModel.Motoristas = _mapper.Map <IEnumerable <MotoristaViewModel> >(await _motoristaRepository.ListarTodos());
return(servicoViewModel);
}
public async Task <IActionResult> Create(ServicoViewModel servicoViewModel)
{
if (!ModelState.IsValid)
{
return(View(servicoViewModel));
}
//Criação vai ser pela classe de serviço.
var servico = _mapper.Map <Servico>(servicoViewModel);
await _contexto.Adicionar(servico);
return(RedirectToAction("Index"));
}
public ActionResult Create([Bind(Include = "Id,Descricao,DataAtendimento,ValorServico,ClienteId,TipoServicoId")] ServicoViewModel cadastroViewModel)
{
if (ModelState.IsValid)
{
var servico = Mapper.Map <ServicoViewModel, Servico>(cadastroViewModel);
servico.FornecedorId = unitOfWork.ServicoRepository.FornecedorIdLogado;
unitOfWork.ServicoRepository.Insert(servico);
unitOfWork.Commit();
return(RedirectToAction("Index"));
}
PopulateDropDownCliente(cadastroViewModel.ClienteId);
PopulateDropDownTipoServico(cadastroViewModel.TipoServicoId);
return(View(cadastroViewModel));
}
public ActionResult Create(ServicoViewModel objeto)
{
try
{
sv.Cadastrar(UsuarioLogado.IdEmpresa, objeto.Nome, objeto.Preco, objeto.PrecoFixo);
TempData["Nome"] = objeto.Nome;
TempData["Acao"] = "criado";
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex.Message);
return(View());
}
}
public ActionResult Edit(long id, ServicoViewModel objeto)
{
try
{
sv.Editar(id, objeto.Nome, objeto.Preco, objeto.PrecoFixo);
TempData["Nome"] = objeto.Nome;
TempData["Acao"] = "editado";
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex.Message);
return(Edit(id));
}
}
public ServicoViewModel RegistrarExclusaoServico(int id)
{
var servicoViewModel = new ServicoViewModel();
BeginTransaction();
_servicoService.Excluir(id);
servicoViewModel.ValidationResult = new DomainValidation.Validation.ValidationResult {
Message = Mensagem.Exclusao
};
SaveChange();
Commit();
return(servicoViewModel);
}
public int AtualizarOrSalvar(ServicoViewModel model)
{
var servico = _servicoRepository.GetServicoById(model.ServicoId);
if (servico == null)
{
return(_servicoRepository.SalvarServico(new Servico()
{
ClienteVeiculoId = model.ClienteVeiculoId,
ColaboradorId = model.ColaboradorId,
Descricao = model.Descricao,
ValorMaodeObra = model.ValorMaodeObra,
ValorPeca = model.ValorPeca,
ValorAdicional = model.ValorAdicional,
PercentualDesconto = model.PercentualDesconto,
ValorDesconto = model.ValorDesconto,
ValorTotal = model.ValorTotal,
Status = (int)EnumStatusServico.IniciadoPendente,
Ativo = true,
DataCadastro = DateTime.Now,
DataAlteracao = null
}));
}
else
{
_servicoRepository.AtualizarServico(new Servico()
{
ServicoId = model.ServicoId,
ClienteVeiculoId = model.ClienteVeiculoId,
ColaboradorId = model.ColaboradorId,
Descricao = model.Descricao,
ValorMaodeObra = model.ValorMaodeObra,
ValorPeca = model.ValorPeca,
ValorAdicional = model.ValorAdicional,
PercentualDesconto = model.PercentualDesconto,
ValorDesconto = model.ValorDesconto,
ValorTotal = model.ValorTotal,
Status = model.Status,
Ativo = model.Ativo,
DataCadastro = servico.DataCadastro,
DataAlteracao = DateTime.Now
});
return(0);
}
}
public ValidationResult Gravar(ServicoViewModel servico)
{
BeginTransaction();
var dadoIncluir = Mapper.Map <Servico>(servico);
var retorno = service.Gravar(dadoIncluir);
if (retorno.IsValid)
{
//commit transaction
Commit();
//commit error
if (!ValidationResults.IsValid)
{
return(ValidationResults);
}
}
return(retorno);
}
public async Task <IActionResult> PutServico(int id, ServicoViewModel servico)
{
if (id != servico.Id)
{
return(BadRequest());
}
if (await _servico.ExisteAsync(id))
{
var vm = await _servico.AtualizarAsync(_mapper.Map <Servico>(servico));
return(Ok(_mapper.Map <ServicoViewModel>(vm)));
}
else
{
return(NotFound());
}
}
public async Task <IActionResult> Edit(Guid id, ServicoViewModel servicoViewModel)
{
if (id != servicoViewModel.Id)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(View(servicoViewModel));
}
var servico = _mapper.Map <Servico>(servicoViewModel);
await _contexto.Atualizar(servico);
return(RedirectToAction("Index"));
}
public ServicoViewModel RegistrarInclusaoServico(ServicoViewModel servicoViewModel)
{
var Servico = Mapper.Map <Servico>(servicoViewModel);
BeginTransaction();
var ServicoReturn = _servicoService.Salvar(Servico);
servicoViewModel = Mapper.Map <ServicoViewModel>(ServicoReturn);
if (!ServicoReturn.ValidationResult.IsValid)
{
return(servicoViewModel);
}
SaveChange();
Commit();
return(servicoViewModel);
}
public IActionResult Salvar(ServicoViewModel model)
{
try
{
var Id = _servicoServices.AtualizarOrSalvar(model);
if (Id == 0)
{
return(Ok());
}
return(Created("", Id));
}
catch (Exception ex)
{
return(StatusCode(500, ex));
}
}
public ActionResult Recover(long id, ServicoViewModel objeto)
{
try
{
sv.Recover(id);
ServicoModel s = sv.Find(id);
TempData["Nome"] = s.Nome;
TempData["Acao"] = "criado";
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex.Message);
return(View());
}
}
public async Task <IActionResult> Edit(Guid id, ServicoViewModel servicoViewModel)
{
if (id != servicoViewModel.Id)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
await CarregarListas(servicoViewModel);
return(View(servicoViewModel));
}
await _servicoRepository.Atualizar(_mapper.Map <Servico>(servicoViewModel));
return(RedirectToAction(nameof(Index)));
}
internal static IServicoDominio converterServicoViewModelParaIServicoDominio(ServicoViewModel servicoViewModel)
{
IServicoDominio _servicoDominio = null;
if (servicoViewModel != null)
{
_servicoDominio = new ServicoViewModel();
_servicoDominio.Descricao = servicoViewModel.Descricao;
_servicoDominio.Id = servicoViewModel.Id;
_servicoDominio.Indicacao = servicoViewModel.Indicacao;
_servicoDominio.Nome = servicoViewModel.Nome;
_servicoDominio.Preco = servicoViewModel.Preco;
_servicoDominio.Status = servicoViewModel.Status;
_servicoDominio.ITipoServico = servicoViewModel.ITipoServico;
_servicoDominio.tipoServicoDominioId = servicoViewModel.tipoServicoDominioId;
}
return(_servicoDominio);
}
