protected override void OnAppearing()
{
base.OnAppearing();
BindingContext = new AtividadeViewModel();
((AtividadeViewModel)BindingContext).RefreshCommand.Execute(null);
}
public AtividadeViewModel CarregarAtividadeLigacao(AtividadeViewModel view, string userId)
{
var atividade = new Atividade(
view.id
, view.atividadeTipoID
, view.criadoEm
, view.criadoPorUserID
, view.responsavelPorUserID
, view.statusAtividadeID
, view.ocorrenciaID
, view.contratoID
, view.atendimentoID
, view.previsaoDeExecucao
, view.finalizadoEm
, view.finalizadoPorUserID
, view.titulo
, view.descricao
, view.pessoaFisicaID
, view.pessoaJuridicaID
, view.potenciaisClientesID);
var retorno = _atividadeServico.Adicionar(atividade);
return(new AtividadeViewModel(atividade.Id, atividade.AtividadeTipoId, atividade.PessoasFisicasId,
atividade.PessoasJuridicasId));
}
public ViewResult FormStatusAtividade(string id)
{
AtividadeViewModel modelo = new AtividadeViewModel();
modelo.contexto = this.contexto;
try
{
Atividade retorno = new Atividade();
if (!String.IsNullOrEmpty(id))
{
//campo que sempre contém valor
retorno = atividadeData.Get(new Guid(id));
if (retorno != null)
{
modelo.atividade = retorno;
}
}
}
catch (Exception ex)
{
LogOsca log = new LogOsca();
log.GravaLog(1, 4, this.contexto.idUsuario, this.contexto.idOrganizacao, "FormStatusAtividade-get", ex.Message);
}
return(View(modelo));
}
public ViewResult FormUpdateAtividade(string id)
{
AtividadeViewModel modelo = new AtividadeViewModel();
modelo.atividade = new Atividade();
modelo.atividade.id = new Guid(id);
SqlGenericData sqlData = new SqlGenericData();
Atividade retorno = new Atividade();
if (!String.IsNullOrEmpty(id))
{
retorno = atividadeData.Get(modelo.atividade.id);
modelo.profissional = sqlData.RetornaRelacaoProfissional(retorno.idProfissional);
if (retorno != null)
{
modelo.atividade = retorno;
//apresenta mensagem de registro atualizado com sucesso
modelo.StatusMessage = StatusMessage;
}
}
return(View(modelo));
}
public ActionResult Create(AtividadeViewModel atividadeViewModel)
{
for (int i = 0; i < atividadeViewModel.Tipos.Count; i++)
if (atividadeViewModel.Tipos[i].Excluir)
{
ModelState.Remove("Tipos[" + i + "].IdTipoAtividade");
ModelState.Remove("Tipos[" + i + "].Faixa");
ModelState.Remove("Tipos[" + i + "].DuracaoFaixa");
ModelState.Remove("Tipos[" + i + "].DuracaoFaixaPresencial");
ModelState.Remove("Tipos[" + i + "].Excluir");
}
if (ModelState.IsValid)
{
atividadeViewModel.Usuario = getUserLogado();
if (atividadeViewModel.IdAtividade == 0)
atividadeViewModel = _atividadeAppService.Adicionar(atividadeViewModel);
else
atividadeViewModel = _atividadeAppService.Atualizar(atividadeViewModel);
if (atividadeViewModel.ValidationResult.IsValid)
return setMessageAndRedirect(atividadeViewModel.ValidationResult.Message, "Index");
else
setModelErrorList(atividadeViewModel.ValidationResult.Erros);
}
return View(atividadeViewModel);
}
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Atividade atividade = await db.Atividades.FindAsync(id);
if (atividade == null)
{
return(HttpNotFound());
}
Referencia refe = atividade.Usuario.GetReferencia(atividade.Inicio.Year, atividade.Inicio.Month);
if (refe.Fechado)
{
MensagemParaUsuarioViewModel.MensagemAlerta("Você não pode alterar uma atividade de um mês que já foi fechado.", TempData);
return(RedirectToAction("Index"));
}
AtividadeViewModel atvVm = Mapper.Map <AtividadeViewModel>(atividade);
CarregaTipos(atvVm.IdTipoAtividade);
CarregaProjetos(atvVm.IdProjectNode);
return(View(atvVm));
}
public int SalvarAtividade(AtividadeViewModel atividadeViewModel)
{
var entidade = _mapper.Map <Atividade>(atividadeViewModel);
entidade.DataAlteracao = null;
entidade.DataCriacao = DateTime.Now;
return(_atividadeRepository.SalvarAtividade(entidade));
}
public AtividadeView()
{
AtividadeViewModel = new AtividadeViewModel();
BindingContext = AtividadeViewModel;
InitializeComponent();
}
public AtividadeRealizadaView()
{
InitializeComponent();
NavigationPage.SetHasBackButton(this, false);
BindingContext = new AtividadeViewModel();
}
private static void TratarTiposAtividadeExcluidos(AtividadeViewModel atividadeViewModel)
{
for (var i = atividadeViewModel.Tipos.Count - 1; i >= 0; i--)
{
if (atividadeViewModel.Tipos[i].Excluir && atividadeViewModel.Tipos[i].IdTipoAtividade == 0)
{
atividadeViewModel.Tipos.RemoveAt(i);
}
}
}
public IActionResult NovaEntrada()
{
var listas = new AtividadeViewModel(
listaDeAtividades: AtividadeRepository.ListarAtividades(),
listaDeMarcas: AtividadeRepository.ListarMarcas(),
listaDeModelos: AtividadeRepository.ListarModelos()
);
ViewData["ViewName"] = "Nova Entrada";
return(View(listas)); //Redirecionar para uma tela de sucesso
}
public IActionResult BalancoDeAtividade()
{
AtividadeViewModel listas = new AtividadeViewModel(
listaDeAtividades: AtividadeRepository.ListarAtividades(),
listaDeMarcas: AtividadeRepository.ListarMarcas(),
listaDeModelos: AtividadeRepository.ListarModelos()
);
ViewData["ViewName"] = "Balanço de Atividade";
return(View(listas));
}
public ViewResult FormCreateAtividade()
{
AtividadeViewModel modelo = new AtividadeViewModel();
modelo.atividade = new Atividade();
modelo.contexto = contexto;
modelo.atividade.criadoEm = DateTime.Now;
modelo.atividade.criadoPorName = contexto.nomeUsuario;
return(View(modelo));
}
public AtividadeViewModel Remover(AtividadeViewModel atividadeViewModel)
{
var atividade = Mapper.Map <AtividadeViewModel, Atividade>(atividadeViewModel);
BeginTransaction();
var atividadeReturn = _atividadeService.Remover(atividade);
_logService.Logar(atividade, atividadeViewModel.Usuario.CPF, Domain.Enums.Operacao.Exclusão.ToString());
Commit();
return(Mapper.Map <Atividade, AtividadeViewModel>(atividadeReturn));;
}
public ActionResult Atualizar(AtividadeViewModel atividade)
{
if (ModelState.IsValid)
{
var atividadeDominio = Mapper.Map <AtividadeViewModel, Atividade>(atividade);
_aplicacaoAtividade.Atualizar(atividadeDominio);
return(RedirectToAction("Index"));
}
return(View(atividade));
}
public CadastroView()
{
InitializeComponent();
AtividadeViewModel vm = new AtividadeViewModel();
vm.Titulo = "Titulo teste";
vm.Descricao = "Descrição teste";
vm.Ativo = true;
DataContext = new ViewModels.AtividadeViewModel();
}
public ActionResult Edit(AtividadeViewModel atividade)
{
if (ModelState.IsValid)
{
var atividadeDomain = Mapper.Map <AtividadeViewModel, Atividade>(atividade);
_atividadeApp.Update(atividadeDomain);
return(RedirectToAction("Index"));
}
ViewBag.Tarefa_Id = new SelectList(_tarefaApp.GetAll(), "Id", "Nome", atividade.Tarefa_Id);
ViewBag.Pessoa_Id = new SelectList(_pessoaApp.GetAll(), "Id", "Nome", atividade.Pessoa_Id);
return(View(atividade));
}
public IActionResult Create(AtividadeViewModel atividade)
{
if (ModelState.IsValid)
{
var entityAtividade = _mapper.Map <Atividade>(atividade);
var usuarioAtualId = User.FindFirst(ClaimTypes.NameIdentifier).Value;
entityAtividade.UsuarioCadastroId = usuarioAtualId;
entityAtividade.UsuarioModificacaoId = usuarioAtualId;
string jsonContent = JsonConvert.SerializeObject(entityAtividade);
var resultTask = ClientPostAsync(_api, jsonContent);
return(RedirectToAction("Index"));
}
return(View());
}
public static bool AtividadeUpdate(AtividadeViewModel entrada, out Atividade modelo)
{
modelo = new Atividade();
modelo = entrada.atividade;
modelo.idProfissional = entrada.profissional.id;
if (entrada.atividade.statusAtividade == CustomEnumStatus.StatusAtividade.Cancelada || entrada.atividade.statusAtividade == CustomEnumStatus.StatusAtividade.Concluida)
{
modelo.dataFechamento = DateTime.Now;
}
////************ Objetos de controle de acesso ***************
modelo.modificadoEm = DateTime.Now;
modelo.modificadoPor = entrada.contexto.idUsuario;
modelo.modificadoPorName = entrada.contexto.nomeUsuario;
////************ FIM Objetos de controle de acesso ***************
return(true);
}
public ActionResult Create(int? id)
{
AtividadeViewModel obj = new AtividadeViewModel();
if (!id.HasValue)
{
obj = new AtividadeViewModel();
obj.Usuario = getUserLogado();
obj.Tipos = new List<TipoAtividadeViewModel>();
obj.Tipos.Add(new TipoAtividadeViewModel { Excluir = false });
}
else
{
obj = _atividadeAppService.ObterPorId(id.Value);
obj.Usuario = getUserLogado();
obj.PctMinimoReducao = obj.PctMinimoReducao;
}
ViewBag.ListaUsuarios = new System.Web.Script.Serialization.JavaScriptSerializer().Serialize(_usuarioAppService.ObterTodos(obj.Usuario.Unidade).Select(a => a.Nome).ToList());
return View(obj);
}
public ActionResult VisualizarAtividade(int id_atividade)
{
var atividadeVM = new AtividadeViewModel();
_repositorio = new AtividadesRepositorio();
_repositorio_questao = new QuestoesRepositorio();
_repositorio_opcao = new OpcoesRepositorio();
var atividade = _repositorio.RetornaAtividadesPorId(id_atividade);
atividadeVM.Nome_atividade = atividade.Titulo.ToString();
ViewData["id_unidade"] = atividade.Id_unidade;
var questao = _repositorio_questao.ListaQuestoesPorAtividadeAtivasOrdenadas(id_atividade);
var opcao = _repositorio_opcao.ListaOpcoesPorAtividade(id_atividade);
atividadeVM.ListaQuestoes = questao;
atividadeVM.ListaOpcoes = opcao;
return(PartialView(atividadeVM));
}
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Atividade atividade = await db.Atividades.FindAsync(id);
if (atividade == null)
{
return(HttpNotFound());
}
AtividadeViewModel atvVm = Mapper.Map <AtividadeViewModel>(atividade);
CarregaTipos(atvVm.IdTipoAtividade);
CarregaProjetos(atvVm.IdProjectNode);
CarregaUsuarios(atvVm.IdUsuario);
return(View(atvVm));
}
public ActionResult Create(AtividadeViewModel atividade)
{
try
{
if (ModelState.IsValid)
{
var atividadeDomain = Mapper.Map <AtividadeViewModel, Atividade>(atividade);
_atividadeApp.Add(atividadeDomain);
return(RedirectToAction("Index"));
}
}
catch (EntidadeException exp)
{
ModelState.AddModelError("", exp.Message);
}
ViewBag.Tarefa_Id = new SelectList(_tarefaApp.GetAll(), "Id", "Nome", atividade.Tarefa_Id);
ViewBag.Pessoa_Id = new SelectList(_pessoaApp.GetAll(), "Id", "Nome", atividade.Pessoa_Id);
return(View(atividade));
}
public IActionResult FormCreateAtividade(AtividadeViewModel entrada)
{
Atividade modelo = new Atividade();
try
{
if (entrada.atividade != null)
{
if (AtividadeRules.AtividadeCreate(entrada, out modelo, contexto))
{
atividadeData.Add(modelo);
return(RedirectToAction("FormUpdateAtividade", new { id = modelo.id.ToString() }));
}
}
}
catch (Exception ex)
{
LogOsca log = new LogOsca();
log.GravaLog(1, 27, this.contexto.idUsuario, this.contexto.idOrganizacao, "FormCreateAtividade-post", ex.Message);
}
return(View());
}
public ActionResult Pergunta()
{
_repositorio = new MeusCursosRepositorio();
_repositorioResultado = new ResultadosRespositorio();
_repositorioAtividade = new AtividadesRepositorio();
_repositorioOpcao = new OpcoesRepositorio();
TempData.Keep("id_atividade");
TempData.Keep("id_inscricao");
TempData.Keep("id_resultado");
int id_atividade = Convert.ToInt32(TempData["id_atividade"]);
int id_resultado = Convert.ToInt32(TempData["id_resultado"]);
int id_inscricao = Convert.ToInt32(TempData["id_inscricao"]);
//Mostra a primeira pergunta
AtividadeViewModel atividade = new AtividadeViewModel();
atividade.Id = _repositorioAtividade.RetornaAtividadesPorId(id_atividade).Id_atividade;
atividade.Nome_atividade = _repositorioAtividade.RetornaAtividadesPorId(id_atividade).Titulo;
atividade.ListaQuestoes = _repositorio.BuscaQuestoesAtividade(id_atividade, id_resultado);
atividade.IdResultado = id_resultado;
atividade.IdInscricao = id_inscricao;
atividade.ListaOpcoes = _repositorioOpcao.ListaOpcoesPorAtividade(id_atividade);
//Já respondeu todas as questões então verifica se pode fechar a avaliação
if (atividade.ListaQuestoes.Count == 0)
{
List <Resultado> listaresultados1 = _repositorioResultado.ListaResultados(id_inscricao, id_atividade);
//Verifica se o resultado não foi ainda finalizado
if (listaresultados1[0].finalizado == false)
{
//Finaliza o resultado
_repositorio.FinalizaResultado(listaresultados1[0].Id_resultado);
}
}
return(PartialView(atividade));
}
private TipoAtividade ConfigurarTipoAtividade(AtividadeViewModel atividadeViewModel, Atividade atividade)
{
TipoAtividade tipoAtividade = new TipoAtividade();
foreach (var tipo in atividadeViewModel.Tipos)
{
if (tipo.Excluir)
{
tipoAtividade = _tipoatividadeService.ObterPorId(tipo.IdTipoAtividade);
_tipoatividadeService.Remover(tipoAtividade);
}
else
{
tipoAtividade = Mapper.Map <TipoAtividadeViewModel, TipoAtividade>(tipo);
tipoAtividade.IdAtividade = atividadeViewModel.IdAtividade;
if (tipoAtividade.Faixa == null)
{
tipoAtividade.Faixa = "";
}
if (tipo.IdTipoAtividade == 0)
{
_tipoatividadeService.Adicionar(tipoAtividade);
}
else
{
_tipoatividadeService.Atualizar(tipoAtividade);
}
if (!tipoAtividade.ValidationResult.IsValid)
{
break;
}
atividade.Tipos.Add(tipoAtividade);
}
}
return(tipoAtividade);
}
public JsonResult Create(AtividadeViewModel atividade)
{
var atividadeEdit = new AtividadeViewModel()
{
Id = atividade.Id,
DataRealizada = atividade.DataRealizada,
Pessoa = atividade.Pessoa,
Pessoa_Id = atividade.Pessoa_Id,
Tarefa = atividade.Tarefa,
Tarefa_Id = atividade.Tarefa_Id
};
Atividade atividadeDomain;
try
{
if (atividadeEdit.Pessoa != null)
{
atividadeEdit.Pessoa_Id = atividadeEdit.Pessoa.Id;
atividadeEdit.Pessoa = null;
}
if (atividadeEdit.Tarefa != null)
{
atividadeEdit.Tarefa_Id = atividadeEdit.Tarefa.Id;
atividadeEdit.Tarefa = null;
}
atividadeDomain = Mapper.Map <AtividadeViewModel, Atividade>(atividadeEdit);
_atividadeApp.Add(atividadeDomain);
atividade.Id = atividadeEdit.Id;
}
catch (Exception exp)
{
Response.StatusCode = 500;
var msg = exp.InnerException == null ? exp.Message : exp.InnerException.InnerException.Message;
return(Json(new { msg }, JsonRequestBehavior.AllowGet));
}
return(Json(atividade, JsonRequestBehavior.AllowGet));
}
public AtividadeViewModel SalvarAtendimentoLigacao(AtividadeViewModel view)
{
var entidade = _atividadeServico.ObterPorId(view.id);
entidade.PrevisaoDeExecucao = view.previsaoDeExecucao;
entidade.Descricao = view.descricao;
entidade.Titulo = view.titulo ?? "";
_atividadeServico.Atualizar(entidade);
entidade = _atividadeServico.ObterPorId(view.id);
if (view.filaID != null)
{
_atividadeServico.AtualizarResponsavel(entidade.Id, null, null);
var listaAtividadeFila =
_atividadeFilaServico.ObterPorAtividadeId(entidade.Id).Where(c => c.SaiuDaFilaEm == null);
foreach (var item in listaAtividadeFila)
{
_atividadeFilaServico.AtualizaSaiuDaFilaEm(item.Id);
}
_atividadeFilaServico.Adicionar(new AtividadeFila(entidade.Id, Convert.ToInt32(view.filaID)));
}
var ligacao = _ligacaoServico.ObterPorId(view.LigacaoViewModel.id);
ligacao.PessoaFisicaId = view.LigacaoViewModel.pessoaFisicaID;
ligacao.PessoaJuridicaId = view.LigacaoViewModel.pessoaJuridicaID == 0
? null
: view.LigacaoViewModel.pessoaJuridicaID;
ligacao.TelefoneId = view.LigacaoViewModel.telefoneID;
ligacao.Sentido = view.LigacaoViewModel.sentido;
var retornoLigacao = _ligacaoServico.Atualizar(ligacao);
return(new AtividadeViewModel(entidade.Id, entidade.AtividadeTipoId, view.LigacaoViewModel.pessoaFisicaID,
view.LigacaoViewModel.pessoaJuridicaID));
}
public IActionResult FormUpdateAtividade(AtividadeViewModel entrada)
{
Atividade modelo = new Atividade();
entrada.contexto = this.contexto;
try
{
if (AtividadeRules.AtividadeUpdate(entrada, out modelo))
{
atividadeData.Update(modelo);
StatusMessage = "Registro Atualizado com Sucesso!";
return(RedirectToAction("FormUpdateAtividade", new { id = modelo.id.ToString(), idOrg = contexto.idOrganizacao }));
}
}
catch (Exception ex)
{
LogOsca log = new LogOsca();
log.GravaLog(1, 27, this.contexto.idUsuario, this.contexto.idOrganizacao, "FormUpdateAtividade-post", ex.Message);
}
return(RedirectToAction("FormUpdateAtividade", new { id = modelo.id.ToString() }));
}
public static bool AtividadeCreate(AtividadeViewModel entrada, out Atividade modelo, ContextPage contexto)
{
modelo = new Atividade();
modelo = entrada.atividade;
modelo.idProfissional = entrada.profissional.id;
if (modelo.assunto != null)
{
////************ Objetos de controle de acesso ***************
modelo.criadoEm = DateTime.Now;
modelo.criadoPor = contexto.idUsuario;
modelo.criadoPorName = contexto.nomeUsuario;
modelo.modificadoEm = DateTime.Now;
modelo.modificadoPor = contexto.idUsuario;
modelo.modificadoPorName = contexto.nomeUsuario;
modelo.idOrganizacao = contexto.idOrganizacao;
////************ FIM Objetos de controle de acesso ***************
return(true);
}
return(false);
}
