private void UploadFilesHandler(SolicitacaoViewModel viewModel, int id)
{
var targetDirectory = string.Format("~/Documents/{0}/Solicitacoes/{1}", id, DateTime.Now.ToString("yyyyMMdd"));
if (!Directory.Exists(Server.MapPath(targetDirectory)))
{
Directory.CreateDirectory(Server.MapPath(targetDirectory));
}
foreach (PropertyInfo propertyInfo in viewModel.GetType().GetProperties())
{
if (propertyInfo.PropertyType == typeof(HttpPostedFileBase) && propertyInfo.Name != "Foto")
{
var propertyValue = propertyInfo.GetValue(viewModel);
if (propertyValue == null)
{
continue;
}
var postedFileName = propertyValue.GetType().GetProperty("FileName").GetValue(propertyValue);
//To Get File Extension
string fileExtension = Path.GetExtension(postedFileName.ToString());
//Add Current Date To Attached File Name
string fileName = string.Format("{0}-{1}{2}", DateTime.Now.ToString("yyyyMMddHHmmss"), propertyInfo.Name, fileExtension);
//Its Create complete path to store in server.
string uploadPath = string.Format("{0}/{1}", targetDirectory, fileName);
//To copy and save file into server.
propertyInfo.PropertyType.GetMethod("SaveAs").Invoke(propertyValue, new object[] { Server.MapPath(uploadPath) });
viewModel.GetType().GetProperty(propertyInfo.Name + "Path").SetValue(viewModel, uploadPath);
}
}
}
public SolicitacaoViewModel BuscarModuloProduto(int idCliente, int idModulo)
{
var clienteModuloServico = new ClienteModuloServico();
var solicitacaoViewModel = new SolicitacaoViewModel();
try
{
var model = clienteModuloServico.ObterPorModulo(idCliente, idModulo);
if (model != null)
{
solicitacaoViewModel.ModuloId = model.ModuloId;
solicitacaoViewModel.ModuloCodigo = model.Modulo.Codigo;
solicitacaoViewModel.ModuloNome = model.Modulo.Nome;
if (model.Produto != null)
{
solicitacaoViewModel.ProdutoId = model.ProdutoId;
solicitacaoViewModel.ProdutoCodigo = model.Produto.Codigo;
solicitacaoViewModel.ProdutoNome = model.Produto.Nome;
}
}
return(solicitacaoViewModel);
}
catch (Exception ex)
{
solicitacaoViewModel.Mensagem = ex.Message;
return(solicitacaoViewModel);
}
}
public ActionResult Delete(long?id)
{
if (id != null)
{
Solicitacao solicitacao = SolicitacaoService.ObterSolicitacaoPorId(id);
if (solicitacao != null)
{
if (solicitacao.ClienteId.ToString() != Gerenciador.FindByEmail(HttpContext.GetOwinContext().Authentication.User.Identity.Name).Id)
{
return(new HttpStatusCodeResult(HttpStatusCode.Unauthorized));
}
SolicitacaoViewModel solicitacaoView = new SolicitacaoViewModel()
{
Solicitacao = solicitacao
};
return(View(solicitacaoView));
}
else
{
return(new HttpNotFoundResult("Item não encontrado"));
}
}
else
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
}
//[ValidateAntiForgeryToken]
public ActionResult Edit(SolicitacaoViewModel model)
{
try
{
var solicitacao = model.MapearParaObjetoDominio();
solicitacao.Atualizacao = DateTime.Now;
solicitacao.Atualizador = User.Identity.Name;
UploadFilesHandler(model, model.IdPessoa);
solicitacao.CertAntCrimPCFilePath = model.CertAntCrimPCFilePath;
solicitacao.CertAntCrimPFFilePath = model.CertAntCrimPFFilePath;
solicitacao.CertTJBAFilePath = model.CertTJBAFilePath;
solicitacao.CertTRFFilePath = model.CertTRFFilePath;
SolicitacaoService.AtualizarAnexos(solicitacao);
return(Json(new
{
success = true,
title = "Sucesso",
message = "Anexos cadastrados com sucesso !"
}, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
return(Json(new
{
success = false,
title = "Erro",
message = ex.Message
}, JsonRequestBehavior.AllowGet));
}
}
//[ValidateAntiForgeryToken]
public ActionResult Create(SolicitacaoViewModel model)
{
try
{
var solicitacao = model.MapearParaObjetoDominio();
solicitacao.Criador =
solicitacao.Atualizador = User.Identity.Name;
UploadFilesHandler(model, solicitacao.PessoaId.Value);
solicitacao.CertAntCrimPCFilePath = model.CertAntCrimPCFilePath;
solicitacao.CertAntCrimPFFilePath = model.CertAntCrimPFFilePath;
solicitacao.CertAntCrimPFFilePath = model.CertTJBAFilePath;
solicitacao.CertTRFFilePath = model.CertTRFFilePath;
SolicitacaoService.Salvar(solicitacao);
return(Json(new
{
success = true,
title = "Sucesso",
message = "Solicitação cadastrada com sucesso !"
}, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
return(Json(new
{
success = false,
title = "Erro",
message = ex.Message
}, JsonRequestBehavior.AllowGet));
}
}
public ActionResult Create()
{
var v_SolicitacaoViewModel = new SolicitacaoViewModel();
v_SolicitacaoViewModel.FatosCotidianos = db.FatosCotidiano.OrderBy(p => p.Nome).ToList();
return(View(v_SolicitacaoViewModel));
}
public ActionResult Create(SolicitacaoViewModel solicitacaoViewModel)
{
try
{
if (ModelState.IsValid)
{
var v_AtividadeSemestral =
db.AtividadesSemestrais.Where(
p =>
p.AreaConhecimento.FatoCotidiano.Any(
o => o.Id == solicitacaoViewModel.IdFatoCotidiano) && p.Ativo).FirstOrDefault();
var v_FatoCotidiano =
db.FatosCotidiano.Where(p => p.Id == solicitacaoViewModel.IdFatoCotidiano).FirstOrDefault();
if (v_AtividadeSemestral == null)
{
solicitacaoViewModel.FatosCotidianos = db.FatosCotidiano.OrderBy(p => p.Nome).ToList();
ModelState.AddModelError("",
"Não existe atividade semestral ativa para o Tipo de Assunto selecionado.");
return(View(solicitacaoViewModel));
}
var v_GuidUser = User.Identity.GetUserId();
var v_Solicitacao = new Solicitacao
{
AtividadeSemestralId =
v_AtividadeSemestral.Id,
DataCadastro = DateTime.Now,
Situacao = SituacaoEnum.Criado,
UsuarioCliente = db.Users.Where(p => p.Id == v_GuidUser).FirstOrDefault(),
Descricao = solicitacaoViewModel.Descricao,
Duvida = solicitacaoViewModel.Duvida,
IdentificacaoPartes = solicitacaoViewModel.IdentificacaoPartes,
FatoCotidianoId = solicitacaoViewModel.IdFatoCotidiano
};
db.Solicitacaos.Add(v_Solicitacao);
db.SaveChanges();
return(RedirectToAction("Index"));
}
}
catch (DbEntityValidationException e)
{
foreach (var eve in e.EntityValidationErrors)
{
Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
ve.PropertyName, ve.ErrorMessage);
}
}
throw;
}
return(View(solicitacaoViewModel));
}
public async Task <ActionResult <SolicitacaoViewModel> > Adicionar([FromBody] SolicitacaoViewModel solicitacaoViewModel)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _solicitacaoService.Adicionar(_mapper.Map <Solicitacao>(solicitacaoViewModel));
return(CustomResponse(solicitacaoViewModel));
}
public async Task <SolicitacaoViewModel> Atualizar(SolicitacaoViewModel solicitacao)
{
var solicitavaoContent = ObterConteudo(solicitacao);
var response = await _httpClient.PostAsync("/solicitacao/atualizar-solicitacao/", solicitavaoContent);
if (!TratarErrosResponse(response))
{
solicitacao.ResponseResult = await DeserializarObjetoResponse <ResponseResult>(response);
}
return(solicitacao);
}
public void UpdateSolicitacoes(int idSolicitacao, SolicitacaoViewModel model)
{
Solicitacao oldSolicitacao = _repository.Find((long)idSolicitacao);
if (!oldSolicitacao.FlStatus.Equals("P"))
{
throw new Exception("Está solicitação já foi atualizada");
}
Solicitacao novaSolicitacao = _mapper.Map <Solicitacao>(model);
_repository.UpdateAsync(novaSolicitacao);
}
public ActionResult Update(int idSolicitacao, [FromBody] SolicitacaoViewModel solicitacao)
{
_log.LogInformation($"==> Action Update({idSolicitacao}, {solicitacao}) :: SolicitacaoController -> executou " + DateTime.Now.ToLongTimeString());
try
{
_service.UpdateSolicitacoes(idSolicitacao, solicitacao);
return(Ok("Solicitação atualizada com sucesso"));
}
catch (Exception e)
{
_log.LogError($"==> Action Update({idSolicitacao}, {solicitacao}) :: SolicitacaoController -> Erro: {e.Message} " + DateTime.Now.ToLongTimeString());
return(this.StatusCode(StatusCodes.Status500InternalServerError, $"Erro ao processar requisição. Erro: {e.Message}"));
}
}
// GET: Solicitacao/Delete/5
public ActionResult Delete(int?id)
{
SolicitacaoViewModel model = new SolicitacaoViewModel(this.SolicitacaoService.ObterPorId(id));
model.Aeroportos = AeroportoService.ObterTodos();
model.Empresas = EmpresaService.ObterTodos();
model.Contratos = ContratoService.ObterTodos();
model.TiposSolicitacao = TipoSolicitacaoService.ObterTodos();
model.Areas = AreaService.Listar().ToList();
model.Cargo = CargoService.Listar().ToList();
model.RamoAtividade = RamoAtividadeService.ObterTodos().ToList();
return(PartialView(model));
}
public SolicitacaoViewModel Salvar(SolicitacaoViewModel model, int idUsuario, bool ocorrencia)
{
string URI = Constantes.URL + "Solicitacao?idUsuario={0}";
if (model.Id == 0)
{
URI = Constantes.URL + "Solicitacao/Incluir?usuarioId={0}";
return(new Operacao <SolicitacaoViewModel>().Insert(string.Format(URI, idUsuario), model));
}
else
{
URI = Constantes.URL + "Solicitacao/Alterar?usuarioId={0}";
return(new Operacao <SolicitacaoViewModel>().Update(string.Format(URI, idUsuario, ocorrencia), model));
}
}
public SolicitacaoViewModel Update([FromBody] SolicitacaoViewModel viewModel, int usuarioId)
{
try
{
var model = viewModel.Adapt <Solicitacao>();
_solicitacaoServico.Salvar(model, usuarioId);
viewModel = model.Adapt <SolicitacaoViewModel>();
return(viewModel);
}
catch (Exception ex)
{
viewModel.Mensagem = ex.Message;
return(viewModel);
}
}
public SolicitacaoViewModel Delete(int idUsuario, int id)
{
var viewModel = new SolicitacaoViewModel();
try
{
var model = _solicitacaoServico.ObterPorId(id);
_solicitacaoServico.Excluir(idUsuario, model);
return(viewModel);
}
catch (Exception ex)
{
viewModel.Mensagem = ex.Message;
return(viewModel);
}
}
public async Task <ActionResult <SolicitacaoViewModel> > Atualizar(Guid id, [FromBody] SolicitacaoViewModel solicitacaoViewModel)
{
if (id != solicitacaoViewModel.Id)
{
NotificarErro("O id informado não é o mesmo que foi passado na query");
return(CustomResponse(solicitacaoViewModel));
}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _solicitacaoService.Atualizar(_mapper.Map <Solicitacao>(solicitacaoViewModel));
return(CustomResponse(solicitacaoViewModel));
}
public SolicitacaoViewModel ObterPorId(int id)
{
var viewModel = new SolicitacaoViewModel();
try
{
var model = _solicitacaoServico.ObterPorId(id);
viewModel = model.Adapt <SolicitacaoViewModel>();
return(viewModel);
}
catch (Exception ex)
{
viewModel.Mensagem = ex.Message;
return(viewModel);
}
}
public static SolicitacaoViewModel ToViewModel(this Solicitacao solicitacao)
{
var viewModel = new SolicitacaoViewModel
{
Protocolo = solicitacao.Abertura.Protocolo,
DataDeAbertura = solicitacao.Abertura.DataDaAbertura,
Situacao = solicitacao.Situacao.GetStringValue(),
SituacaoCodigo = solicitacao.Situacao,
Codigo = solicitacao.Codigo,
DiasSLA = solicitacao.Abertura.Tipo.SLA,
Solicitante = solicitacao.Abertura.Responsavel.Nome,
Tipo = solicitacao.Abertura.Tipo.Descricao,
Programa = solicitacao.Abertura.Programa
};
return(viewModel);
}
// GET: Solicitacao/Create
public ActionResult Create(string id)
{
SolicitacaoViewModel model = new SolicitacaoViewModel();
model.IdPessoa = Convert.ToInt32(id);
model.Aeroportos = AeroportoService.ObterTodos().OrderBy(a => a.Descricao).ToList();
model.Empresas = new List <Empresa>(); //EmpresaService.ObterTodos();
model.Contratos = new List <Contrato>(); //ContratoService.ObterTodos();
model.TiposSolicitacao = TipoSolicitacaoService.ObterTodos();
model.Areas = AreaService.Listar().OrderBy(a => a.Sigla).ToList();
model.Cargo = CargoService.Listar().OrderBy(c => c.Descricao).ToList();
model.RamoAtividade = RamoAtividadeService.ObterTodos().OrderBy(r => r.Descricao).ToList();
return(PartialView(model));
}
public SolicitacaoViewModel Editar(int idUsuario, int id)
{
var viewModel = new SolicitacaoViewModel();
try
{
string mensagem = "";
var model = _solicitacaoServico.Editar(idUsuario, id, ref mensagem);
viewModel = model.Adapt <SolicitacaoViewModel>();
PopularSolicitacao(viewModel, model, idUsuario);
viewModel.Mensagem = mensagem;
return(viewModel);
}
catch (Exception ex)
{
viewModel.Mensagem = ex.Message;
return(viewModel);
}
}
public async Task <IActionResult> Salvar(SolicitacaoViewModel model)
{
var Index = _solicitacaoApp.Insert(new Solicitacao()
{
Nome = model.Nome,
Celular = model.Celular,
Telefone = model.Telefone,
Email = model.Email,
Endereco = model.Endereco,
Numero = model.Numero,
Bairro = model.Bairro,
Municipio = model.Municipio,
UF = model.UF,
Cep = model.Cep,
Contato = model.Contato,
SolicitacaoStatusId = model.SolicitacaoStatusId,
Assunto = model.Assunto,
});
return(Json(Index));
}
public async Task <IActionResult> Index([Bind("Busca")] SolicitacaoViewModel solicitacao)
{
var aproximaContext = new List <Solicitacao>();
if (ModelState.IsValid)
{
aproximaContext = await _context.Solicitacao
.Include(s => s.Classificacao)
.Where(m => string.IsNullOrEmpty(solicitacao.Busca) || m.Id == new Guid(solicitacao.Busca))
.ToListAsync();
foreach (var item in aproximaContext)
{
item.Classificacao.Descricao = Breadcrumb(item.ClassificacaoId);
}
}
return(View(new SolicitacaoViewModel {
Solicitacoes = aproximaContext
}));
}
public SolicitacaoViewModel Novo(int idUsuario)
{
var viewModel = new SolicitacaoViewModel();
try
{
var model = _solicitacaoServico.Novo(idUsuario);
viewModel = model.Adapt <SolicitacaoViewModel>();
viewModel.UsuarioAberturaId = model.UsuarioAbertura.Id;
viewModel.UsuarioAberturaCodigo = model.UsuarioAbertura.Codigo;
viewModel.UsuarioAberturaNome = model.UsuarioAbertura.Nome;
viewModel.StatusId = model.Status.Id;
viewModel.StatusCodigo = model.Status.Codigo;
viewModel.StatusNome = model.Status.Nome;
return(viewModel);
}
catch (Exception ex)
{
viewModel.Mensagem = ex.Message;
return(viewModel);
}
}
public async Task <IActionResult> ResponderSolicitacao(SolicitacaoViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var solicitacao = await _solicitacaoService.ObterPorId(model.Id);
if (solicitacao != null)
{
OrdemViewModel ordem = new OrdemViewModel
{
IdSolicitacao = solicitacao.Id,
IdSolicitante = _user.ObterUserId(),
CodDepartamento = solicitacao.CodDepartamento,
DataSolucao = DateTime.Now,
Solucao = model.Solucao,
Descricao = "Resposta a solicitação do cidadão"
};
var response = await _ordemService.Adicionar(ordem);
if (ResponsePossuiErros(response))
{
TempData["Erros"] = ModelState.Values.SelectMany(v => v.Errors.Select(e => e.ErrorMessage)).ToList();
ViewData["Cidadao"] = await _cidadaoService.ObterPorId(solicitacao.IdSolicitante);
return(View(model));
}
return(RedirectToAction("AtenderSolicitacao", "Departamento"));
}
else
{
AdicionarErroValidacao("Solicitação não encontrada.");
}
return(RedirectToAction("AtenderSolicitacao", "Departamento"));
}
public async Task <ActionResult> Create([Bind(Include = "SolicitacaoId,Equipamento,DataSolicitacao,Quantidade,Status")] SolicitacaoViewModel solicitacaoViewModel, int Setor)
{
var solicitacao = new Solicitacao
{
Equipamento = solicitacaoViewModel.Equipamento,
Quantidade = solicitacaoViewModel.Quantidade,
};
if (ModelState.IsValid)
{
Setor setor = db.Setores.Find(Setor);
solicitacao.Setor = setor;
solicitacao.Status = Solicitacao.Estado.Aguardando;
solicitacao.DataSolicitacao = DateTime.Now;
db.Solicitacoes.Add(solicitacao);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(solicitacao));
}
private void PopularSolicitacao(SolicitacaoViewModel viewModel, Solicitacao model, int usuarioId)
{
if (model.UsuarioAnalista != null)
{
viewModel.AnalistaCodigo = model.UsuarioAnalista.Codigo;
viewModel.AnalistaNome = model.UsuarioAnalista.Nome;
}
if (model.Categoria != null)
{
viewModel.CategoriaCodigo = model.Categoria.Codigo;
viewModel.CategoriaNome = model.Categoria.Nome;
}
if (model.Cliente != null)
{
viewModel.ClienteCodigo = model.Cliente.Codigo;
viewModel.ClienteNome = model.Cliente.Nome;
}
if (model.UsuarioDesenvolvedor != null)
{
viewModel.DesenvolvedorCodigo = model.UsuarioDesenvolvedor.Codigo;
viewModel.DesenvolvedorNome = model.UsuarioDesenvolvedor.Nome;
}
if (model.Modulo != null)
{
viewModel.ModuloCodigo = model.Modulo.Codigo;
viewModel.ModuloNome = model.Modulo.Nome;
}
if (model.Produto != null)
{
viewModel.ProdutoCodigo = model.Produto.Codigo;
viewModel.ProdutoNome = model.Produto.Nome;
}
if (model.Status != null)
{
viewModel.StatusCodigo = model.Status.Codigo;
viewModel.StatusNome = model.Status.Nome;
}
if (model.Tipo != null)
{
viewModel.TipoCodigo = model.Tipo.Codigo;
viewModel.TipoNome = model.Tipo.Nome;
}
if (model.VersaoRelacao != null)
{
viewModel.VersaoDescricao = model.VersaoRelacao.VersaoStr;
}
var usuario = _usuarioServico.ObterPorId(usuarioId);
viewModel.PermissaoAbertura = _solicitacaoServico.PermissaoAbertura(usuario);
viewModel.PermissaoAnalise = _solicitacaoServico.PermissaoAnalise(usuario);
viewModel.PermissaoOcorrenciaGeral = _solicitacaoServico.PermissaoOcorrenciaGeral(usuario);
viewModel.PermissaoOcorrenciaRegra = _solicitacaoServico.PermissaoOcorrenciaRegra(usuario);
viewModel.PermissaoOcorrenciaTecnica = _solicitacaoServico.PermissaoOcorrenciaTecnica(usuario);
viewModel.PermissaoStatus = _solicitacaoServico.PermissaoStatus(usuario);
viewModel.PermissaoTempo = _solicitacaoServico.PermissaoSolicitacaoTempo(usuario);
viewModel.PermissaoConfTempoGeral = _solicitacaoServico.PermissaoConferenciaTempoGeral(usuario);
viewModel.MostrarAnexos = _solicitacaoServico.MostrarAnexos(usuario);
viewModel.CaminhoAnexos = _solicitacaoServico.RetornarCaminhoAnexo();
if (viewModel.SolicitacaoCronogramas != null)
{
foreach (var item in viewModel.SolicitacaoCronogramas)
{
item.CodigoUsuario = item.Usuario.Codigo;
item.NomeUsuario = item.Usuario.Nome;
}
}
if (viewModel.SolicitacaoOcorrencias != null)
{
foreach (var item in viewModel.SolicitacaoOcorrencias)
{
item.CodigoUsuario = item.Usuario.Codigo;
item.NomeUsuario = item.Usuario.Nome;
}
}
if (viewModel.SolicitacaoStatus != null)
{
foreach (var item in viewModel.SolicitacaoStatus)
{
item.NomeStatus = item.Status.Nome;
item.NomeUsuario = item.Usuario.Nome;
item.HoraStr = Utils.FormatarHHMMSS(item.Hora.Value);
}
}
}
public ActionResult Delete(SolicitacaoViewModel solicitacaoView)
{
SolicitacaoService.RemoverSolicitacaoPorId(solicitacaoView.Solicitacao.SolicitacaoId);
TempData["Message"] = "Solicitação Removida com Sucesso!";
return(RedirectToAction("Index"));
}
