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);
}
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;
}
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);
}