Пример #1
0
        /// <summary>
        /// salva uma atividade, se for correto do ponto de vista do negócio fazer isso
        /// não salva a atividade caso quem esteja editando seja um usuário e o período seja fechado
        /// </summary>
        /// <param name="att">Atividade - atividade a ser salva</param>
        /// <param name="podeSalvarReferenciaFechada">bool - se true, permite salvar atividades em períodos fechados.</param>
        /// <returns></returns>
        public virtual async Task SaveAsync(Atividade att, bool podeSalvarReferenciaFechada = false)
        {
            DateTime   database = new DateTime(att.Inicio.Year, att.Inicio.Month, 1);
            Referencia refe     = att.Usuario.GetReferencia(att.Inicio.Year, att.Inicio.Month);

            if (!refe.Fechado || podeSalvarReferenciaFechada)
            {
                if (att.ProjectNode != null)
                {
                    att.Cliente = att.ProjectNode.GetCliente();
                }

                //todo: colocar verificação de duplicidade por data inicial aqui, pesquisar para não lançar duas vezes

                if (att.Id == 0)
                {
                    _db.Atividades.Add(att);
                }

                await _db.SaveChangesAsync();

                refe.SincronizaAtividades(database, new CalendarioServices());

                await _db.SaveChangesAsync();
            }
        }
Пример #2
0
        /// <summary>
        /// salva um tipo de atividade
        /// </summary>
        /// <param name="ent"></param>
        /// <returns></returns>
        public virtual async Task SaveAsync(TipoAtividade ent)
        {
            if ((ent.Id == 0) || (!await _db.TiposAtividade.AnyAsync(x => x.Id == ent.Id)))
            {
                _db.TiposAtividade.Add(ent);
            }

            await _db.SaveChangesAsync();
        }
Пример #3
0
        /// <summary>
        /// salva um feriado
        /// </summary>
        /// <param name="ent"></param>
        /// <returns></returns>
        public virtual async Task SaveAsync(Feriado ent)
        {
            if ((ent.Id == 0) || (!await _db.Feriados.AnyAsync(x => x.Id == ent.Id)))
            {
                _db.Feriados.Add(ent);
            }

            await _db.SaveChangesAsync();
        }
Пример #4
0
        /// <summary>
        /// salva um node
        /// </summary>
        /// <param name="ent"></param>
        /// <returns></returns>
        public virtual async Task SaveAsync(ProjectNode ent)
        {
            if ((ent.Id == 0) || (!await _db.ProjectNodes.AnyAsync(x => x.Id == ent.Id)))
            {
                _db.ProjectNodes.Add(ent);
            }

            await _db.SaveChangesAsync();
        }
Пример #5
0
        /// <summary>
        /// salva um usuário de forma assíncrona
        /// </summary>
        /// <param name="ent"></param>
        /// <returns></returns>
        public virtual async Task SaveAsync(Usuario ent)
        {
            if ((ent.Id == 0) || (!await _db.Usuarios.AnyAsync(x => x.Id == ent.Id)))
            {
                _db.Usuarios.Add(ent);
            }
            else
            {
                _db.Entry(ent).State = EntityState.Modified;
            }

            await _db.SaveChangesAsync();
        }
Пример #6
0
        /// <summary>
        /// obtém a referência atual do usuário, criando caso ainda não exista e sincronizando as atividades
        /// </summary>
        /// <param name="idUsu">int - id do usuário sendo pesquisado</param>
        /// <returns></returns>
        public virtual async Task <ReferenciaViewModel> GetReferenciaAsync(int idUsu)
        {
            //exemplo de include, para desabilitar o lazy load tirando o virtual
            Usuario usuLogado = await _db.Usuarios
                                .AsNoTracking()
                                .Include(x => x.Atividades)
                                .Include(x => x.Referencias)
                                .Where(x => x.Id == idUsu)
                                .FirstOrDefaultAsync();

            //.FindAsync(idUsu);

            if (usuLogado != null)
            {
                var referencia = usuLogado.GetReferencia();
                referencia.SincronizaAtividades(new CalendarioServices());
                await _db.SaveChangesAsync();

                ReferenciaViewModel rvm = new ReferenciaViewModel
                {
                    Id               = referencia.Id,
                    PrevistoDoMes    = referencia.Previsto,
                    PrevistoCorrente = referencia.PrevistoCorrente,
                    RealizadoDoMes   = referencia.Realizado,

                    SaldoDoMes = referencia.SaldoDoMes,
                    Saldo      = referencia.Saldo,

                    BancoDeHoras = referencia.BancoDeHoras,

                    Ano = referencia.Ano,
                    Mes = referencia.Mes
                };

                return(rvm);
            }

            return(new ReferenciaViewModel());
        }
Пример #7
0
        /// <summary>
        /// Remove de um node todos os usuários que não estão na lista passada no segundo parâmetro
        /// </summary>
        /// <param name="idNode">int - id do Node</param>
        /// <param name="idsUsuarios">int[] - array com os usuários que deveriam ficar</param>
        /// <returns></returns>
        public virtual async Task RemoverUsuariosForaDaLista(int idNode, List <int> idsUsuarios, bool recursivo = false)
        {
            if (idNode == 0)
            {
                throw new UsuarioApplicationException("Id do Node não informado.");
            }

            ProjectNode node = await _db.ProjectNodes.FindAsync(idNode);

            if (node == null)
            {
                throw new UsuarioApplicationException("Node não encontrado.");
            }

            List <Usuario> removidos = new List <Usuario>();

            if (idsUsuarios == null || idsUsuarios.Count == 0)
            {
                removidos.AddRange(node.UsuariosDesteNode);
            }
            else
            {
                removidos = node.UsuariosDesteNode.Where(x => !idsUsuarios.Contains(x.Id)).ToList();
            }

            removidos.ForEach(u =>
            {
                if (recursivo)
                {
                    RemoveNodesRecursivamente(u, node);
                }
                else
                {
                    node.UsuariosDesteNode.Remove(u);
                }
            });

            await _db.SaveChangesAsync();
        }