public async Task <ActionResult> LancaPlanilhaPost(ImportacaoPlanilhaAtividadesViewModel planmodel)
{
CarregaTipos();
CarregaProjetos();
CarregaUsuarios();
if (ModelState.IsValid && planmodel != null && planmodel.Itens.Count > 0)
{
try
{
ImportaPlanilhaApplication app = new ImportaPlanilhaApplication(this.db);
int linhas = await app.LancarAsync(planmodel);
MensagemParaUsuarioViewModel.MensagemSucesso(string.Format("Planilha importada com sucesso! {0} linhas da planilha importadas.", linhas), TempData);
return(View("Index"));
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro(err.Message, TempData, ModelState);
LogServices.LogarException(err);
}
}
return(View(planmodel));
}
public async Task <ActionResult> Busca(AtividadeBuscaStringViewModel abvmUsu)
{
if (abvmUsu == null || abvmUsu.IsBlank())
{
abvmUsu = (Session["abvmUsu"] as AtividadeBuscaStringViewModel) ?? new AtividadeBuscaStringViewModel();
}
var usu = this.User.Identity.Name;
var usuLogado = db.Usuarios.Where(u => u.Login == usu).FirstOrDefault();
if (usuLogado != null)
{
DateTime?DataInicio = TFW.TFWConvert.ToNullableDateTime(abvmUsu.DataInicio) ?? new DateTime(1901, 1, 1);
DateTime?DataFim = (TFW.TFWConvert.ToNullableDateTime(abvmUsu.DataFim) ?? new DateTime(2100, 12, 31)).AddDays(1).AddSeconds(-1);
var app = new AtividadeApplication(db);
var attIdx = await app.GetAtividadeIndexAsync(usuLogado.Id, DataInicio, DataFim);
//as referencias mostradas no combo não devem refletir as trazidas na busca
var referencias = await app.GetReferenciasUltimoAnoAsync(usuLogado.Id);
CarregaReferencias(referencias, attIdx.Referencias.Count > 0 ? attIdx.Referencias.First().Id : new Nullable <int>());
Session["abvmUsu"] = abvmUsu;
return(View("Index", attIdx));
}
MensagemParaUsuarioViewModel.MensagemErro("Usuário não autorizado.");
return(View("Index", new AtividadeIndexViewModel()));
}
public async Task <ActionResult> Delete(int?id)
{
if (id == null)
{
MensagemParaUsuarioViewModel.MensagemErro("Não foi especificado um item para excluir", TempData, ModelState);
return(RedirectToAction("index"));
}
try
{
Usuario usuario = await db.Usuarios.FindAsync(id);
if (usuario == null)
{
MensagemParaUsuarioViewModel.MensagemErro("O item não foi encontrado", TempData, ModelState);
return(RedirectToAction("index"));
}
return(View(usuario));
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro(err.Message, TempData, ModelState);
return(RedirectToAction("index"));
}
}
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 async Task <ActionResult> RemoverTodosOsNodes(int IdUsuarioExclusaoTodos)
{
try
{
UsuarioApplication usuapp = new UsuarioApplication(this.db);
Usuario usu = usuapp.GetById(IdUsuarioExclusaoTodos);
usu.NosDoUsuario.Clear();
await db.SaveChangesAsync();
MensagemParaUsuarioViewModel.MensagemSucesso("Projetos removidos", TempData);
return(RedirectToAction("AdicionarNode", new { Id = IdUsuarioExclusaoTodos }));
}
catch (UsuarioApplicationException uaex)
{
MensagemParaUsuarioViewModel.MensagemErro(uaex.Message, TempData, ModelState);
}
catch (DbUpdateConcurrencyException duce)
{
MensagemParaUsuarioViewModel.MensagemErro(" Talvez esse registro tenha sido excluído por outra pessoa. " + duce.Message, TempData, ModelState);
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro("Esse registro não pôde ser excluído. " + err.Message, TempData, ModelState);
}
return(RedirectToAction("AdicionarNode", new { Id = IdUsuarioExclusaoTodos }));
}
public async Task <ActionResult> ResetarTodasSenhas()
{
var todos = await UserManager.Users.ToListAsync();
string erros = "";
bool deuErro = false;
foreach (var u in todos)
{
try
{
if (await UserManager.HasPasswordAsync(u.Id))
{
var reset = await UserManager.RemovePasswordAsync(u.Id);
if (!reset.Succeeded)
{
deuErro = true;
erros += string.Join("<br/>\r\n", reset.Errors.ToArray());
}
}
var result = await UserManager.AddPasswordAsync(u.Id, SENHA_RESETADA_PADRAO);
if (result.Succeeded)
{
var usr = await UserManager.FindByIdAsync(u.Id);
if (usr == null)
{
deuErro = true;
erros += "<br/>\r\nUsuário não encontrado depois de definir senha: " + u.Email + "<br/>\r\n";
}
}
else
{
deuErro = true;
erros += string.Join("<br/>\r\n", result.Errors.ToArray());
}
}
catch (Exception err)
{
deuErro = true;
erros += err.Message + "<br/>\r\n";
}
}
if (deuErro)
{
MensagemParaUsuarioViewModel.MensagemErro(erros, TempData, ModelState);
}
else
{
MensagemParaUsuarioViewModel.MensagemSucesso("Todas as senhas resetadas para " + SENHA_RESETADA_PADRAO, TempData);
}
return(RedirectToAction("Index"));
}
public async Task <ActionResult> Index()
{
var dtini = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1);
var dtfin = dtini.AddMonths(1).AddSeconds(-1);
var abvmUsu = (Session != null ? Session["abvmUsu"] as AtividadeBuscaStringViewModel : new AtividadeBuscaStringViewModel()) ?? new AtividadeBuscaStringViewModel();
if ((abvmUsu != null) && (!abvmUsu.IsBlank()))
{
return(await Busca(abvmUsu));
}
if (this.User != null && this.User.Identity != null)
{
var usu = this.User.Identity.Name;
var usuLogado = db.Usuarios.Where(u => u.Login == usu).FirstOrDefault();
if (usuLogado != null)
{
var app = new AtividadeApplication(db);
var attIdx = await app.GetAtividadeIndexAsync(usuLogado.Id, new Nullable <DateTime>(), new Nullable <DateTime>());
//as referencias mostradas no combo não devem refletir as trazidas na busca
var referencias = await app.GetReferenciasUltimoAnoAsync(usuLogado.Id);
CarregaReferencias(referencias, attIdx.Referencias.Count > 0 ? attIdx.Referencias.First().Id : new Nullable <int>());
return(View(attIdx));
}
}
MensagemParaUsuarioViewModel.MensagemErro("Usuário não autorizado.");
return(View(new AtividadeIndexViewModel()));
}
public async Task <ActionResult> RemoverNode(int IdUsuarioExclusao, int IdNodeExclusao, bool RemoverRecursivo)
{
try
{
UsuarioApplication usu = new UsuarioApplication(this.db);
await usu.RemoverNodeAsync(IdUsuarioExclusao, IdNodeExclusao, RemoverRecursivo);
MensagemParaUsuarioViewModel.MensagemSucesso("Projeto removido", TempData);
return(RedirectToAction("AdicionarNode", new { Id = IdUsuarioExclusao }));
}
catch (UsuarioApplicationException uaex)
{
MensagemParaUsuarioViewModel.MensagemErro(uaex.Message, TempData, ModelState);
}
catch (DbUpdateConcurrencyException duce)
{
MensagemParaUsuarioViewModel.MensagemErro(" Talvez esse registro tenha sido excluído por outra pessoa. " + duce.Message, TempData, ModelState);
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro("Esse registro não pôde ser excluído. " + err.Message, TempData, ModelState);
}
return(RedirectToAction("AdicionarNode", new { Id = IdUsuarioExclusao }));
}
public async Task <ActionResult> RemoverPerfil(int IdUsuarioExclusao, int IdPerfilExclusao)
{
try
{
Usuario usuario = db.Usuarios.Find(IdUsuarioExclusao);
if (usuario != null)
{
Perfil perfil = usuario.Perfis.Where(x => x.Id == IdPerfilExclusao).FirstOrDefault();
if (perfil != null)
{
usuario.Perfis.Remove(perfil);
await db.SaveChangesAsync();
}
}
return(RedirectToAction("AdicionarRole", new { Id = IdUsuarioExclusao }));
}
catch (DbUpdateConcurrencyException duce)
{
MensagemParaUsuarioViewModel.MensagemErro(" Talvez esse registro tenha sido excluído por outra pessoa. " + duce.Message, TempData, ModelState);
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro("Esse registro não pôde ser excluído. " + err.Message, TempData, ModelState);
}
return(RedirectToAction("AdicionarRole", new { Id = IdUsuarioExclusao }));
}
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
MensagemParaUsuarioViewModel.MensagemErro("Não foi especificado um item para editar", TempData, ModelState);
return(RedirectToAction("index"));
}
try
{
TipoAtividade tipoAtividade = await db.TiposAtividade.FindAsync(id);
if (tipoAtividade == null)
{
MensagemParaUsuarioViewModel.MensagemErro("O item não foi encontrado", TempData, ModelState);
return(RedirectToAction("index"));
}
return(View(tipoAtividade));
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro(err.Message, TempData, ModelState);
return(RedirectToAction("index"));
}
}
public async Task <ActionResult> RemoverAcao(int IdAcaoExclusao, int IdPerfilExclusao)
{
try
{
Acao acao = db.Acoes.Find(IdAcaoExclusao);
Perfil perfil = db.Perfis.Find(IdPerfilExclusao);
if ((acao != null) && (perfil != null))
{
perfil.Acoes.Remove(acao);
await db.SaveChangesAsync();
}
return(RedirectToAction("AdicionarAcao", new { Id = IdPerfilExclusao }));
}
catch (DbUpdateConcurrencyException duce)
{
MensagemParaUsuarioViewModel.MensagemErro(" Talvez esse registro tenha sido excluído por outra pessoa. " + duce.Message, TempData, ModelState);
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro("Esse registro não pôde ser excluído. " + err.Message, TempData, ModelState);
}
return(RedirectToAction("AdicionarAcao", new { Id = IdPerfilExclusao }));
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
Perfil perfil = new Perfil {
Id = id
};
try
{
db.Entry(perfil).State = EntityState.Deleted;
await db.SaveChangesAsync();
MensagemParaUsuarioViewModel.MensagemSucesso("Registro Excluido.", TempData);
return(RedirectToAction("Index"));
}
catch (DbUpdateConcurrencyException duce)
{
MensagemParaUsuarioViewModel.MensagemErro(" Talvez esse registro tenha sido excluído por outra pessoa. " + duce.Message, TempData, ModelState);
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro("Esse registro não pôde ser excluído. " + err.Message, TempData, ModelState);
}
return(View(perfil));
}
public async Task <ActionResult> AdicionarAcao(int?id)
{
if (id == null)
{
MensagemParaUsuarioViewModel.MensagemErro("Escolha um perfil para adicionar ações", TempData, ModelState);
return(RedirectToAction("index"));
}
try
{
Perfil perfil = await db.Perfis.FindAsync(id);
if (perfil == null)
{
MensagemParaUsuarioViewModel.MensagemErro("O perfil não foi encontrado", TempData, ModelState);
return(RedirectToAction("index"));
}
PerfilAcaoViewModel pavm = new PerfilAcaoViewModel
{
Perfil = perfil,
IdPerfil = perfil.Id
};
CarregaAcoes(perfil);
return(View(pavm));
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro(err.Message, TempData, ModelState);
return(RedirectToAction("index"));
}
}
public async Task <ActionResult> Delete(int?id)
{
if (id == null)
{
MensagemParaUsuarioViewModel.MensagemErro("Não foi especificado um item para excluir", TempData, ModelState);
return(RedirectToAction("index"));
}
try
{
Produto tp = await _appSvc.GetByIdAsync(id.Value);
if (tp == null)
{
MensagemParaUsuarioViewModel.MensagemErro("O item não foi encontrado", TempData, ModelState);
return(RedirectToAction("index"));
}
return(View(tp));
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro(err.Message, TempData, ModelState);
return(RedirectToAction("index"));
}
}
public async Task <ActionResult> Editar(int?id)
{
ComboTipoProduto();
if ((id == null) || (id == 0))
{
return(View(new Produto()));
}
try
{
Produto pd = await _appSvc.GetByIdAsync(id.Value);
if (pd != null)
{
return(View(pd));
}
else
{
MensagemParaUsuarioViewModel.MensagemErro("Esse registro não pôde ser encontrado. ", TempData, ModelState);
}
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro("Esse registro não pôde ser visualizado. " + err.Message, TempData, ModelState);
}
return(View());
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
Produto tp = await _appSvc.GetByIdAsync(id);
if (tp != null)
{
try
{
await _appSvc.DeleteAsync(id);
MensagemParaUsuarioViewModel.MensagemSucesso("Registro Excluido.", TempData);
return(RedirectToAction("Index"));
}
catch (DbUpdateConcurrencyException duce)
{
MensagemParaUsuarioViewModel.MensagemErro(" Talvez esse registro tenha sido excluído por outra pessoa. " + duce.Message, TempData, ModelState);
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro("Esse registro não pôde ser excluído. " + err.Message, TempData, ModelState);
}
}
else
{
MensagemParaUsuarioViewModel.MensagemErro("Registro não encontrado.", TempData, ModelState);
}
return(View(tp));
}
public async Task <ActionResult> Create([Bind(Include = "Id, Login, EnviarAlertaLancamento")] Usuario usuario)
{
if (ModelState.IsValid)
{
usuario.Login = usuario.Login.Trim();
db.Usuarios.Add(usuario);
try
{
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
catch (DbUpdateConcurrencyException duce)
{
MensagemParaUsuarioViewModel.MensagemErro("Talvez esse registro tenha sido excluído por outra pessoa. " + duce.Message, TempData, ModelState);
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro("Esse registro não pôde ser salvo. " + err.Message, TempData, ModelState);
}
}
return(View(usuario));
}
public async Task <ActionResult> AdicionarNode(int?id)
{
if (id == null)
{
MensagemParaUsuarioViewModel.MensagemErro("Escolha um usuário para adicionar estruturas de projeto", TempData, ModelState);
return(RedirectToAction("index"));
}
try
{
Usuario usuario = await db.Usuarios.FindAsync(id);
if (usuario == null)
{
MensagemParaUsuarioViewModel.MensagemErro("O usuário não foi encontrado", TempData, ModelState);
return(RedirectToAction("index"));
}
UsuarioNodeViewModel urvm = new UsuarioNodeViewModel
{
Usuario = usuario,
IdUsuario = usuario.Id
};
CarregaNodes();
return(View(urvm));
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro(err.Message, TempData, ModelState);
return(RedirectToAction("index"));
}
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
AtividadeApplication app = new AtividadeApplication(this.db);
await app.DeleteAsync(id, true);
MensagemParaUsuarioViewModel.MensagemSucesso("Registro Excluido.", TempData);
return(RedirectToAction("Index"));
}
public async Task <ActionResult> Delete(int id)
{
MensagemParaUsuarioViewModel result = new MensagemParaUsuarioViewModel();
ProjectNode prj = await db.ProjectNodes.FindAsync(id);
if (prj != null)
{
try
{
if (prj.Filhos != null && prj.Filhos.Count > 0)
{
result.Sucesso = false;
result.Mensagem = "Não se pode excluir um nó de projeto com dependentes. Exclua os itens primeiro.";
result.Titulo = "Erro ao excluir nó de projeto";
}
else if (prj.Atividades != null && prj.Atividades.Count > 0)
{
result.Sucesso = false;
result.Mensagem = "Este nó de projeto não pode ser excluído porque tem atividades lançadas para ele.";
result.Titulo = "Erro ao excluir nó de projeto";
}
else
{
prj.UsuariosDesteNode.Clear();
db.ProjectNodes.Remove(prj);
await db.SaveChangesAsync();
result.Sucesso = true;
result.Mensagem = "Item excluído com sucesso.";
result.Titulo = "exclusão de item do projeto";
}
}
catch (Exception err)
{
LogServices.LogarException(err);
result.Sucesso = false;
result.Mensagem = err.Message;
if (err.InnerException != null)
{
result.Mensagem += "\r\n" + err.InnerException.Message;
if (err.InnerException.InnerException != null)
{
result.Mensagem += "\r\n" + err.InnerException.InnerException.Message;
}
}
result.Titulo = "Erro ao excluir nó de projeto";
}
}
else
{
result.Sucesso = false;
result.Mensagem = "Não foi selecionado nenhum nó de projeto para exclusão.";
result.Titulo = "Erro ao excluir nó de projeto";
}
return(Json(result));
}
public async Task <ActionResult> DeleteMultiploConfirmado(int[] ids)
{
AtividadeApplication app = new AtividadeApplication(this.db);
foreach (int i in ids)
{
await app.DeleteAsync(i, true);
}
MensagemParaUsuarioViewModel.MensagemSucesso("Registros Excluidos.", TempData);
return(RedirectToAction("DeleteMultiplo"));
}
public async Task <ActionResult> Edit([Bind(Include = "Id,Nome,HorasEstimadas, IdNodeLabel")] ProjectNodeViewModel projectNodeVm)
{
if (ModelState.IsValid)
{
try
{
var existente = db.ProjectNodes.Any(x => (x.Pai_Id ?? 0) == (projectNodeVm.IdPai ?? 0) && x.Nome == projectNodeVm.Nome);
if (existente)
{
MensagemParaUsuarioViewModel.MensagemErro("Já existe um item com esse mesmo nome debaixo deste nó de projeto. \r\n Itens de projetos com nomes repetidos podem existir dentro de nós de projeto diferentes, mas não debaixo do mesmo nó.", TempData, ModelState);
CarregaNodeLabels();
return(View(projectNodeVm));
}
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro("Não foi possível pesquisar no banco de dados por este item.\r\n " + LogServices.ConcatenaExceptions(err), TempData, ModelState);
CarregaNodeLabels();
return(View(projectNodeVm));
}
try
{
ProjectNode pn = db.ProjectNodes.Find(projectNodeVm.Id);
NodeLabel nl = db.NodeLabels.Find(projectNodeVm.IdNodeLabel);
int?idpai = pn.Pai != null?pn.Pai.Id:new Nullable <int>();
pn.Nome = projectNodeVm.Nome;
pn.HorasEstimadas = projectNodeVm.HorasEstimadas;
pn.NodeLabel = nl;
await db.SaveChangesAsync();
return(RedirectToAction("Index", new { Id = idpai }));
}
catch (DbUpdateConcurrencyException duce)
{
MensagemParaUsuarioViewModel.MensagemErro(" Talvez esse registro tenha sido excluído por outra pessoa. \r\n " + LogServices.ConcatenaExceptions(duce), TempData, ModelState);
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro("Esse registro não pôde ser salvo. \r\n " + LogServices.ConcatenaExceptions(err), TempData, ModelState);
}
}
CarregaNodeLabels();
return(View(projectNodeVm));
}
public ActionResult ImportarDoAssembly(bool atualizarDescricoes = false)
{
int alterados = 0;
Type tipo = Type.GetType("TPA.Presentation.Controllers.TPAController, TPA.Presentation");
AcaoServices g = new AcaoServices(db);
alterados = g.ImportarDoAssembly(tipo, atualizarDescricoes);
g.AtualizaAdmin();
MensagemParaUsuarioViewModel.MensagemInfo(string.Format("Foram importadas/atualizadas {0} ações do sistema", alterados), TempData);
return(RedirectToAction("Index"));
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
ProjectNode projectNode = await db.ProjectNodes.FindAsync(id);
if (projectNode == null)
{
MensagemParaUsuarioViewModel.MensagemErro("Registro não encontrado", TempData, ModelState);
return(RedirectToAction("Index"));
}
if (projectNode.Filhos.Count > 0)
{
MensagemParaUsuarioViewModel.MensagemAlerta("Este projeto não pode ser excluído porque tem projetos filhos associados a ele.", TempData);
return(RedirectToAction("Index"));
}
if (projectNode.Atividades.Count > 0)
{
MensagemParaUsuarioViewModel.MensagemAlerta("Este projeto não pode ser excluído porque já tem atividades lançadas para ele.", TempData);
return(RedirectToAction("Index"));
}
if (projectNode.UsuariosDesteNode.Count > 0)
{
MensagemParaUsuarioViewModel.MensagemAlerta("Este projeto não pode ser excluído porque está designado a usuários nas configurações do usuário.", TempData);
return(RedirectToAction("Index"));
}
try
{
db.Entry(projectNode).State = EntityState.Deleted;
await db.SaveChangesAsync();
MensagemParaUsuarioViewModel.MensagemSucesso("Registro Excluido.", TempData);
return(RedirectToAction("Index"));
}
catch (DbUpdateConcurrencyException duce)
{
MensagemParaUsuarioViewModel.MensagemErro(" Talvez esse registro tenha sido excluído por outra pessoa. \r\n " + LogServices.ConcatenaExceptions(duce), TempData, ModelState);
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro("Esse registro não pôde ser excluído. \r\n " + LogServices.ConcatenaExceptions(err), TempData, ModelState);
}
return(View(projectNode));
}
public async Task <ActionResult> EnviarTodosEmailsDeAlerta()
{
try
{
UsuarioApplication usuApp = new UsuarioApplication(this.db);
await usuApp.EnviarTodosOsAlertasAsync(true, true);
MensagemParaUsuarioViewModel.MensagemSucesso("Alertas enviados com sucesso.", TempData);
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro(err.Message, TempData, ModelState);
}
return(RedirectToAction("AtrasoLancamento"));
}
public ActionResult Download(int id)
{
var arquivo = db.Atestados.Find(id);
if (arquivo != null)
{
byte[] fileBytes = arquivo.Arquivo;
string fileName = arquivo.NomeArquivoOriginal;
return(File(fileBytes, System.Net.Mime.MediaTypeNames.Application.Octet, fileName));
}
else
{
MensagemParaUsuarioViewModel.MensagemErro("Registro não encontrado.", TempData);
return(RedirectToAction("Index"));
}
}
public async Task <ActionResult> AdicionarNode(UsuarioNodeViewModel urvm)
{
CarregaNodes();
if ((urvm == null) || (urvm.IdUsuario == 0))
{
MensagemParaUsuarioViewModel.MensagemErro("Usuário não encontrado", TempData, ModelState);
return(RedirectToAction("index"));
}
if ((urvm == null) || (urvm.IdNode == 0) || (urvm.IdUsuario == 0))
{
MensagemParaUsuarioViewModel.MensagemErro("O Nó de Projeto e o usuário devem ser informados.", TempData, ModelState);
return(View(urvm));
}
if (ModelState.IsValid)
{
try
{
UsuarioApplication usu = new UsuarioApplication(this.db);
await usu.AdicionarNodeAsync(urvm);
MensagemParaUsuarioViewModel.MensagemSucesso("Projeto adicionado", TempData);
return(View(urvm));
}
catch (UsuarioApplicationException uaex)
{
MensagemParaUsuarioViewModel.MensagemErro(uaex.Message, TempData, ModelState);
}
catch (DbUpdateConcurrencyException duce)
{
MensagemParaUsuarioViewModel.MensagemErro("Talvez esse registro tenha sido excluído por outra pessoa. " + duce.Message, TempData, ModelState);
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro("Esse registro não pôde ser salvo. " + err.Message, TempData, ModelState);
}
}
return(View(urvm));
}
public async Task <ActionResult> ConfirmaDeleteMultiplo(int[] ids)
{
if (ids == null || ids.Length == 0)
{
MensagemParaUsuarioViewModel.MensagemErro("Escolha pelo menos um registro!", TempData, ModelState);
return(RedirectToAction("DeleteMultiplo"));
}
List <Atividade> atividades = await db.Atividades.Where(a => ids.Contains(a.Id)).ToListAsync();
if (atividades == null)
{
return(HttpNotFound());
}
return(View(atividades));
}
public ActionResult Index(FormCollection formCollection)
{
CarregaTipos();
CarregaProjetos();
CarregaUsuarios();
if (Request != null)
{
HttpPostedFileBase file = Request.Files["UploadedFile"];
if ((file != null) && (file.ContentLength > 0) && !string.IsNullOrEmpty(file.FileName) && (Path.GetExtension(file.FileName).ToUpper() == ".XLSX"))
{
string fileName = file.FileName;
string fileContentType = file.ContentType;
using (var package = new ExcelPackage(file.InputStream))
{
try
{
ImportaPlanilhaApplication app = new ImportaPlanilhaApplication(this.db);
var planilha = app.TransformarPlanilhaAdmin(package);
return(View("LancaPlanilha", planilha));
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro(err.ToString(), TempData, ModelState);
LogServices.LogarException(err);
}
}
}
else
{
MensagemParaUsuarioViewModel.MensagemErro("Faça o upload de uma planilha de horários em excel .xlsx no padrão da Tecnun.", TempData, ModelState);
}
}
else
{
MensagemParaUsuarioViewModel.MensagemErro("Ocorreu algum erro e o request está nulo", TempData, ModelState);
}
return(View("Index"));
}
public async Task <ActionResult> Edit([Bind(Include = "Id, IdUsuario, HorasPrevistasString, Fechado")] FechamentoViewModel referencia)
{
if (referencia.HorasPrevistasDouble < 0)
{
MensagemParaUsuarioViewModel.MensagemErro("Favor preencher as horas previstas", TempData, ModelState);
}
if (ModelState.IsValid)
{
try
{
var refe = db.Referencias.Find(referencia.Id);
if (refe != null)
{
refe.Previsto = referencia.HorasPrevistasTimeSpan;
refe.Fechado = referencia.Fechado;
refe.SincronizaAtividades(new CalendarioServices());
await db.SaveChangesAsync();
MensagemParaUsuarioViewModel.MensagemSucesso("Alterações salvas.", TempData);
return(View(referencia));
}
else
{
MensagemParaUsuarioViewModel.MensagemErro("Não foi encontrada a referência deste mês para este funcionário", TempData, ModelState);
}
}
catch (DbEntityValidationException ex)
{
string exceptionMessage = LogServices.ConcatenaErrosDbEntityValidation(ex);
MensagemParaUsuarioViewModel.MensagemErro(exceptionMessage, TempData, ModelState);
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro(err.Message, TempData, ModelState);
}
}
return(View(referencia));
}