Пример #1
0
        public void Save(int?idAtividade, int idProjeto, int?idAtividadePredecessora, string tituloAtividade, Decimal tempoEstimado, int porcentagemCompleta, DateTime dtInicio, DateTime dtTermino, string descricao, int idUsuario, Katapoka.DAO.Tag.TagCompleta[] tags)
        {
            Katapoka.DAO.Atividade_Tb atividadeTb = null;
            if (idAtividade == null)
            {
                atividadeTb = new DAO.Atividade_Tb();
                atividadeTb.IdUsuarioCriacao = idUsuario;
                atividadeTb.DtCriacao        = DateTime.Now;
            }
            else
            {
                atividadeTb = GetById(idAtividade.Value);
            }
            if (atividadeTb == null)
            {
                throw new Exception("Atividade não pode ser criada.");
            }
            atividadeTb.IdProjeto = idProjeto;
            atividadeTb.IdAtividadePredecessora = idAtividadePredecessora;
            atividadeTb.DsTituloAtividade       = tituloAtividade;
            atividadeTb.QtTempoEstimado         = tempoEstimado;
            atividadeTb.VrCompletoPorcentagem   = porcentagemCompleta;
            atividadeTb.DtInicio    = dtInicio;
            atividadeTb.DtTermino   = dtTermino;
            atividadeTb.DsAtividade = descricao;
            Save(atividadeTb);

            //Verifico quais tags eu possuo associadas para associar (apenas ID's positivas)
            List <Katapoka.DAO.Tag.TagCompleta> tagsReais = tags.Where(p => p.IdTag > 0).ToList();
            List <Katapoka.DAO.Tag.TagCompleta> tagsNovas = tags.Where(p => p.IdTag < 0).ToList();

            BLL.Tag.TagBLL          tagBLL    = CriarObjetoNoMesmoContexto <Tag.TagBLL>();
            BLL.Tag.AtividadeTagBLL atiTagBLL = CriarObjetoNoMesmoContexto <Tag.AtividadeTagBLL>();

            //Removo as que não foram postadas
            int[] idsPostadas = tags.Where(p => p.IdTag != null).Select(p => p.IdTag.Value).ToArray();
            foreach (Katapoka.DAO.AtividadeTag_Tb ati in atividadeTb.AtividadeTag_Tb
                     .Where(p => !idsPostadas.Contains(p.IdTag))
                     .ToList())
            {
                atiTagBLL.Delete(ati);
            }

            //Cadastro as novas tags e associo à atividade
            foreach (Katapoka.DAO.Tag.TagCompleta tag in tagsNovas)
            {
                Katapoka.DAO.Tag_Tb newTag = new DAO.Tag_Tb()
                {
                    DsTag = tag.DsTag
                };
                tagBLL.Save(newTag);

                Katapoka.DAO.AtividadeTag_Tb atiTag = new DAO.AtividadeTag_Tb()
                {
                    IdTag = newTag.IdTag, IdAtividade = atividadeTb.IdAtividade
                };
                atiTagBLL.Save(atiTag);
            }

            //Adiciono as novas tags
            foreach (int idTag in tagsReais.Select(p => p.IdTag).ToList()
                     .Where(p => !atividadeTb.AtividadeTag_Tb.Select(p2 => p2.IdTag).ToList().Contains(p.Value)))
            {
                Katapoka.DAO.AtividadeTag_Tb atiTag = new DAO.AtividadeTag_Tb()
                {
                    IdTag = idTag, IdAtividade = atividadeTb.IdAtividade
                };
                atiTagBLL.Save(atiTag);
            }

            Save(atividadeTb);
        }
Пример #2
0
        public IList<Katapoka.DAO.Atividade.AtividadeAjaxPost> SalvarAtividades(int idProjeto, List<Katapoka.DAO.Atividade.AtividadeAjaxPost> atividades, int idUsuarioAlteracao)
        {
            Katapoka.DAO.Projeto_Tb projetoTb = GetById(idProjeto);

            Dictionary<int, Katapoka.DAO.Tag_Tb> tagsUtilizadas = new Dictionary<int, DAO.Tag_Tb>();
            Dictionary<int, Katapoka.DAO.Atividade_Tb> atividadesRelacionadas = new Dictionary<int, DAO.Atividade_Tb>();
            Dictionary<int, Katapoka.DAO.Usuario_Tb> usuariosUtilizados = new Dictionary<int, DAO.Usuario_Tb>();

            Katapoka.BLL.Atividade.AtividadeBLL atividadeBLL = CriarObjetoNoMesmoContexto<Katapoka.BLL.Atividade.AtividadeBLL>();
            Katapoka.BLL.Tag.TagBLL tagBLL = CriarObjetoNoMesmoContexto<Katapoka.BLL.Tag.TagBLL>();
            Katapoka.BLL.Tag.AtividadeTagBLL atividadeTagBLL = CriarObjetoNoMesmoContexto<Katapoka.BLL.Tag.AtividadeTagBLL>();
            Katapoka.BLL.Usuario.UsuarioBLL usuarioBLL = CriarObjetoNoMesmoContexto<Usuario.UsuarioBLL>();
            Katapoka.BLL.Atividade.AtividadeUsuarioBLL atividadeUsuarioBLL = CriarObjetoNoMesmoContexto<Atividade.AtividadeUsuarioBLL>();
            foreach (Katapoka.DAO.Atividade.AtividadeAjaxPost atividade in atividades)
            {
                #region Adiciona as atividades na "tabela de relacionamento de atividades"
                Katapoka.DAO.Atividade_Tb atividadeTb = null;
                if (atividade.IdAtividade == null)
                {
                    atividadeTb = new DAO.Atividade_Tb();
                    atividadeTb.DtCriacao = DateTime.Now;
                    atividadeTb.IdUsuarioCriacao = idUsuarioAlteracao;
                    atividadeTb.FlStatus = "A"; //Recém criada, recebe status de ativa!
                    projetoTb.Atividade_Tb.Add(atividadeTb);
                    atividadeTb.Projeto_Tb = projetoTb;
                }
                else
                {
                    atividadeTb = atividadeBLL.GetById(atividade.IdAtividade.Value);
                }
                atividadesRelacionadas.Add(atividade.IdAtividadeLocal, atividadeTb);
                #endregion
                #region Adiciona as tags na "tabela de relacionamento"
                if (atividade.Tags.Count > 0)
                {
                    foreach (Katapoka.DAO.Tag.TagCompleta tag in atividade.Tags)
                    {
                        Katapoka.DAO.Tag_Tb tagTb = null;
                        if (!tagsUtilizadas.ContainsKey(tag.IdTag.Value))
                        {
                            if (tag.IdTag.Value < 1)
                            {
                                tagTb = new DAO.Tag_Tb();
                                tagTb.DsTag = tag.DsTag;
                                Katapoka.DAO.AtividadeTag_Tb atividadeTagTb = new DAO.AtividadeTag_Tb();
                                atividadeTagTb.Tag_Tb = tagTb;
                                atividadeTagTb.Atividade_Tb = atividadeTb;
                                atividadeTb.AtividadeTag_Tb.Add(atividadeTagTb);
                                tagTb.AtividadeTag_Tb.Add(atividadeTagTb);
                            }
                            else
                            {
                                tagTb = tagBLL.GetById(tag.IdTag.Value);
                            }
                            tagsUtilizadas.Add(tag.IdTag.Value, tagTb);
                        }

                    }
                }
                #endregion
                #region Adiciona os usuários utilizados
                foreach (Katapoka.DAO.UsuarioCompleto usuarioCompleto in atividade.Usuarios)
                {
                    if (!usuariosUtilizados.ContainsKey(usuarioCompleto.IdUsuario))
                    {
                        usuariosUtilizados.Add(usuarioCompleto.IdUsuario, usuarioBLL.GetById(usuarioCompleto.IdUsuario));
                    }
                }
                #endregion
            }

            //Processamento geral
            foreach (Katapoka.DAO.Atividade.AtividadeAjaxPost atividade in atividades)
            {
                //Preencho os dados
                if(!string.IsNullOrWhiteSpace(atividade.DsNomeAtividade))
                    atividadesRelacionadas[atividade.IdAtividadeLocal].DsTituloAtividade = atividade.DsNomeAtividade;
                else
                    atividadesRelacionadas[atividade.IdAtividadeLocal].DsTituloAtividade = "Atividade sem título";
                atividadesRelacionadas[atividade.IdAtividadeLocal].DsAtividade = atividade.DsAtividade;
                atividadesRelacionadas[atividade.IdAtividadeLocal].DtInicio = !string.IsNullOrWhiteSpace(atividade.DtInicioStr) ? Convert.ToDateTime(atividade.DtInicioStr) : (DateTime?)null;
                atividadesRelacionadas[atividade.IdAtividadeLocal].DtTermino = !string.IsNullOrWhiteSpace(atividade.DtTerminoStr) ? Convert.ToDateTime(atividade.DtTerminoStr) : (DateTime?)null;
                atividadesRelacionadas[atividade.IdAtividadeLocal].QtTempoEstimado = !string.IsNullOrWhiteSpace(atividade.QtTempoEstimado) ? Katapoka.BLL.Utilitarios.Utilitario.ConvertTimeStringToDecimal(atividade.QtTempoEstimado) : (decimal?)null;
                atividadesRelacionadas[atividade.IdAtividadeLocal].VrCompletoPorcentagem = atividade.VrCompletoPorcentagem;
                //Tempo executado não está aqui pois não pode editado manualmente

                #region Relaciono as atividades com Pre e pos
                if (atividade.IdAtividadePredecessora != null)
                {
                    Katapoka.DAO.Atividade_Tb atividadePre, atividadeTb;
                    atividadeTb = atividadesRelacionadas[atividade.IdAtividadeLocal];
                    atividadePre = atividadesRelacionadas[atividade.IdAtividadePredecessora.Value];
                    atividadeTb.AtividadePredecessora_Tb = atividadePre;
                    atividadePre.AtividadesSucessoras_Tb.Add(atividadeTb);
                }
                else
                {
                    Katapoka.DAO.Atividade_Tb atividadeTb;
                    atividadeTb = atividadesRelacionadas[atividade.IdAtividadeLocal].AtividadePredecessora_Tb = null;
                }
                #endregion

                //Removo as tags que não fazem mais parte da atividade DAS ATIVIDADES PARA EDIÇÃO (IdAtividade != null)
                if (atividade.IdAtividade != null)
                {
                    int[] idsTagsAtividade = atividade.Tags.Where(p => p.IdTag != null && p.IdTag.Value > 0)
                        .Select(p => p.IdTag.Value)
                        .ToArray();
                    IList<Katapoka.DAO.AtividadeTag_Tb> tagsARemover =
                        this.Context.AtividadeTag_Tb
                            .Where(p => p.IdAtividade == atividade.IdAtividade.Value && !idsTagsAtividade.Contains(p.IdTag))
                            .ToList();
                    atividadeTagBLL.DeleteRange(tagsARemover);
                }

                //Gerenciamento dos usuários da atividade
                //Se a atividade é nova, adiciona todos os usuários, caso contrário, valida quem entra, quem fica e quem saí.
                if (atividade.IdAtividade == null)
                {
                    //Adiciona usuários
                    foreach (Katapoka.DAO.UsuarioCompleto usuarioCompleto in atividade.Usuarios)
                    {
                        Katapoka.DAO.AtividadeUsuario_Tb atividadeUsuarioTb = new DAO.AtividadeUsuario_Tb();
                        atividadeUsuarioTb.DtCriacao = DateTime.Now;
                        atividadeUsuarioTb.IdUsuarioCriacao = idUsuarioAlteracao;
                        atividadeUsuarioTb.Atividade_Tb = atividadesRelacionadas[atividade.IdAtividadeLocal];
                        atividadeUsuarioTb.Usuario_Tb = usuariosUtilizados[usuarioCompleto.IdUsuario];
                        usuariosUtilizados[usuarioCompleto.IdUsuario].AtividadeUsuario_Tb.Add(atividadeUsuarioTb);
                        atividadesRelacionadas[atividade.IdAtividadeLocal].AtividadeUsuario_Tb.Add(atividadeUsuarioTb);
                    }

                    //Adiciona tags
                    foreach (Katapoka.DAO.Tag.TagCompleta tag in atividade.Tags)
                    {
                        Katapoka.DAO.AtividadeTag_Tb atividadeTag = new DAO.AtividadeTag_Tb();
                        Katapoka.DAO.Atividade_Tb atividadeTb = atividadesRelacionadas[atividade.IdAtividadeLocal];
                        Katapoka.DAO.Tag_Tb tagTb = tagsUtilizadas[tag.IdTag.Value];

                        atividadeTag.Tag_Tb = tagTb;
                        atividadeTag.Atividade_Tb = atividadeTb;
                        tagTb.AtividadeTag_Tb.Add(atividadeTag);
                        atividadeTb.AtividadeTag_Tb.Add(atividadeTag);
                    }
                }
                else
                {
                    #region Trata usuários
                    int[] idsEnviadas = atividade.Usuarios.Select(p => p.IdUsuario).ToArray();
                    int[] idsUsuariosJaAssociados = atividadesRelacionadas[atividade.IdAtividadeLocal].AtividadeUsuario_Tb
                        .Select(p => p.IdUsuario).ToArray();
                    //Insere novos
                    foreach (int idUsuarioInserir in idsEnviadas.Where(p => !idsUsuariosJaAssociados.Contains(p)).ToArray())
                    {
                        Katapoka.DAO.Usuario_Tb usuarioTb = usuariosUtilizados[idUsuarioInserir];
                        Katapoka.DAO.Atividade_Tb atividadeTb = atividadesRelacionadas[atividade.IdAtividadeLocal];
                        Katapoka.DAO.AtividadeUsuario_Tb atividadeUsuarioTb = new DAO.AtividadeUsuario_Tb();
                        atividadeUsuarioTb.DtCriacao = DateTime.Now;
                        atividadeUsuarioTb.IdUsuarioCriacao = idUsuarioAlteracao;
                        atividadeUsuarioTb.Usuario_Tb = usuarioTb;
                        atividadeUsuarioTb.Atividade_Tb = atividadeTb;
                        atividadeTb.AtividadeUsuario_Tb.Add(atividadeUsuarioTb);
                        usuarioTb.AtividadeUsuario_Tb.Add(atividadeUsuarioTb);
                    }

                    //Remove não associados
                    IList<Katapoka.DAO.AtividadeUsuario_Tb> usuariosRemover = this.Context.AtividadeUsuario_Tb
                        .Where(p => p.IdAtividade == atividade.IdAtividade.Value && !idsEnviadas.Contains(p.IdUsuario))
                        .ToList();
                    atividadeUsuarioBLL.DeleteRange(usuariosRemover);
                    #endregion
                    #region Trata tags
                    int[] idsTagsEnviadas = atividade.Tags.Where(p => p.IdTag != null && p.IdTag.Value > 0)
                        .Select(p => p.IdTag.Value)
                        .ToArray();
                    int[] idsTagsEmUso = atividadesRelacionadas[atividade.IdAtividadeLocal].AtividadeTag_Tb
                        .Select(p => p.IdTag).ToArray();
                    //Insere as novas
                    foreach (int idTagInserir in idsTagsEnviadas.Where(p => !idsTagsEmUso.Contains(p)).ToArray())
                    {
                        Katapoka.DAO.AtividadeTag_Tb atividadeTagTb = new DAO.AtividadeTag_Tb();
                        atividadeTagTb.Tag_Tb = tagsUtilizadas[idTagInserir];
                        atividadeTagTb.Atividade_Tb = atividadesRelacionadas[atividade.IdAtividadeLocal];
                        atividadesRelacionadas[atividade.IdAtividadeLocal].AtividadeTag_Tb.Add(atividadeTagTb);
                        tagsUtilizadas[idTagInserir].AtividadeTag_Tb.Add(atividadeTagTb);
                    }

                    //Deleta as que não existe mais
                    IList<Katapoka.DAO.AtividadeTag_Tb> atividadesARemover = this.Context.AtividadeTag_Tb
                        .Where(p => p.IdAtividade == atividade.IdAtividade.Value && !idsTagsEnviadas.Contains(p.IdTag))
                        .ToList();
                    atividadeTagBLL.DeleteRange(atividadesARemover);

                    //Katapoka.DAO.AtividadeTag_Tb atividadeTagTb = new DAO.AtividadeTag_Tb();
                    //atividadeTagTb.Tag_Tb = tagTb;
                    //atividadeTagTb.Atividade_Tb = atividadeTb;
                    //atividadeTb.AtividadeTag_Tb.Add(atividadeTagTb);
                    //tagTb.AtividadeTag_Tb.Add(atividadeTagTb);
                    #endregion
                }

            }


            //Removo as atividades que não mais fazem parte do projeto
            int[] idsAtividadesProjeto = atividades.Where(p => p.IdAtividade != null)
                .Select(p => p.IdAtividade.Value).ToArray(); //Ids que AINDA FAZEM PARTE do projeto
            IList<Katapoka.DAO.Atividade_Tb> atividadesRemover =
                this.Context.Atividade_Tb.Where(p => p.IdProjeto == idProjeto && !idsAtividadesProjeto.Contains(p.IdAtividade))
                .ToList();
            //atividadeBLL.DeleteRange(atividadesRemover);
            foreach (Katapoka.DAO.Atividade_Tb atividadeRemover in atividadesRemover)
            {
                atividadeRemover.FlStatus = "L";
                atividadeRemover.IdAtividadePredecessora = null; //Se a atividade foi removida eu removo o vínculo dela com qualquer outra para evitar que de problemas futuros de integridade
                //atividadeRemover.AtividadePredecessora_Tb = null;
            }

            //Reza pra não dar pau e tenta salvar tudo
            Save(projetoTb);

            //Atualiza as IDS de atividade e atualiza as IDS de tags e retorna
            for (int i = 0; i < atividades.Count; i++)
            {
                Katapoka.DAO.Atividade_Tb atividadeTb = atividadesRelacionadas[atividades[i].IdAtividadeLocal];
                atividades[i].IdAtividade = atividadeTb.IdAtividade;
                atividades[i].DsNomeAtividade = atividadeTb.DsTituloAtividade;
                TimeSpan tempoExecutado = TimeSpan.FromHours((double)atividadeTb.QtTempoExecutado);
                atividades[i].QtTempoExecutado = string.Format("{0:000}:{1:00}", Math.Floor(tempoExecutado.TotalHours), tempoExecutado.Minutes);

                //Re-gero as tags utilizadas
                //atividades[i].Tags = atividadeTb.AtividadeTag_Tb
                //    .Select(p => new Katapoka.DAO.Tag.TagCompleta()
                //    {
                //        DsTag = p.Tag_Tb.DsTag,
                //        IdTag = p.IdTag
                //    }).ToList();
                //
                ////Re-gero os usuários
                //atividades[i].Usuarios = atividadeTb.AtividadeUsuario_Tb.Select(p => new Katapoka.DAO.UsuarioCompleto()
                //{
                //    DsNome = p.Usuario_Tb.DsNome,
                //    IdUsuario = p.IdUsuario
                //}).ToList();
            }
            return atividades;
        }
Пример #3
0
        public IList <Katapoka.DAO.Atividade.AtividadeAjaxPost> InserirTipoAtividades(int idTipoProjeto, List <Katapoka.DAO.Atividade.AtividadeAjaxPost> atividades)
        {
            Dictionary <int, Katapoka.DAO.TipoAtividade_Tb> atividadesRelacionadas = new Dictionary <int, Katapoka.DAO.TipoAtividade_Tb>();
            Dictionary <int, Katapoka.DAO.Tag_Tb>           tagsUtilizadas         = new Dictionary <int, DAO.Tag_Tb>();

            Atividade.TipoAtividadeBLL tipoAtividadeBLL = CriarObjetoNoMesmoContexto <Atividade.TipoAtividadeBLL>();
            Tag.TagBLL tagBLL = CriarObjetoNoMesmoContexto <Tag.TagBLL>();
            TipoProjetoTipoAtividadeBLL tipoProjetoTipoAtividadeBLL = CriarObjetoNoMesmoContexto <TipoProjetoTipoAtividadeBLL>();

            Tag.TipoAtividadeTagBLL tipoAtividadeTagBLL = CriarObjetoNoMesmoContexto <Tag.TipoAtividadeTagBLL>();

            Katapoka.DAO.TipoProjeto_Tb tipoProjetoTb = GetById(idTipoProjeto);

            foreach (Katapoka.DAO.Atividade.AtividadeAjaxPost atividade in atividades)
            {
                Katapoka.DAO.TipoAtividade_Tb tipoAtividadeTb            = null;
                TipoProjetoTipoAtividade_Tb   tipoProjetoTipoAtividadeTb = null;

                //Inclui os TipoAtividade
                if (atividade.IdAtividade != null)
                {
                    tipoAtividadeTb            = tipoAtividadeBLL.GetById(atividade.IdAtividade.Value);
                    tipoProjetoTipoAtividadeTb = tipoProjetoTipoAtividadeBLL.GetTipoProjetoTipoAtividade(idTipoProjeto, atividade.IdAtividade.Value);
                    if (tipoProjetoTipoAtividadeTb == null)
                    {
                        tipoProjetoTipoAtividadeTb = new TipoProjetoTipoAtividade_Tb();

                        //Vincula
                        tipoProjetoTipoAtividadeTb.TipoAtividade_Tb = tipoAtividadeTb;
                        tipoAtividadeTb.TipoProjetoTipoAtividade_Tb.Add(tipoProjetoTipoAtividadeTb);

                        tipoProjetoTipoAtividadeTb.TipoProjeto_Tb = tipoProjetoTb;
                        tipoProjetoTb.TipoProjetoTipoAtividade_Tb.Add(tipoProjetoTipoAtividadeTb);
                    }
                }
                else
                {
                    tipoAtividadeTb            = new TipoAtividade_Tb();
                    tipoProjetoTipoAtividadeTb = new TipoProjetoTipoAtividade_Tb();

                    //Vincula
                    tipoProjetoTipoAtividadeTb.TipoAtividade_Tb = tipoAtividadeTb;
                    tipoAtividadeTb.TipoProjetoTipoAtividade_Tb.Add(tipoProjetoTipoAtividadeTb);

                    tipoProjetoTipoAtividadeTb.TipoProjeto_Tb = tipoProjetoTb;
                    tipoProjetoTb.TipoProjetoTipoAtividade_Tb.Add(tipoProjetoTipoAtividadeTb);
                }

                tipoAtividadeTb.DsAtividade       = atividade.DsAtividade;
                tipoAtividadeTb.DsTituloAtividade = atividade.DsNomeAtividade;
                tipoAtividadeTb.QtTempoEstimado   = Utilitarios.Utilitario.ConvertTimeStringToDecimal(atividade.QtTempoEstimado);
                atividadesRelacionadas[atividade.IdAtividadeLocal] = tipoAtividadeTb;

                //Inclui as tags
                foreach (Katapoka.DAO.Tag.TagCompleta tagCompleta in atividade.Tags)
                {
                    Katapoka.DAO.Tag_Tb tagTb = null;
                    if (!tagsUtilizadas.ContainsKey(tagCompleta.IdTag.Value))
                    {
                        if (tagCompleta.IdTag < 1)
                        {
                            tagTb = new Tag_Tb();
                        }
                        else
                        {
                            tagTb = tagBLL.GetById(tagCompleta.IdTag.Value);
                        }
                        tagTb.DsTag = tagCompleta.DsTag;
                        tagsUtilizadas[tagCompleta.IdTag.Value] = tagTb;
                    }
                }
            }

            //Configura as pre atividades
            foreach (Katapoka.DAO.Atividade.AtividadeAjaxPost atividade in atividades)
            {
                DAO.TipoAtividade_Tb tipoAtividadeTb = atividadesRelacionadas[atividade.IdAtividadeLocal];

                #region VINCULA AS PRE_ATIVIDADES
                DAO.TipoProjetoTipoAtividadePredecessora_Tb configPredecessora = null;
                //Se é um novo registro, ele ainda não tem sua configuração de predecessora
                if (atividade.IdAtividade == null)
                {
                    configPredecessora = CriaConfigTipoAtividadePredecessora(tipoProjetoTb, tipoAtividadeTb);
                }
                else
                {
                    configPredecessora = tipoAtividadeBLL.GetTipoProjetoTipoAtividadePredecessora(idTipoProjeto, atividade.IdAtividade.Value);
                    if (configPredecessora == null)
                    {
                        configPredecessora = CriaConfigTipoAtividadePredecessora(tipoProjetoTb, tipoAtividadeTb);
                    }
                }

                //Configura a pre
                if (atividade.IdAtividadePredecessora == null)
                {
                    configPredecessora.TipoAtividadePredecessora_Tb = null;
                }
                else
                {
                    TipoAtividade_Tb tipoAtividadePre = atividadesRelacionadas[atividade.IdAtividadePredecessora.Value];
                    configPredecessora.TipoAtividadePredecessora_Tb = tipoAtividadePre;
                }

                #endregion

                #region PROCESSA AS TAGS
                if (atividade.IdAtividade == null)
                {
                    //Adiciona as novas tags
                    foreach (DAO.Tag.TagCompleta tagCompleta in atividade.Tags.Where(p => p.IdTag < 1))
                    {
                        DAO.TipoAtividadeTag_Tb tipoAtividadeTag = new TipoAtividadeTag_Tb();
                        DAO.Tag_Tb tagTb = tagsUtilizadas[tagCompleta.IdTag.Value];

                        //Vincula tag com a atividade
                        tipoAtividadeTb.TipoAtividadeTag_Tb.Add(tipoAtividadeTag);
                        tipoAtividadeTag.TipoAtividade_Tb = tipoAtividadeTb;

                        tagTb.TipoAtividadeTag_Tb.Add(tipoAtividadeTag);
                        tipoAtividadeTag.Tag_Tb = tagTb;
                    }
                }
                else
                {
                    int[] idsTagsEnviadas = atividade.Tags.Where(p => p.IdTag != null)
                                            .Select(p => p.IdTag.Value)
                                            .ToArray();

                    int[] idsTagsEmUso = atividadesRelacionadas[atividade.IdAtividadeLocal].TipoAtividadeTag_Tb
                                         .Select(p => p.IdTag).ToArray();

                    //Insere as novas
                    foreach (int idTagInserir in idsTagsEnviadas.Where(p => !idsTagsEmUso.Contains(p)).ToArray())
                    {
                        Katapoka.DAO.TipoAtividadeTag_Tb tipoAtividadeTagTb = new DAO.TipoAtividadeTag_Tb();
                        tipoAtividadeTagTb.Tag_Tb           = tagsUtilizadas[idTagInserir];
                        tipoAtividadeTagTb.TipoAtividade_Tb = atividadesRelacionadas[atividade.IdAtividadeLocal];
                        atividadesRelacionadas[atividade.IdAtividadeLocal].TipoAtividadeTag_Tb.Add(tipoAtividadeTagTb);
                        tagsUtilizadas[idTagInserir].TipoAtividadeTag_Tb.Add(tipoAtividadeTagTb);
                    }

                    //Deleta as que não existe mais
                    IList <Katapoka.DAO.TipoAtividadeTag_Tb> atividadesARemover = this.Context.TipoAtividadeTag_Tb
                                                                                  .Where(p => p.IdTipoAtividade == atividade.IdAtividade.Value && !idsTagsEnviadas.Contains(p.IdTag))
                                                                                  .ToList();
                    tipoAtividadeTagBLL.DeleteRange(atividadesARemover);
                }
                #endregion
            }

            //Removo as atividades que não mais fazem parte do tipo de projeto
            int[] idsAtividadesProjeto = atividades.Where(p => p.IdAtividade != null)
                                         .Select(p => p.IdAtividade.Value).ToArray(); //Ids que AINDA FAZEM PARTE do tipo projeto
            IList <Katapoka.DAO.TipoProjetoTipoAtividade_Tb> atividadesRemover =
                this.Context.TipoProjetoTipoAtividade_Tb.Where(p => p.IdTipoProjeto == idTipoProjeto && !idsAtividadesProjeto.Contains(p.IdTipoAtividade))
                .ToList();
            tipoProjetoTipoAtividadeBLL.DeleteRange(atividadesRemover);
            Save(tipoProjetoTb);

            //Reprocessa a lista atualizando as ids tags tags
            foreach (Katapoka.DAO.Atividade.AtividadeAjaxPost atividade in atividades)
            {
                atividade.IdAtividade = atividadesRelacionadas[atividade.IdAtividadeLocal].IdTipoAtividade;
                foreach (Katapoka.DAO.Tag.TagCompleta tagCompleta in atividade.Tags)
                {
                    int oldTagId = tagCompleta.IdTag.Value;
                    tagCompleta.IdTag = tagsUtilizadas[oldTagId].IdTag;
                }
            }

            return(atividades);
        }