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> Busca(AtividadeBuscaStringViewModel abvm)
{
if (abvm == null || abvm.IsBlank())
{
abvm = (Session["abvm"] as AtividadeBuscaStringViewModel) ?? new AtividadeBuscaStringViewModel();
}
List <int> usuarioIds = new List <int>();
if (abvm != null && abvm.IdUsuario != null && abvm.IdUsuario.Length > 0)
{
var ids = abvm.IdUsuario;
foreach (string s in ids)
{
usuarioIds.Add(TFW.TFWConvert.ToInteger(s));
}
}
CarregaUsuarios(usuarioIds);
DateTime?DataInicio = TFW.TFWConvert.ToNullableDateTime(abvm.DataInicio) ?? new DateTime(1901, 1, 1);
DateTime?DataFim = (TFW.TFWConvert.ToNullableDateTime(abvm.DataFim) ?? new DateTime(2100, 12, 31)).AddDays(1).AddSeconds(-1);
var app = new AtividadeApplication(db);
var attIdx = await app.GetAtividadeIndexAsync(usuarioIds, DataInicio, DataFim);
Session["abvm"] = abvm;
return(View("Index", attIdx));
}
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> 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> 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> Index()
{
var abvm = (Session["abvm"] as AtividadeBuscaStringViewModel) ?? new AtividadeBuscaStringViewModel();
if ((abvm != null) && (!abvm.IsBlank()))
{
return(await Busca(abvm));
}
CarregaUsuarios();
var app = new AtividadeApplication(db);
var ativs = await app.GetAtividadeIndexAsync(null, null, null);
return(View(ativs));
}
public async Task <ActionResult> Delete(int id)
{
Atividade atividade = await db.Atividades.FindAsync(id);
if (atividade != null)
{
Referencia refe = atividade.Usuario.GetReferencia(atividade.Inicio.Year, atividade.Inicio.Month);
if (!refe.Fechado)
{
AtividadeApplication app = new AtividadeApplication(this.db);
await app.DeleteAsync(atividade, true);
return(Json(true));
}
}
return(Json(false));
}
public async Task <ActionResult> Adicionar(AtestadoAnexoViewModel avm)
{
if (avm.IdUsuario == 0)
{
MensagemParaUsuarioViewModel.MensagemErro("Favor preencher a data inicial", TempData, ModelState, "IdUsuario");
}
if (avm.Horas == null || avm.Horas == TimeSpan.Zero || avm.Horas.Value.TotalHours > 8)
{
MensagemParaUsuarioViewModel.MensagemErro("Por favor preencha corretamente a quantidade de horas abonadas. Ela não pode ser maior que 8. ", TempData, ModelState, "Horas");
}
if (avm.DataInicial == DateTime.MinValue)
{
MensagemParaUsuarioViewModel.MensagemErro("Favor preencher a data inicial", TempData, ModelState, "DataInicial");
}
if (avm.DataFinal < avm.DataInicial)
{
MensagemParaUsuarioViewModel.MensagemErro("A data final deve ser maior ou igual a data inicial", TempData, ModelState, "DataFinal");
}
if (avm.DataFinal == null || avm.DataFinal.Value == DateTime.MinValue)
{
avm.DataFinal = avm.DataInicial;
}
if ((avm.DataFinal.Value - avm.DataInicial).TotalDays > 365)
{
MensagemParaUsuarioViewModel.MensagemErro("Não é permitido um lançamento em lote maior que um ano", TempData, ModelState, "DataFinal");
}
if (ModelState.IsValid)
{
CalendarioServices cal = new CalendarioServices();
AtividadeApplication app = new AtividadeApplication(this.db);
DateTime data = avm.DataInicial.Date;
int IDADMIN = TFW.TFWConvert.ToInteger(ApplicationResources.PROJECTNODE_ADMINISTRATIVO_ID);
int IDATESTADO = TFW.TFWConvert.ToInteger(ApplicationResources.TIPOATIVIDADE_ATESTADO_ID);
var projeto = db.ProjectNodes.Include(X => X.Pai).Where(x => x.Id == IDADMIN).SingleOrDefault();
var tipo = db.TiposAtividade.Find(IDATESTADO);
var usuario = await db.Usuarios.FindAsync(avm.IdUsuario);
avm.NomeUsuario = usuario.FuncionarioNomeOuLogin;
AtestadoAnexo atestado = new AtestadoAnexo();
atestado.Atividades = new List <Atividade>();
atestado.Observacao = avm.Observacao;
byte[] fileData = null;
using (var binaryReader = new BinaryReader(avm.ArquivoAnexo.InputStream))
{
fileData = binaryReader.ReadBytes(Request.Files[0].ContentLength);
}
atestado.Arquivo = fileData;
atestado.NomeArquivoOriginal = avm.ArquivoAnexo.FileName;
db.Atestados.Add(atestado);
while (data <= avm.DataFinal)
{
try
{
if (cal.IsDiaUtil(data))
{
Atividade atv = new Atividade
{
Observacao = avm.Observacao,
Inicio = data,
Fim = data.Add(avm.Horas.Value),
ProjectNode = projeto,
TipoAtividade = tipo,
Usuario = usuario
};
await app.SalvarAsync(atv, true);
atestado.Atividades.Add(atv);
}
}
catch (DbEntityValidationException ex)
{
string exceptionMessage = LogServices.ConcatenaErrosDbEntityValidation(ex);
MensagemParaUsuarioViewModel.MensagemErro(exceptionMessage, TempData, ModelState);
return(View(avm));
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro(err.Message, TempData, ModelState);
return(View(avm));
}
finally
{
data = data.AddDays(1);
}
await db.SaveChangesAsync();
}
MensagemParaUsuarioViewModel.MensagemSucesso("Atestado salvo e abonos lançados.", TempData);
return(View(avm));
}
return(View(avm));
}
public async Task <ActionResult> Salvar(AbonoViewModel avm)
{
if (avm.IdsUsuarios == null || avm.IdsUsuarios.Count() == 0)
{
MensagemParaUsuarioViewModel.MensagemErro("Favor preencher a data inicial", TempData, ModelState, "IdsUsuarios");
}
if (avm.DataInicial == DateTime.MinValue)
{
MensagemParaUsuarioViewModel.MensagemErro("Favor preencher a data inicial", TempData, ModelState, "DataInicial");
}
if (avm.DataFinal < avm.DataInicial)
{
MensagemParaUsuarioViewModel.MensagemErro("A data final deve ser maior ou igual a data inicial", TempData, ModelState, "DataFinal");
}
if (avm.DataFinal == null || avm.DataFinal.Value == DateTime.MinValue)
{
avm.DataFinal = avm.DataInicial;
}
if ((avm.DataFinal.Value - avm.DataInicial).TotalDays > 365)
{
MensagemParaUsuarioViewModel.MensagemErro("Não é permitido um lançamento em lote maior que um ano", TempData, ModelState, "DataFinal");
}
if (ModelState.IsValid)
{
CalendarioServices cal = new CalendarioServices();
AtividadeApplication app = new AtividadeApplication(this.db);
DateTime data = avm.DataInicial.Date;
int IDADMIN = TFW.TFWConvert.ToInteger(ApplicationResources.PROJECTNODE_ADMINISTRATIVO_ID);
while (data <= avm.DataFinal)
{
try
{
if (cal.IsDiaUtil(data))
{
var projeto = db.ProjectNodes.Include(X => X.Pai).Where(x => x.Id == IDADMIN).SingleOrDefault();
var tipo = db.TiposAtividade.Where(x => x.Id == avm.IdTipoAtividade).SingleOrDefault();
var usuarios = await db.Usuarios
.Include(x => x.Funcionario)
.Where(u => avm.IdsUsuarios.Contains(u.Id))
.ToListAsync();
string nomesDosUsuarios = string.Join(", ", usuarios.Select(u => u.FuncionarioNomeOuLogin).ToList <string>().ToArray());
foreach (var u in usuarios)
{
if (tipo.Nome == ApplicationResources.TIPOATIVIDADE_FERIAS_NOME)
{
await app.SalvarAsync(new Atividade
{
Observacao = avm.Descricao,
Inicio = data.AddHours(8),
Fim = data.AddHours(12),
ProjectNode = projeto,
TipoAtividade = tipo,
Usuario = u
}, true);
await app.SalvarAsync(new Atividade
{
Observacao = avm.Descricao,
Inicio = data.AddHours(13),
Fim = data.AddHours(17),
ProjectNode = projeto,
TipoAtividade = tipo,
Usuario = u
}, true);
}
else
{
await app.SalvarAsync(new Atividade
{
Observacao = avm.Descricao,
Inicio = data,
Fim = data.Add(avm.Horas.Value),
ProjectNode = projeto,
TipoAtividade = tipo,
Usuario = u
}, true);
}
}
avm.NomeTipoAtividade = tipo.Nome;
avm.NomeUsuario = nomesDosUsuarios;
}
}
catch (DbEntityValidationException ex)
{
string exceptionMessage = LogServices.ConcatenaErrosDbEntityValidation(ex);
MensagemParaUsuarioViewModel.MensagemErro(exceptionMessage, TempData, ModelState);
return(PartialView("~/views/shared/EditorTemplates/AbonoViewModel.cshtml", avm));
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro(err.Message, TempData, ModelState);
return(PartialView("~/views/shared/EditorTemplates/AbonoViewModel.cshtml", avm));
}
finally
{
data = data.AddDays(1);
}
}
MensagemParaUsuarioViewModel.MensagemSucesso("Atividades salvas.", TempData);
return(PartialView("~/views/shared/DisplayTemplates/AbonoViewModel.cshtml", avm));
}
return(PartialView("~/views/shared/EditorTemplates/AbonoViewModel.cshtml", avm));
}
public async Task <ActionResult> Edit([Bind(Include = "Id, Observacao, Data, Inicio, Fim, IdProjectNode, IdTipoAtividade, IdUsuario")] AtividadeViewModel atividadeVm)
{
if (atividadeVm.Data == DateTime.MinValue)
{
MensagemParaUsuarioViewModel.MensagemErro("Favor preencher a data", TempData, ModelState);
}
if ((atividadeVm.Inicio == null) || (atividadeVm.Inicio <= TimeSpan.Zero) || (atividadeVm.Inicio > new TimeSpan(23, 59, 59)))
{
MensagemParaUsuarioViewModel.MensagemErro("Favor preencher uma hora válida para o Início entre 00:00 e 23:59", TempData, ModelState);
}
if ((atividadeVm.Fim == null) || (atividadeVm.Fim <= TimeSpan.Zero) || (atividadeVm.Fim > new TimeSpan(23, 59, 59)))
{
MensagemParaUsuarioViewModel.MensagemErro("Favor preencher uma hora válida para o Fim entre 00:00 e 23:59", TempData, ModelState);
}
if (atividadeVm.Inicio > atividadeVm.Fim)
{
MensagemParaUsuarioViewModel.MensagemErro("A hora de início não pode ser maior que a hora de término", TempData, ModelState);
}
if (ModelState.IsValid)
{
try
{
var projeto = db.ProjectNodes.Find(atividadeVm.IdProjectNode);
var tipo = db.TiposAtividade.Find(atividadeVm.IdTipoAtividade);
var usuario = db.Usuarios.Find(atividadeVm.IdUsuario);
Atividade domainAtv = db.Atividades.Find(atividadeVm.Id);
domainAtv.Observacao = atividadeVm.Observacao;
domainAtv.Inicio = atividadeVm.Data.AddHours(atividadeVm.Inicio.Hours).AddMinutes(atividadeVm.Inicio.Minutes);
domainAtv.Fim = atividadeVm.Data.AddHours(atividadeVm.Fim.Hours).AddMinutes(atividadeVm.Fim.Minutes);
domainAtv.ProjectNode = projeto;
domainAtv.TipoAtividade = tipo;
domainAtv.Usuario = usuario;
AtividadeApplication app = new AtividadeApplication(this.db);
await app.SalvarAsync(domainAtv, true);
MensagemParaUsuarioViewModel.MensagemSucesso("Atividade salva.", TempData);
return(RedirectToAction("Edit", atividadeVm));
}
catch (DbEntityValidationException ex)
{
string exceptionMessage = LogServices.ConcatenaErrosDbEntityValidation(ex);
MensagemParaUsuarioViewModel.MensagemErro(exceptionMessage, TempData, ModelState);
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro(err.Message, TempData, ModelState);
}
}
CarregaTipos();
CarregaProjetos();
CarregaUsuarios();
return(View(atividadeVm));
}
public async Task <ActionResult> Lancar(LancamentoEmLoteModel lctos)
{
if (lctos.IdsUsuarios == null || lctos.IdsUsuarios.Count() == 0)
{
MensagemParaUsuarioViewModel.MensagemErro("Escolha pelo menos um usuário", TempData, ModelState, "IdsUsuarios");
}
if (lctos.DataInicial == DateTime.MinValue)
{
MensagemParaUsuarioViewModel.MensagemErro("Favor preencher a data inicial", TempData, ModelState, "DataInicial");
}
if (lctos.DataFinal == DateTime.MinValue)
{
MensagemParaUsuarioViewModel.MensagemErro("Favor preencher a data final", TempData, ModelState, "DataFinal");
}
if (lctos.DataFinal < lctos.DataInicial)
{
MensagemParaUsuarioViewModel.MensagemErro("A data final deve ser maior ou igual a data inicial", TempData, ModelState, "DataFinal");
}
if ((lctos.DataFinal - lctos.DataInicial).TotalDays > 365)
{
MensagemParaUsuarioViewModel.MensagemErro("Não é permitido um lançamento em lote maior que um ano", TempData, ModelState, "DataFinal");
}
if ((lctos.EntradaManha == null) || (lctos.EntradaManha <= TimeSpan.Zero) || (lctos.EntradaManha > new TimeSpan(23, 59, 59)))
{
MensagemParaUsuarioViewModel.MensagemErro("Favor preencher uma hora válida para a entrada da manhã entre 00:00 e 23:59", TempData, ModelState, "EntradaManha");
}
if ((lctos.SaidaManha == null) || (lctos.SaidaManha <= TimeSpan.Zero) || (lctos.SaidaManha > new TimeSpan(23, 59, 59)))
{
MensagemParaUsuarioViewModel.MensagemErro("Favor preencher uma hora válida para a saída da manhã entre 00:00 e 23:59", TempData, ModelState, "SaidaManha");
}
if ((lctos.EntradaTarde == null) || (lctos.EntradaTarde <= TimeSpan.Zero) || (lctos.EntradaTarde > new TimeSpan(23, 59, 59)))
{
MensagemParaUsuarioViewModel.MensagemErro("Favor preencher uma hora válida para a entrada da tarde entre 00:00 e 23:59", TempData, ModelState, "EntradaTarde");
}
if ((lctos.SaidaTarde == null) || (lctos.SaidaTarde <= TimeSpan.Zero) || (lctos.SaidaTarde > new TimeSpan(23, 59, 59)))
{
MensagemParaUsuarioViewModel.MensagemErro("Favor preencher uma hora válida para a saída da tarde entre 00:00 e 23:59", TempData, ModelState, "SaidaTarde");
}
if (lctos.EntradaManha > lctos.SaidaManha)
{
MensagemParaUsuarioViewModel.MensagemErro("A hora de início não pode ser maior que a hora de término no primeiro horário", TempData, ModelState, "EntradaManha");
}
if (lctos.EntradaTarde > lctos.SaidaTarde)
{
MensagemParaUsuarioViewModel.MensagemErro("A hora de início não pode ser maior que a hora de término no segundo horário", TempData, ModelState, "EntradaTarde");
}
if (lctos.EntradaManha > lctos.SaidaTarde)
{
MensagemParaUsuarioViewModel.MensagemErro("A primeira hora de início não pode ser maior que última hora de término", TempData, ModelState, "EntradaManha");
}
if (lctos.SaidaManha > lctos.EntradaTarde)
{
MensagemParaUsuarioViewModel.MensagemErro("A saída do primeiro horário não pode ser maior que a entrada do segundo horário", TempData, ModelState, "SaidaManha");
}
if (ModelState.IsValid)
{
CalendarioServices cal = new CalendarioServices();
AtividadeApplication app = new AtividadeApplication(this.db);
DateTime data = lctos.DataInicial;
var projeto = await db.ProjectNodes.FindAsync(lctos.IdProjeto);
var tipo = await db.TiposAtividade.FindAsync(lctos.IdTipoAtividade);
var usuarios = await db.Usuarios.Where(u => lctos.IdsUsuarios.Contains(u.Id)).ToListAsync <Usuario>();
while (data <= lctos.DataFinal)
{
try
{
if (cal.IsDiaUtil(data))
{
foreach (Usuario usu in usuarios)
{
await app.SalvarAsync(new Atividade
{
Observacao = lctos.Descricao,
Inicio = data.AddHours(lctos.EntradaManha.Hours).AddMinutes(lctos.EntradaManha.Minutes),
Fim = data.AddHours(lctos.SaidaManha.Hours).AddMinutes(lctos.SaidaManha.Minutes),
ProjectNode = projeto,
TipoAtividade = tipo,
Usuario = usu
}, true);
await app.SalvarAsync(new Atividade
{
Observacao = lctos.Descricao,
Inicio = data.AddHours(lctos.EntradaTarde.Hours).AddMinutes(lctos.EntradaTarde.Minutes),
Fim = data.AddHours(lctos.SaidaTarde.Hours).AddMinutes(lctos.SaidaTarde.Minutes),
ProjectNode = projeto,
TipoAtividade = tipo,
Usuario = usu
}, true);
}
}
}
catch (DbEntityValidationException ex)
{
string exceptionMessage = LogServices.ConcatenaErrosDbEntityValidation(ex);
MensagemParaUsuarioViewModel.MensagemErro(exceptionMessage, TempData, ModelState);
return(RedirectToAction("Index"));
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro(err.Message, TempData, ModelState);
return(RedirectToAction("Index"));
}
finally
{
data = data.AddDays(1);
}
}
MensagemParaUsuarioViewModel.MensagemSucesso("Atividades salvas.", TempData);
}
CarregaTipos();
CarregaProjetos();
CarregaUsuarios();
return(View(lctos));
}
public async Task <JsonResult> CarregaReferencia(int id)
{
var referencia = await db.Referencias.FindAsync(id);
referencia.SincronizaAtividades(new CalendarioServices());
var app = new AtividadeApplication(db);
var atvidx = await app.GetAtividadeIndexAsync(referencia.Id);
var refvm = new
{
Id = referencia.Id,
PrevistoDoMes = referencia.Previsto.BigTimeSpanToString(),
PrevistoCorrente = referencia.PrevistoCorrente.BigTimeSpanToString(),
RealizadoDoMes = referencia.Realizado.BigTimeSpanToString(),
SaldoDoMes = referencia.SaldoDoMes.BigTimeSpanToString(),
Saldo = referencia.Saldo.BigTimeSpanToString(),
BancoDeHoras = referencia.BancoDeHoras.BigTimeSpanToString(),
Ano = referencia.Ano.ToString(),
Mes = referencia.Mes.ToString("D2"),
Atividades = ControleAcesso.TemAcesso(SegurancaResources.EDITAR_ATIVIDADE) ?
atvidx.Atividades.Select(x =>
new string[] {
x.ProjectNodeNome,
x.TipoAtividadeNome,
x.Observacao,
x.Inicio.ToString("dd/MM/yyyy"),
x.Inicio.ToString("HH:mm"),
x.Fim.ToString("HH:mm"),
((TimeSpan)(x.Fim - x.Inicio)).TimeSpanToString(),
x.Inicio.ToString("yyyy-MM-dd"),
x.ReferenciaFechado?"":"<a href='" + Url.Action("Edit", "Home", new { id = x.Id.ToString() }) + "'><span class='glyphicon glyphicon-edit'></span></a>",
x.ReferenciaFechado?"":"<span data-id='" + x.Id.ToString() + "' class='glyphicon glyphicon-remove delete-button' id='spdeletar" + x.Id.ToString() + "'></span>",
}
).ToArray() : atvidx.Atividades.Select(x =>
new string[] {
x.ProjectNodeNome,
x.TipoAtividadeNome,
x.Observacao,
x.Inicio.ToString("dd/MM/yyyy"),
x.Inicio.ToString("HH:mm"),
x.Fim.ToString("HH:mm"),
((TimeSpan)(x.Fim - x.Inicio)).TimeSpanToString(),
x.Inicio.ToString("yyyy-MM-dd")
}
).ToArray(),
ConsolidadoDiario = atvidx.ConsolidadoDiario.Select(x =>
new string[] {
x.Data.ToString("dd/MM/yyyy"),
x.Horas.TimeSpanToString(),
x.ClienteNome,
x.Data.ToString("yyyy-MM-dd")
}
).ToArray()
};
return(Json(refvm));
}
public async Task <ActionResult> CreateAjax([Bind(Include = "Observacao,Data,Inicio,Fim, IdProjectNode, IdTipoAtividade")] AtividadeAjaxViewModel atividadeVm)
{
if (atividadeVm.Data == DateTime.MinValue)
{
MensagemParaUsuarioViewModel.MensagemErro("Favor preencher a data", TempData, ModelState);
}
if ((atividadeVm.Inicio == null) || (atividadeVm.Inicio <= TimeSpan.Zero) || (atividadeVm.Inicio > new TimeSpan(23, 59, 59)))
{
MensagemParaUsuarioViewModel.MensagemErro("Favor preencher uma hora válida para o Início entre 00:00 e 23:59", TempData, ModelState);
}
if ((atividadeVm.Fim == null) || (atividadeVm.Fim <= TimeSpan.Zero) || (atividadeVm.Fim > new TimeSpan(23, 59, 59)))
{
MensagemParaUsuarioViewModel.MensagemErro("Favor preencher uma hora válida para o Fim entre 00:00 e 23:59", TempData, ModelState);
}
if (atividadeVm.Inicio > atividadeVm.Fim)
{
MensagemParaUsuarioViewModel.MensagemErro("A hora de início não pode ser maior que a hora de término", TempData, ModelState);
}
if (ModelState.IsValid)
{
var usuario = db.Usuarios.Where <Usuario>(x => x.Login == User.Identity.Name).FirstOrDefault();
if (usuario != null)
{
try
{
var projeto = await db.ProjectNodes.FindAsync(atividadeVm.IdProjectNode);
var tipo = await db.TiposAtividade.FindAsync(atividadeVm.IdTipoAtividade);
Atividade domainAtv = new Atividade
{
Observacao = atividadeVm.Observacao,
Inicio = atividadeVm.Data.AddHours(atividadeVm.Inicio.Hours).AddMinutes(atividadeVm.Inicio.Minutes),
Fim = atividadeVm.Data.AddHours(atividadeVm.Fim.Hours).AddMinutes(atividadeVm.Fim.Minutes),
ProjectNode = projeto,
TipoAtividade = tipo,
Usuario = usuario
};
Referencia refe = domainAtv.Usuario.GetReferencia(domainAtv.Inicio.Year, domainAtv.Inicio.Month);
if (!refe.Fechado)
{
AtividadeApplication app = new AtividadeApplication(this.db);
await app.SalvarAsync(domainAtv, false);
MensagemParaUsuarioViewModel.MensagemSucesso("Atividade salva.", TempData);
return(PartialView("~/views/shared/DisplayTemplates/AtividadeAjaxViewModel.cshtml", domainAtv));
}
else
{
MensagemParaUsuarioViewModel.MensagemAlerta("Você não pode criar uma atividade para um mês que já foi fechado.", TempData);
}
}
catch (DbEntityValidationException ex)
{
string exceptionMessage = LogServices.ConcatenaErrosDbEntityValidation(ex);
MensagemParaUsuarioViewModel.MensagemErro(exceptionMessage, TempData, ModelState);
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro(err.Message, TempData, ModelState);
}
}
else
{
ModelState.AddModelError("Usuario", "Usuário logado não encontrado!.");
MensagemParaUsuarioViewModel.MensagemErro("Usuário logado não encontrado!.", TempData);
}
}
CarregaTipos();
CarregaProjetos();
return(PartialView("~/views/shared/EditorTemplates/AtividadeAjaxViewModel.cshtml", atividadeVm));
}
