public ActionResult Create(int?id)
{
var osViewModel = new OrdemServicoViewModel();
ViewBag.Grupos = new SelectList(_GrupoAtividadeAppService.ObterTodos(), "IdGrupoAtividade", "NomGrupoAtividade");
ViewBag.CriteriosAvaliacao = new SelectList(_CriterioAvaliacaoAppService.ObterTodos(), "IdCriterioAvaliacao", "DescCriterioAvaliacao");
if (!id.HasValue)
{
osViewModel.Grupos = new List <GrupoAtividadeViewModel>();
osViewModel.CriteriosAvaliacao = new List <CriterioAvaliacaoViewModel>();
osViewModel.DatInicioNormativo = DateTime.Now;
osViewModel.DatInicioSistema = DateTime.Now;
}
else
{
osViewModel = _OrdemServicoAppService.ObterPorId(id.Value);
osViewModel.idsGrupos = new List <int>();
foreach (var obj in osViewModel.Grupos)
{
osViewModel.idsGrupos.Add(obj.IdGrupoAtividadeOriginal);
}
osViewModel.idsCriteriosAvaliacao = new List <int>();
foreach (var obj in osViewModel.CriteriosAvaliacao)
{
osViewModel.idsCriteriosAvaliacao.Add(obj.IdCriterioAvaliacaoOriginal);
}
}
return(View(osViewModel));
}
public ActionResult EnviarPasso2(OrdemServicoViewModel ordemServicoViewModel)
{
try
{
//if (!ModelState.IsValid) return RedirectToAction("Index", "OrdemServico", ordemServicoViewModel);
//Session["ordemservicoViewModel"] = ordemServicoViewModel;
//if (!ValidarEntradaHorasAtendimento(ordemServicoViewModel))
//{
//return RedirectToAction("Index", "OrdemServico");
//}
var cliente = Session["cliente"] as Cliente;
ordemServicoViewModel.IdCliente = cliente.IdCliente;
Session["ordemservicoViewModel"] = ordemServicoViewModel;
return(RedirectToAction("Index", "FluxoAtendimento"));
}
catch
{
return(View());
}
}
public DataTable ToDataTable(OrdemServicoViewModel osvm)
{
DataTable dataTable = new DataTable("RolAtividades");
//dados header
dataTable.Columns.Add("Grupo de Atividades");
dataTable.Columns.Add("Atividade");
dataTable.Columns.Add("Faixa");
dataTable.Columns.Add("Tempo de duração da atividade presencial");
dataTable.Columns.Add("Tempo de duração da atividade no PGD");
dataTable.Columns.Add("Percentual mínimo de redução");
DataRow row;
foreach (GrupoAtividadeViewModel g in osvm.Grupos.OrderBy(g => g.NomGrupoAtividade))
{
foreach (AtividadeViewModel a in g.Atividades.OrderBy(a => a.NomAtividade))
{
foreach (TipoAtividadeViewModel t in a.Tipos.OrderBy(t => t.Faixa))
{
row = dataTable.NewRow();
row["Grupo de Atividades"] = g.NomGrupoAtividade;
row["Atividade"] = a.NomAtividade;
row["Faixa"] = t.FaixaTextoExplicativo;
row["Tempo de duração da atividade presencial"] = t.DuracaoFaixaPresencial;
row["Tempo de duração da atividade no PGD"] = t.DuracaoFaixa;
row["Percentual mínimo de redução"] = a.PctMinimoReducao + "%";
dataTable.Rows.Add(row);
}
}
}
return(dataTable);
}
public IActionResult FormUpdateOrdemServico(OrdemServicoViewModel entrada)
{
OrdemServico modelo = new OrdemServico();
entrada.contexto = this.contexto;
try
{
if (OrdemServicoRules.OrdemServicoUpdate(entrada, out modelo))
{
OrdemServicoRules.CalculoOrdem(ref modelo, servicoOrdemData, produtoOrdemData);
ordemServicoData.Update(modelo);
//Se fechar o Ordem insere o faturamento
if (entrada.ordemServico.statusOrdemServico == CustomEnumStatus.StatusOrdemServico.Fechado && entrada.ordemServico.condicaoPagamento == CustomEnum.codicaoPagamento.Avista)
{
FaturamentoRules.InsereFaturamento(modelo, contexto.idOrganizacao);
}
StatusMessage = "Registro Atualizado com Sucesso!";
return(RedirectToAction("FormUpdateOrdemServico", new { id = modelo.id.ToString() }));
}
}
catch (Exception ex)
{
LogOsca log = new LogOsca();
log.GravaLog(1, 5, this.contexto.idUsuario, this.contexto.idOrganizacao, "FormUpdateOrdemServico-post", ex.Message);
}
return(RedirectToAction("FormUpdateOrdemServico", new { id = modelo.id.ToString() }));
}
public ViewResult FormStatusOrdemServico(string id)
{
OrdemServicoViewModel modelo = new OrdemServicoViewModel();
modelo.contexto = this.contexto;
try
{
OrdemServico retorno = new OrdemServico();
if (!String.IsNullOrEmpty(id))
{
//campo que sempre contém valor
retorno = ordemServicoData.Get(new Guid(id));
if (retorno != null)
{
modelo.ordemServico = retorno;
}
}
}
catch (Exception ex)
{
LogOsca log = new LogOsca();
log.GravaLog(1, 5, this.contexto.idUsuario, this.contexto.idOrganizacao, "FormStatusOrdemServico-get", ex.Message);
}
return(View(modelo));
}
public JsonResult Detalhe(int id)
{
try
{
OrdemServicoNegocio ordemServico = new OrdemServicoNegocio();
OrdemServico o = ordemServico.Consulta(id);
OrdemServicoViewModel model = new OrdemServicoViewModel();
ColaboradorNegocio colaboradorNegocio = new ColaboradorNegocio();
Colaborador c = colaboradorNegocio.Consulta(o.ColaboradorId);
model.Id = o.Id;
model.Motivo = o.Motivo;
model.Obs = o.Obs;
model.Orcamento = o.Orçamento;
model.Placa = o.Placa;
model.Status = o.Status;
model.NomeColaborador = c.Nome;
model.DataAbertura = o.DataAbertura.ToString("yyyy-MM-dd");
return(Json(model));
}
catch (Exception ex)
{
throw;
}
}
public static bool OrdemServicoCreate(OrdemServicoViewModel entrada, out OrdemServico ordemServico)
{
ordemServico = new OrdemServico();
ordemServico = entrada.ordemServico;
SqlGeneric servico = new SqlGeneric();
if (ordemServico.idOrganizacao != null)
{
ordemServico.codigo = servico.RetornaNovaPosicao(5, entrada.contexto.idOrganizacao);
ordemServico.statusOrdemServico = CustomEnumStatus.StatusOrdemServico.EmAndamento;
ordemServico.idCliente = entrada.cliente.id;
//************ Objetos de controle de acesso para Create ******************
ordemServico.criadoEm = DateTime.Now;
ordemServico.criadoPor = entrada.contexto.idUsuario;
ordemServico.criadoPorName = entrada.contexto.nomeUsuario;
ordemServico.modificadoEm = DateTime.Now;
ordemServico.modificadoPor = entrada.contexto.idUsuario;
ordemServico.modificadoPorName = entrada.contexto.nomeUsuario;
ordemServico.idOrganizacao = entrada.contexto.idOrganizacao;
//************ FIM Objetos de controle de acesso ***************
return(true);
}
return(false);
}
/// <summary>
///
/// </summary>
/// <param name="ordemServicoViewModel"></param>
/// <returns></returns>
public bool ValidarEntradaHorasAtendimento(OrdemServicoViewModel ordemServicoViewModel)
{
if (ordemServicoViewModel.DataPreenchimento.ToString() == "01/01/0001 00:00:00")
{
TempData["warning"] = "Verifique o lançamento da data preenchimento.";
return(false);
}
DateTime data = Convert.ToDateTime(ordemServicoViewModel.HoraChegada);
if (Convert.ToDateTime(ordemServicoViewModel.HoraChegada) >= Convert.ToDateTime(ordemServicoViewModel.HoraSaida))
{
TempData["warning"] = "Verifique os lançamentos de horas.";
return(false);
}
if (Convert.ToDateTime(ordemServicoViewModel.HoraChegada) >= Convert.ToDateTime(ordemServicoViewModel.HoraInicio))
{
TempData["warning"] = "Verifique os lançamentos de horas.";
return(false);
}
if (Convert.ToDateTime(ordemServicoViewModel.HoraChegada) >= Convert.ToDateTime(ordemServicoViewModel.HoraTermino))
{
TempData["warning"] = "Verifique os lançamentos de horas.";
return(false);
}
if (Convert.ToDateTime(ordemServicoViewModel.HoraChegada) >= Convert.ToDateTime(ordemServicoViewModel.HoraSaida))
{
TempData["warning"] = "Verifique os lançamentos de horas.";
return(false);
}
if (Convert.ToDateTime(ordemServicoViewModel.HoraInicio) >= Convert.ToDateTime(ordemServicoViewModel.HoraTermino))
{
TempData["warning"] = "Verifique os lançamentos de horas.";
return(false);
}
if (Convert.ToDateTime((ordemServicoViewModel.HoraInicio)) >= Convert.ToDateTime(ordemServicoViewModel.HoraSaida))
{
TempData["warning"] = "Verifique os lançamentos de horas.";
return(false);
}
if (Convert.ToDateTime(ordemServicoViewModel.HoraTermino) >= Convert.ToDateTime(ordemServicoViewModel.HoraSaida))
{
TempData["warning"] = "Verifique os lançamentos de horas.";
return(false);
}
return(true);
}
public OrdemServicoViewModel Atualizar(OrdemServicoViewModel ordemServicoViewModel)
{
BeginTransaction();
var os = _ordemservicoService.ObterPorId(ordemServicoViewModel.IdOrdemServico.Value);
os.Grupos = null;
os.CriteriosAvaliacao = null;
var OrdemServico = Mapper.Map <OrdemServicoViewModel, OrdemServico>(ordemServicoViewModel);
if (OrdemServico != null)
{
foreach (var grupo in OrdemServico.Grupos)
{
grupo.IdGrupoAtividadeOriginal = grupo.IdGrupoAtividade;
var listaTipos = new List <TipoPacto>();
foreach (var tipo in grupo.TiposPacto)
{
var t = _tipoPactoService.ObterPorId(tipo.IdTipoPacto);
listaTipos.Add(t);
}
grupo.TiposPacto = listaTipos;
}
foreach (var criterioAvaliacao in OrdemServico.CriteriosAvaliacao)
{
criterioAvaliacao.IdCriterioAvaliacaoOriginal = criterioAvaliacao.IdCriterioAvaliacao;
foreach (var itemAvaliacao in criterioAvaliacao.ItensAvaliacao)
{
itemAvaliacao.NotaMaxima = _notaAvaliacaoService.ObterPorId(itemAvaliacao.IdNotaMaxima);
}
}
os.DatInicioNormativo = ordemServicoViewModel.DatInicioNormativo;
os.DatInicioSistema = ordemServicoViewModel.DatInicioSistema;
os.DescOrdemServico = ordemServicoViewModel.DescOrdemServico;
os.IdOrdemServico = ordemServicoViewModel.IdOrdemServico.Value;
os.Grupos = OrdemServico.Grupos;
os.CriteriosAvaliacao = OrdemServico.CriteriosAvaliacao;
var osReturn = _ordemservicoService.Atualizar(os);
if (osReturn.ValidationResult.IsValid)
{
_logService.Logar(OrdemServico, ordemServicoViewModel.Usuario.CPF, Domain.Enums.Operacao.Alteração.ToString());
Commit();
}
ordemServicoViewModel = Mapper.Map <OrdemServico, OrdemServicoViewModel>(osReturn);
}
return(ordemServicoViewModel);
}
private void MontarSeccaoOrdemServico(OrdemServicoViewModel ordemServico, ref Document documento, Font bodyFont)
{
string descricaoOrdemServico = "Protocolo Chamado nr " + ordemServico.NumeroChamado;
descricaoOrdemServico += " - Registrado em " + ordemServico.DataChamado;
descricaoOrdemServico += " - Ordem de Servico nr " + ordemServico.IdOrdemServico.ToString();
documento.Add(new Paragraph(" "));
documento.Add(new Paragraph(" "));
documento.Add(new Paragraph(descricaoOrdemServico, bodyFont));
}
public PactoViewModel OrdemVigenteProdutos(OrdemServicoViewModel ordemVigente, PactoViewModel pacto)
{
pacto.OrdemServico = ordemVigente;
foreach (var produto in pacto.Produtos)
{
produto.GrupoAtividade = ordemVigente.Grupos.FirstOrDefault(x => x.IdGrupoAtividade == produto.IdGrupoAtividade);
produto.Atividade = produto.GrupoAtividade.Atividades.FirstOrDefault(x => x.IdAtividade == produto.IdAtividade);
produto.TipoAtividade = produto.Atividade.Tipos.FirstOrDefault(x => x.IdTipoAtividade == produto.IdTipoAtividade);
}
return(pacto);
}
public OrdemServicoViewModel Remover(OrdemServicoViewModel ordemServicoViewModel)
{
var OrdemServico = Mapper.Map <OrdemServicoViewModel, OrdemServico>(ordemServicoViewModel);
BeginTransaction();
var grupoatividadeReturn = _ordemservicoService.Remover(OrdemServico);
_logService.Logar(OrdemServico, ordemServicoViewModel.Usuario.CPF, Domain.Enums.Operacao.Exclusão.ToString());
Commit();
return(Mapper.Map <OrdemServico, OrdemServicoViewModel>(grupoatividadeReturn));
}
private void MontarSeccaoPeriodoAtendimento(OrdemServicoViewModel ordemServico, ref Document documento, Font bodyFont, Font bodySubTitle)
{
string descricaoPeriodoAtendimento = "Técnico Responsável " + ordemServico.NomeTecnico + " - Data Atendimento " + ordemServico.DataPreenchimento;
string descricaoPeriodoAtendimentoCompl = " Hora chegada " + ordemServico.HoraChegada + " Hora início " + ordemServico.HoraInicio;
descricaoPeriodoAtendimentoCompl += " Hora término " + ordemServico.HoraTermino + " Hora saída " + ordemServico.HoraSaida;
documento.Add(new Paragraph(" "));
documento.Add(FormatarSubTituloSeccao("Período Atendimento", bodySubTitle));
documento.Add(new Paragraph(descricaoPeriodoAtendimento, bodyFont));
documento.Add(new Paragraph(descricaoPeriodoAtendimentoCompl, bodyFont));
}
public async Task <ActionResult <OrdemServicoViewModel> > PostOrdemServico(OrdemServicoViewModel ordemServico)
{
var vm = await _servico.InserirOrdemServico(_mapper.Map <OrdemServico>(ordemServico));
if (vm != null)
{
return(Ok(_mapper.Map <OrdemServicoViewModel>(vm)));
}
else
{
return(NotFound());
}
}
public ActionResult EnviarDadosFinalizacao(OrdemServicoViewModel ordemServicoViewModel)
{
var ordemservicoViewModelOrigem = Session["ordemservicoViewModel"] as OrdemServicoViewModel;
ordemservicoViewModelOrigem.Observacoes = ordemServicoViewModel.Observacoes;
//Implementar seu metodo de geração de identificador de anexo a OS.
ordemServicoViewModel.IdAnexo = 1;
int a = 1;
//--------------------------------------------------------------------
ordemservicoViewModelOrigem.IdAnexo = ordemServicoViewModel.IdAnexo;
var conta = Request.Files.Count;
List <Anexo> anexos = new List <Anexo>();
for (int i = 0; i < Request.Files.Count; i++)
{
var arquivo = Request.Files[i];
if (arquivo.ContentLength != 0)
{
var anexo = new Anexo();
anexo.Id = a++; // Exemplo modificar para um identificador unico do objeto
anexo.IdAnexo = ordemservicoViewModelOrigem.IdAnexo;
//Use este metodo de conversao para binario caso o arquivo seja tipo imagem (jpeg, png, entre outros)
// anexo.Arquivo = Imagem.ConverterHttpImagem(arquivo);
//Exemplo de recebimento de dados de arquivo anexo (Mockup)
anexo.Arquivo = arquivo.FileName;
anexos.Add(anexo);
}
}
ordemservicoViewModelOrigem.Anexos = anexos;
Session["ordemservicoViewModel"] = ordemservicoViewModelOrigem;
return(RedirectToAction("ClienteResponsavel", "OrdemServico"));
}
public async Task <IActionResult> Edit(OrdemServicoViewModel ordemServicoViewModel)
{
if (!ModelState.IsValid)
{
return(View(ordemServicoViewModel));
}
if (ResponseHasErrors(await _ordemServicoAppService.Update(ordemServicoViewModel)))
{
return(View(ordemServicoViewModel));
}
ViewBag.Sucesso = "Ordem de Serviços atualizada!";
return(RedirectToAction("details", "ordem", new { Id = ordemServicoViewModel.Id }));
}
public static bool OrdemServicoUpdateStatus(OrdemServicoViewModel entrada, out OrdemServico ordemServico)
{
ordemServico = new OrdemServico();
ordemServico = entrada.ordemServico;
if (entrada.ordemServico.statusOrdemServico == CustomEnumStatus.StatusOrdemServico.AguardandoProduto || entrada.ordemServico.statusOrdemServico == CustomEnumStatus.StatusOrdemServico.EmAndamento || entrada.ordemServico.statusOrdemServico == CustomEnumStatus.StatusOrdemServico.ParaEntrega)
{
entrada.ordemServico.dataFechamento = new DateTime();
}
//************ Objetos de controle de acesso para Update*******************
ordemServico.modificadoEm = DateTime.Now;
ordemServico.modificadoPor = entrada.contexto.idUsuario;
ordemServico.modificadoPorName = entrada.contexto.nomeUsuario;
//************ FIM Objetos de controle de acesso ***************
return(true);
}
public async Task <IActionResult> PutOrdemServico(int id, OrdemServicoViewModel ordemServico)
{
if (id != ordemServico.Id)
{
return(BadRequest());
}
if (await _servico.ExisteAsync(id))
{
var vm = await _servico.AtualizarAsync(_mapper.Map <OrdemServico>(ordemServico));
return(Ok(_mapper.Map <OrdemServicoViewModel>(vm)));
}
else
{
return(NotFound());
}
}
private void MontarSeccaoClienteResponsavel(OrdemServicoViewModel ordemServico, Cliente cliente, ref Document documento, Font bodyFont, Font bodySubTitle)
{
documento.Add(FormatarSubTituloSeccao("Cliente Responsável", bodySubTitle));
List <Funcionario> funcionarios = cliente.Funcionarios.ToList();
var funcionario = funcionarios.Find(a => a.IdFuncionario == ordemServico.IdFuncionario && a.IdCliente == cliente.IdCliente);
string descricaoClienteResponsavel = funcionario.Nome + " RG " + funcionario.RG;
string descricaoClienteResponsavelCompl = funcionario.Cargo + " " + funcionario.Telefone + " " + funcionario.Email;
documento.Add(new Paragraph(descricaoClienteResponsavel, bodyFont));
documento.Add(new Paragraph(descricaoClienteResponsavelCompl, bodyFont));
}
public ActionResult Create(OrdemServicoViewModel grupoatividadeViewModel)
{
if (ModelState.IsValid)
{
grupoatividadeViewModel.Usuario = getUserLogado();
grupoatividadeViewModel.Grupos = _OrdemServicoAppService.PreencheListGrupoAtividade(grupoatividadeViewModel.idsGrupos);
grupoatividadeViewModel.CriteriosAvaliacao = _OrdemServicoAppService.PreencheListCriterioAvaliacao(grupoatividadeViewModel.idsCriteriosAvaliacao);
if (!grupoatividadeViewModel.IdOrdemServico.HasValue || grupoatividadeViewModel.IdOrdemServico.Value == 0)
{
grupoatividadeViewModel = _OrdemServicoAppService.Adicionar(grupoatividadeViewModel);
}
else
{
grupoatividadeViewModel = _OrdemServicoAppService.Atualizar(grupoatividadeViewModel);
}
if (grupoatividadeViewModel.ValidationResult.IsValid)
{
return(setMessageAndRedirect(grupoatividadeViewModel.ValidationResult.Message, "Index"));
}
else
{
setModelErrorList(grupoatividadeViewModel.ValidationResult.Erros);
}
}
if (grupoatividadeViewModel.idsGrupos == null)
{
grupoatividadeViewModel.idsGrupos = new List <int>();
}
if (grupoatividadeViewModel.idsCriteriosAvaliacao == null)
{
grupoatividadeViewModel.idsCriteriosAvaliacao = new List <int>();
}
ViewBag.Grupos = new SelectList(_GrupoAtividadeAppService.ObterTodos(), "IdGrupoAtividade", "NomGrupoAtividade");
ViewBag.CriteriosAvaliacao = new SelectList(_CriterioAvaliacaoAppService.ObterTodos(), "IdCriterioAvaliacao", "DescCriterioAvaliacao");
return(View(grupoatividadeViewModel));
}
public ActionResult GravarAtendimento(OrdemServicoViewModel ordemServicoViewModel)
{
var ordemservicoViewModelOrigem = Session["ordemservicoViewModel"] as OrdemServicoViewModel;
ordemservicoViewModelOrigem.IdFuncionario = ordemServicoViewModel.IdFuncionario;
ordemservicoViewModelOrigem.Assinatura = ordemServicoViewModel.Assinatura;
ordemservicoViewModelOrigem.HoraInicio = ordemServicoViewModel.HoraInicio;
ordemservicoViewModelOrigem.HoraChegada = ordemServicoViewModel.HoraChegada;
ordemservicoViewModelOrigem.HoraTermino = ordemServicoViewModel.HoraTermino;
ordemservicoViewModelOrigem.HoraSaida = ordemServicoViewModel.HoraSaida;
ordemservicoViewModelOrigem.DataPreenchimento = ordemServicoViewModel.DataPreenchimento;
Session["ordeservicoViewModel"] = ordemservicoViewModelOrigem;
TempData["success"] = "Gravado com sucesso a ordem de serviço.";
return(RedirectToAction("ClienteResponsavel", "OrdemServico"));
}
public static bool OrdemServicoUpdate(OrdemServicoViewModel entrada, out OrdemServico ordemServico)
{
ordemServico = new OrdemServico();
ordemServico = entrada.ordemServico;
ordemServico.idCategoriaManutencao = entrada.categoria.id;
ordemServico.idProfissional = entrada.profissional.id;
ordemServico.idCliente = entrada.cliente.id;
if (entrada.ordemServico.statusOrdemServico == CustomEnumStatus.StatusOrdemServico.Cancelado || entrada.ordemServico.statusOrdemServico == CustomEnumStatus.StatusOrdemServico.Fechado)
{
entrada.ordemServico.dataFechamento = DateTime.Now;
}
//************ Objetos de controle de acesso para Update*******************
ordemServico.modificadoEm = DateTime.Now;
ordemServico.modificadoPor = entrada.contexto.idUsuario;
ordemServico.modificadoPorName = entrada.contexto.nomeUsuario;
//************ FIM Objetos de controle de acesso ***************
return(true);
}
// GET: Ordem
public ActionResult ConsultarOrdem()
{
OrdemServicoNegocio servicoNegocio = new OrdemServicoNegocio();
List <OrdemServicoViewModel> lstOrdem = new List <OrdemServicoViewModel>();
OrdemServicoViewModel model = new OrdemServicoViewModel();
foreach (var ordem in servicoNegocio.Consulta())
{
model.Id = ordem.Id;
model.Motivo = ordem.Motivo;
model.Obs = ordem.Obs;
model.Orcamento = ordem.Orçamento;
model.Placa = ordem.Placa;
model.Status = ordem.Status;
model.DataAbertura = ordem.DataAbertura.ToString("dd-MM-yyyy");
model.ColaboradorId = ordem.ColaboradorId;
lstOrdem.Add(model);
}
return(View(lstOrdem));
}
public async Task <ActionResult <OrdemServicoListViewModel> > GetById(Guid id)
{
var ordemServico = await _ordemServicoRepository.GetByIdAsync(id);
if (ordemServico != null)
{
var result = new OrdemServicoViewModel
{
Id = ordemServico.Id,
PostoColetaId = ordemServico.PostoColetaId,
PostoColetaNome = ordemServico.PostoColeta.Descricao,
DataExame = ordemServico.DataExame,
PacienteId = ordemServico.PacienteId,
PacienteNome = ordemServico.Paciente.Nome,
Convenio = ordemServico.Convenio,
MedicoId = ordemServico.MedicoId,
MedicoNome = ordemServico.Medico.Nome,
DataRetirada = ordemServico.DataRetirada,
Exames = new List <OrdemServicoExameViewModel>()
};
ordemServico.Exames.ForEach(x =>
{
result.Exames.Add(
new OrdemServicoExameViewModel
{
Id = x.Id,
OrdemServicoId = x.OrdemServicoId,
ExameId = x.ExameId,
ExameNome = x.Exame.Descricao,
Preco = x.Preco
});
});
return(Ok(result));
}
else
{
return(NotFound());
}
}
public OrdemServicoViewModel Adicionar(OrdemServicoViewModel ordemServicoViewModel)
{
var OrdemServico = Mapper.Map <OrdemServicoViewModel, OrdemServico>(ordemServicoViewModel);
BeginTransaction();
foreach (var grupo in OrdemServico.Grupos)
{
grupo.IdGrupoAtividadeOriginal = grupo.IdGrupoAtividade;
var listaTipos = new List <TipoPacto>();
foreach (var tipo in grupo.TiposPacto)
{
var t = _tipoPactoService.ObterPorId(tipo.IdTipoPacto);
listaTipos.Add(t);
}
grupo.TiposPacto = listaTipos;
}
foreach (var criterioAvaliacao in OrdemServico.CriteriosAvaliacao)
{
criterioAvaliacao.IdCriterioAvaliacaoOriginal = criterioAvaliacao.IdCriterioAvaliacao;
foreach (var itemAvaliacao in criterioAvaliacao.ItensAvaliacao)
{
itemAvaliacao.NotaMaxima = _notaAvaliacaoService.ObterPorId(itemAvaliacao.IdNotaMaxima);
}
}
var osReturn = _ordemservicoService.Adicionar(OrdemServico);
if (osReturn.ValidationResult.IsValid)
{
_logService.Logar(OrdemServico, ordemServicoViewModel.Usuario.CPF, Domain.Enums.Operacao.Inclusão.ToString());
Commit();
}
ordemServicoViewModel = Mapper.Map <OrdemServico, OrdemServicoViewModel>(osReturn);
return(ordemServicoViewModel);
}
public async Task <IActionResult> Create(OrdemServicoViewModel ordemServicoViewModel)
{
bool hasErrors = !ModelState.IsValid;
if (!hasErrors)
{
hasErrors = ResponseHasErrors(await _ordemServicoAppService.Add(ordemServicoViewModel));
}
if (hasErrors)
{
ViewData["ConvenioId"] = new SelectList(_convenioAppService.GetAll().Result, "Id", "Nome", ordemServicoViewModel.Convenio?.Id);
ViewData["MedicoId"] = new SelectList(_medicoAppService.GetAll().Result, "Id", "Nome", ordemServicoViewModel.Medico?.Id);
ViewData["PacienteId"] = new SelectList(_pacienteAppService.GetAll().Result, "Id", "Nome", ordemServicoViewModel.Paciente?.Id);
ViewData["PostoColetaId"] = new SelectList(_postoColetaAppService.GetAll().Result, "Id", "Descricao", ordemServicoViewModel.PostoColeta?.Id);
return(View(ordemServicoViewModel));
}
ordemServicoViewModel = await _ordemServicoAppService.GetByNumber(ordemServicoViewModel.Numero);
return(RedirectToAction("edit", "ordem", new { id = ordemServicoViewModel.Id }));
}
public JsonResult Cadastrar(OrdemServicoViewModel model)
{
OrdemServico ordemServico = new OrdemServico();
ColaboradorNegocio colaboradorNegocio = new ColaboradorNegocio();
Colaborador c = colaboradorNegocio.Consulta(model.ColaboradorId);
OrdemServico o = new OrdemServico();
//o.Colaborador = c;
o.ColaboradorId = c.Id;
o.DataAbertura = DateTime.Now;
o.Motivo = model.Motivo;
o.Obs = model.Obs;
o.Orçamento = model.Orcamento;
o.Placa = model.Placa;
o.Status = model.Status;
OrdemServicoNegocio ordemNegocio = new OrdemServicoNegocio();
ordemNegocio.Cadastrar(o);
return(Json(""));
}
public JsonResult Edit(OrdemServicoViewModel model)
{
try
{
OrdemServicoNegocio ordemServicoNegocio = new OrdemServicoNegocio();
OrdemServico o = ordemServicoNegocio.Consulta(model.Id);
o.Motivo = model.Motivo;
o.Obs = model.Obs;
o.Orçamento = model.Orcamento;
o.Placa = model.Placa;
o.Status = model.Status;
o.ColaboradorId = model.ColaboradorId;
o.DataAbertura = Convert.ToDateTime(model.DataAbertura.Replace("-", "/"));
ordemServicoNegocio.Altualizar(o);
return(Json(""));
}
catch (Exception ex)
{
throw;
}
}
public ViewResult FormUpdateOrdemServico(string id)
{
OrdemServicoViewModel modelo = new OrdemServicoViewModel();
modelo.ordemServico.id = new Guid(id);
if (!String.IsNullOrEmpty(id))
{
modelo.ordemServico = ordemServicoData.Get(modelo.ordemServico.id);
modelo.contexto = this.contexto;
SqlGeneric sqlServices = new SqlGeneric();
if (modelo.ordemServico != null)
{
if (!String.IsNullOrEmpty(sqlData.RetornaRelacaoAgendamentoByIdReferencia(modelo.ordemServico.id).codigo))
{
modelo.idAgendamento = sqlData.RetornaRelacaoAgendamentoByIdReferencia(modelo.ordemServico.id).id.ToString();
}
modelo.cliente = sqlData.RetornaRelacaoCliente(modelo.ordemServico.idCliente);
modelo.listaPreco = sqlData.RetornaRelacaoListaPreco(modelo.ordemServico.idListaPreco);
//Prenche lista de preço para o contexto da página
List <SelectListItem> itens = new List <SelectListItem>();
itens = HelperAttributes.PreencheDropDownList(sqlServices.RetornaRelacaoCategoriaManutencao());
modelo.categorias = itens;
//apresenta mensagem de registro atualizado com sucesso
modelo.StatusMessage = StatusMessage;
if (modelo.ordemServico.idProfissional != null)
{
modelo.profissional = sqlData.RetornaRelacaoProfissional(modelo.ordemServico.idProfissional);
}
}
}
return(View(modelo));
}
public IActionResult FormCreateOrdemServico(OrdemServicoViewModel entrada)
{
OrdemServico modelo = new OrdemServico();
entrada.contexto = this.contexto;
try
{
if (entrada.ordemServico != null)
{
if (OrdemServicoRules.OrdemServicoCreate(entrada, out modelo))
{
ordemServicoData.Add(modelo);
return(RedirectToAction("FormUpdateOrdemServico", new { id = modelo.id.ToString() }));
}
}
}
catch (Exception ex)
{
LogOsca log = new LogOsca();
log.GravaLog(1, 5, this.contexto.idUsuario, this.contexto.idOrganizacao, "FormCreateOrdemServico-post", ex.Message);
}
return(View());
}