public ColaboradorDto ConsultarColaboradorPorGuid(Guid IdColaborador)
{
WexDb db = ContextFactoryManager.CriarWexDb();
Colaborador colaborador = ColaboradorDAO.Instancia.ConsultarColaboradorPorGuid(db, IdColaborador);
return(ParseDto(colaborador));
}
public static Projeto CriarProjetoRitmo(WexDb contexto, int nbTamanhoTotal = 0, String txNome = "", int totalCiclos = 1, int ritmo = 1)
{
Projeto projeto = new Projeto()
{
TxNome = txNome,
EmpresaInstituicao = EmpresaInstituiçãoFactoryEntity.Criar(contexto).Oid,
NbTamanhoTotal = nbTamanhoTotal,
NbRitmoTime = ritmo,
NbCicloTotalPlan = totalCiclos
};
ProjetoUltimoFiltro projUltimoFiltro = new ProjetoUltimoFiltro()
{
Projeto = projeto.Oid
};
contexto.Projetos.Add(projeto);
contexto.ProjetoUltimoFiltroes.Add(projUltimoFiltro);
for (int i = 0; i < projeto.NbCicloTotalPlan; i++)
{
CicloFactoryEntity.Criar(contexto, projeto, i.ToString());
}
return(projeto);
}
/// <summary>
/// Consulta os dados de um projeto por Id
/// </summary>
/// <param name="IdProjeto">Id do projeto</param>
/// <returns>Projeto DTO</returns>
public DadosBasicoProjetoDto DadosProjeto(Guid IdProjeto)
{
WexDb db = ContextFactoryManager.CriarWexDb();
Projeto projeto = ProjetoDao.Instancia.ConsultarProjetoPorGuid(db, IdProjeto);
return(CriarProjetoDto(projeto));
}
/// <summary>
/// Método responsável por escolher e retornar uma cor para um colaborador em um determinado cronograma
/// </summary>
/// <param name="contexto">Contexto do Banco</param>
/// <param name="oidColaborador">Oid identificação do colaborador</param>
/// <param name="oidCronograma">Oid identificação do cronograma</param>
/// <returns>Caso existam o colaborador e o cronograma retornará um string contendo a cor selecionada para o usuário naquele cronograma</returns>
public static string EscolherCorColaborador(string login, Guid oidCronograma)
{
using (WexDb contexto = ContextFactoryManager.CriarWexDb())
{
string cor = null;
CronogramaColaboradorConfig config = CronogramaColaboradorConfigDao.ConsultarCronogramaColaboradorConfig(contexto, login, oidCronograma);
if (config == null)
{
config = CronogramaColaboradorConfigDao.SalvarCronogramaColaboradorConfig(contexto, login, oidCronograma);
if (config == null)
{
return(null);
}
}
else
{
if (config.Cor != null)
{
return(Convert.ToString(config.Cor));
}
}
List <string> coresArmazenadas = CronogramaColaboradorConfigDao.ConsultarCoresPorCronograma(contexto, oidCronograma);
cor = ColaboradorConfigBo.SelecionarCor(coresArmazenadas);
config.Cor = Convert.ToInt32(cor);
contexto.SaveChanges();
return(cor);
}
}
/// <summary>
/// </summary>
/// <param name="notaFiscalId"></param>
/// <returns></returns>
public static NotaFiscal ConsultarNotaFiscal(int notaFiscalId)
{
using (WexDb contexto = ContextFactoryManager.CriarWexDb())
{
return(contexto.NotaFiscal.Find(notaFiscalId));
}
}
/// <summary>
/// Selecionar um colaborador pelo oid
/// </summary>
/// <param name="oidColaborador"></param>
/// <returns></returns>
public static Colaborador ConsultarColaborador(Guid oidColaborador, params Expression <Func <Colaborador, object> >[] includes)
{
using (WexDb contexto = ContextFactoryManager.CriarWexDb())
{
return(contexto.Colaboradores.MultiploInclude(includes).FirstOrDefault(o => o.Oid == oidColaborador));
}
}
public Dictionary <TipoRubricaDto, List <CustoRubricaDto> > GetCustosRubricas(Guid projetoOid)
{
Dictionary <TipoRubricaDto, List <CustoRubricaDto> > custosRubricas;
using (var _db = new WexDb())
{
custosRubricas = (from rm in _db.RubricaMeses
where rm.Rubrica.Aditivo.ProjetoOid == projetoOid
group new CustoRubricaDto
{
Ano = rm.NbAno,
Mes = rm.CsMes,
TipoRubrica = rm.Rubrica.TipoRubricaId,
Planejado = rm.NbPlanejado,
Replanejado = rm.NbReplanejado,
Gasto = rm.NbGasto
} by new
{
Nome = rm.Rubrica.TipoRubrica.TxNome,
Classe = rm.Rubrica.TipoRubrica.CsClasse
})
.ToDictionary(cr => new TipoRubricaDto()
{
Nome = cr.Key.Nome, Classe = cr.Key.Classe
}, cr => cr.ToList());
}
return(custosRubricas);
}
/// <summary>
/// Método responsável por carregar o total de horas planejadas para o cronograma por oid
/// </summary>
/// <param name="oidCronograma">oid de identificação do cronograma selecionado</param>
/// <returns>retorna o total de horas planejadas </returns>
public static double ConsultarTotalHorasPlanejadasCronograma(Guid oidCronograma)
{
using (WexDb contexto = ContextFactoryManager.CriarWexDb())
{
var cronograma = CronogramaDao.ConsultarCronogramaPorOid(contexto, oidCronograma);
if (cronograma == null)
{
return(0);
}
return((from cronogramaTarefa in contexto.CronogramaTarefa
join historicoEstimativa in contexto.TarefaHistoricoEstimativa
on cronogramaTarefa.OidTarefa equals historicoEstimativa.OidTarefa
where cronogramaTarefa.OidCronograma == oidCronograma &&
historicoEstimativa.DtPlanejado.Year <= cronograma.DtInicio.Year &&
((historicoEstimativa.DtPlanejado.Month < cronograma.DtInicio.Month) || (historicoEstimativa.DtPlanejado.Month <= cronograma.DtInicio.Month && historicoEstimativa.DtPlanejado.Day <= cronograma.DtInicio.Day)) &&
!cronogramaTarefa.CsExcluido && !cronogramaTarefa.Tarefa.CsExcluido
orderby historicoEstimativa.DtPlanejado descending
select historicoEstimativa)
.ToList()
.GroupBy(historicoEstimativa => historicoEstimativa.OidTarefa)
.Select(historicoEstimativa => historicoEstimativa.FirstOrDefault())
.Sum(historicoEstimativa => (double?)historicoEstimativa.NbHoraRestante) ?? 0);
}
}
/// <summary>
/// Método responsável por carregar o total de horas realizadas até a data estipulada
/// </summary>
/// <param name="oidCronograma">oid de identificação do cronograma selecionado</param>
/// <returns>retorna o total de horas planejadas </returns>
public static Dictionary <DateTime, double> ConsultarTotalHorasRealizadasCronograma(Guid oidCronograma, DateTime dataInicio, DateTime dataFinal)
{
using (WexDb contexto = ContextFactoryManager.CriarWexDb())
{
var historicos = contexto.CronogramaTarefa
.Where(o => o.OidCronograma == oidCronograma && !o.CsExcluido && !o.Tarefa.CsExcluido)
.Join(contexto.TarefaHistoricoEstimativa, ct => ct.OidTarefa,
th => th.OidTarefa,
(c, t) => t)
.ToList();
var datas = historicos.Where(o => o.DtPlanejado.Date >= dataInicio.Date).Select(o => o.DtPlanejado.Date).Distinct().OrderBy(o => o).ToList();
Dictionary <DateTime, double> somatorios = new Dictionary <DateTime, double>();
foreach (var data in datas)
{
if (data.Date > DateUtil.ConsultarDataHoraAtual().Date)
{
break;
}
double soma = 0;
soma = historicos.Where(o => o.DtPlanejado.Date <= data.Date)
.OrderByDescending(o => o.DtPlanejado)
.ToLookup(o => o.OidTarefa)
.Select(o => o.FirstOrDefault())
.ToList()
.Sum(o => o.NbHoraRestante);
somatorios.Add(data, soma);
}
return(somatorios);
}
}
/// <summary>
/// Criando Factory para criação de novos usuário no sistema
/// </summary>
/// <param name="contexto">Contexto do banco</param>
/// <param name="txUserName">descrição para nome de usuário</param>
/// <param name="txFirstName">descrição para primeiro nome do usuário</param>
/// <param name="txLastName">descrição para último nome do usuário</param>
/// <param name="txEmail">descrição para email do usuário</param>
/// <param name="save">verificação se é necessário salvar o objeto</param>
/// <returns>Objeto de Usuário</returns>
public static User CriarUsuario(WexDb contexto, String txUserName, String txFirstName, String txLastName, String txEmail, bool save = true)
{
User usuario = new User()
{
Person = new Person()
{
Party = new Party()
}
};
usuario.UserName = txUserName;
usuario.Person.FirstName = txFirstName;
usuario.Person.LastName = txLastName;
usuario.Person.Email = txEmail;
DateUtil.CurrentDateTime = DateTime.MinValue;
//UserDao.CurrentUser = usuario;
if (save)
{
contexto.Usuario.Add(usuario);
contexto.SaveChanges();
}
return(usuario);
}
/// <summary>
/// Factory para criação de situação planejamento
/// </summary>
/// <param name="contexto">Contexto do banco</param>
/// <param name="txDescricao">descrição para descrição da situação planejamento</param>
/// <param name="csSituacao">enum de situacao</param>
/// <param name="csTipo">enum de tipo</param>
/// <param name="padraoSistema">Verifica se é padrão do sistema</param>
/// <param name="save">verificação se é necessário salvar o objeto</param>
/// <returns>Objeto de Situação Planejamento</returns>
public static SituacaoPlanejamento CriarSituacaoPlanejamento(WexDb contexto,
String txDescricao = "",
CsTipoSituacaoPlanejamento csSituacao = CsTipoSituacaoPlanejamento.Ativo,
CsTipoPlanejamento csTipo = CsTipoPlanejamento.Execução,
CsPadraoSistema padraoSistema = CsPadraoSistema.Não,
bool save = true)
{
SituacaoPlanejamento situacaoPlanejamento = new SituacaoPlanejamento
{
TxDescricao = txDescricao,
CsPadrao = padraoSistema,
TxKeys = ((Shortcut)(contadorAtalhos + seedShortcut)).ToString(),
KeyPress = contadorAtalhos + seedShortcut,
CsSituacao = csSituacao,
CsTipo = csTipo
};
if (save)
{
contexto.SituacaoPlanejamento.Add(situacaoPlanejamento);
contexto.SaveChanges();
}
contadorAtalhos++;
return(situacaoPlanejamento);
}
/// <summary>
/// Factory para crição do objeto de criação de tarefas
/// </summary>
/// <param name="contexto">contexto do banco</param>
/// <param name="nbId">descrição para id da tarefa</param>
/// <param name="txDescricao">descrição para nome da tarefa</param>
/// <param name="txObservacao">descrição para observação da tarefa</param>
/// <param name="situacaoPlanejamento">situação da tarefa</param>
/// <param name="estimativaInicial">estimativa inicial da tarefa</param>
/// <param name="realizado">Número de horas realizada na tarefa</param>
/// <param name="colaborador">Colaborador atrelado a tarefa</param>
/// <param name="cronograma">Cronograma da tarefa</param>
/// <param name="tarefaSelecionada">verifica se nenhuma tarefa foi selecionada</param>
/// <param name="save">verificação se é necessário salvar o objeto</param>
/// <returns>Objeto de Tarefa</returns>
public static CronogramaTarefa CriarTarefa(WexDb contexto, ushort nbId, String txDescricao, String txObservacao,
SituacaoPlanejamento situacaoPlanejamento, Int16 estimativaInicial, TimeSpan realizado,
Colaborador colaborador, Cronograma cronograma, CronogramaTarefa tarefaSelecionada, bool save = false)
{
CronogramaTarefa tarefa = new CronogramaTarefa()
{
Tarefa = new Tarefa()
{
SituacaoPlanejamento = new SituacaoPlanejamento()
}
};
tarefa.Cronograma = cronograma;
if (situacaoPlanejamento != null)
{
tarefa.Tarefa.SituacaoPlanejamento = situacaoPlanejamento;
}
tarefa.Tarefa.TxDescricao = txDescricao;
tarefa.Tarefa.TxObservacao = txObservacao;
tarefa.Tarefa.DtInicio = new DateTime(2011, 11, 01);
tarefa.Tarefa.NbEstimativaInicial = estimativaInicial;
tarefa.Tarefa.TxResponsaveis = colaborador.NomeCompleto;
tarefa.Tarefa.EstimativaRealizadoHora = realizado;
tarefa.Tarefa.AtualizadoPor = colaborador;
if (save)
{
contexto.CronogramaTarefa.Add(tarefa);
contexto.SaveChanges();
}
return(tarefa);
}
/// <summary>
/// Método utilizado para criar uma configuração para um colaborador em um determinado cronograma
/// </summary>
/// <param name="contexto">contexto do banco</param>
/// <param name="login"></param>
/// <param name="oidCronograma">oid do cronograma atual</param>
/// <returns>ColaboradorCronogramaConfig para armazenar as configurações do colaborador</returns>
public static CronogramaColaboradorConfig SalvarCronogramaColaboradorConfig(WexDb contexto, string login, Guid oidCronograma)
{
Cronograma cronograma = CronogramaDao.ConsultarCronogramaPorOid(oidCronograma);
if (cronograma == null)
{
return(null);
}
Colaborador colaborador = ColaboradorDAO.ConsultarColaborador(login);
if (colaborador == null)
{
return(null);
}
CronogramaColaboradorConfig config = ConsultarCronogramaColaboradorConfig(contexto, login, oidCronograma);
if (config != null)
{
return(config);
}
config = new CronogramaColaboradorConfig()
{
OidCronograma = cronograma.Oid,
OidColaborador = colaborador.Oid
};
contexto.CronogramaColaboradorConfig.Add(config);
contexto.SaveChanges();
return(config);
}
/// <summary>
/// Método responsável por salvar o último cronograma selecionado por um usuário.
/// </summary>
/// <param name="contexto">contexto do banco</param>
/// <param name="login">Login do usuário</param>
/// <param name="oidCronograma">Oid do Cronograma selecionado</param>
public static void SalvarUltimoCronogramaSelecionado(WexDb contexto, string login, Guid?oidCronograma)
{
if (contexto == null || login == null || !oidCronograma.HasValue)
{
throw new ArgumentException("Os parâmetros session, oidUsuario e oidCronograma não podem nulos.");
}
User usuario = contexto.Usuario.FirstOrDefault(o => o.UserName == login);
DateTime dataAcesso = DateTime.Now;
Cronograma cronogramaSelecionado = contexto.Cronograma.FirstOrDefault(o => o.Oid == oidCronograma.Value);
CronogramaUltimaSelecao ultimoCronogramaSelecionado = contexto.CronogramaUltimaSelecao.FirstOrDefault(o => o.OidUsuario == usuario.Oid);
if (ultimoCronogramaSelecionado != null)
{
ultimoCronogramaSelecionado.DataAcesso = dataAcesso;
ultimoCronogramaSelecionado.Usuario = usuario;
ultimoCronogramaSelecionado.Cronograma = cronogramaSelecionado;
contexto.SaveChanges();
}
else
{
CronogramaUltimaSelecao ultimoCronograma = new CronogramaUltimaSelecao();
ultimoCronograma.DataAcesso = dataAcesso;
ultimoCronograma.Usuario = usuario;
ultimoCronograma.Cronograma = cronogramaSelecionado;
contexto.CronogramaUltimaSelecao.Add(ultimoCronograma);
contexto.SaveChanges();
}
}
public Colaborador ConsultarColaboradorPorGuid(WexDb db, Guid IdColaborador)
{
return(db.Colaboradores
.Include(o => o.Usuario.Person)
.Include(o => o.Cargo)
.FirstOrDefault(o => o.Oid == IdColaborador));
}
/// <summary>
/// Método responsável por buscar uma situação planejamento pelo Oid.
/// </summary>
/// <param name="oidSituacaoPlanejamento">Oid da situação planejamento</param>
/// <returns>Situação Planejamento</returns>
public static WexProject.BLL.Entities.Planejamento.SituacaoPlanejamento ConsultarSituacaoPlanejamentoPorOid(Guid oidSituacaoPlanejamento)
{
using (WexDb contexto = ContextFactoryManager.CriarWexDb())
{
return(contexto.SituacaoPlanejamento.FirstOrDefault(o => o.Oid == oidSituacaoPlanejamento));
}
}
/// <summary>
/// Selecionar varios colaboradores pelo login em uma coleção de logins
/// </summary>
/// <param name="logins"></param>
/// <returns></returns>
public static List <Colaborador> ConsultarColaboradores(ICollection <string> logins, params Expression <Func <Colaborador, object> >[] includes)
{
using (WexDb contexto = ContextFactoryManager.CriarWexDb())
{
return(contexto.Colaboradores.MultiploInclude(includes).Where(o => logins.Contains(o.Usuario.UserName)).ToList());
}
}
/// <summary>
/// Consultar Situação Planejamento por Tipo.
/// </summary>
/// <param name="tipo">Tipo da situação</param>
/// <returns>Situação Planejamento</returns>
public static WexProject.BLL.Entities.Planejamento.SituacaoPlanejamento ConsultarSituacaoPorTipo(CsTipoPlanejamento tipo)
{
using (WexDb contexto = ContextFactoryManager.CriarWexDb())
{
return(contexto.SituacaoPlanejamento.FirstOrDefault(o => o.CsSituacao == CsTipoSituacaoPlanejamento.Ativo && o.CsTipo == tipo));
}
}
public Dictionary <ProjetoDto, List <CustoRubricaDto> > GetCustosProjetos()
{
Dictionary <ProjetoDto, List <CustoRubricaDto> > custosProjetos;
using (var _db = new WexDb())
{
custosProjetos = (from rm in _db.RubricaMeses
join p in _db.Projetos on rm.Rubrica.Aditivo.ProjetoOid equals p.Oid
join tp in _db.TiposProjetos on p.TipoProjetoId equals tp.TipoProjetoId
where p.ProjetoMacroOid == null
group new CustoRubricaDto
{
Ano = rm.NbAno,
Mes = rm.CsMes,
TipoRubrica = rm.Rubrica.TipoRubricaId,
Planejado = rm.NbPlanejado,
Replanejado = rm.NbReplanejado,
Gasto = rm.NbGasto,
Entrada = rm.Rubrica.TipoRubrica.CsClasse == CsClasseRubrica.Aportes
} by new
{
Oid = p.Oid,
Nome = p.TxNome,
Status = p.CsSituacaoProjeto,
Classe = tp.ClasseProjetoId
})
.ToDictionary(c => new ProjetoDto {
Oid = c.Key.Oid, Nome = c.Key.Nome, Status = (int)c.Key.Status, Classe = c.Key.Classe
}, c => c.ToList());
}
return(custosProjetos);
}
/// <summary>
/// Consultar Situações de Planejamento que estão Ativas.
/// </summary>
/// <returns>Coleção de situações de planejamento</returns>
public static List <WexProject.BLL.Entities.Planejamento.SituacaoPlanejamento> ConsultarSituacoesAtivas()
{
using (WexDb contexto = ContextFactoryManager.CriarWexDb())
{
return(contexto.SituacaoPlanejamento.Where(o => o.CsSituacao == CsTipoSituacaoPlanejamento.Ativo).OrderBy(o => o.TxDescricao).ToList());
}
}
public static Estoria Criar(WexDb contexto, Modulo modulo, Beneficiado beneficiado, string titulo, uint tamanho, string emAnalise, Estoria estoriaPai)
{
Estoria estoria = new Estoria();
estoria.OidModulo = modulo.Oid;
estoria.OidEstoriaPai = estoriaPai.Oid;
estoria.OidBeneficiado = beneficiado.Oid;
estoria.TxTitulo = titulo;
estoria.NbTamanho = tamanho;
if (emAnalise.ToUpper().Equals("SIM"))
{
estoria.CsEmAnalise = true;
estoria.CsSituacao = Convert.ToInt32(CsEstoriaDomain.EmAnalise);
}
else
{
estoria.CsEmAnalise = false;
estoria.CsSituacao = Convert.ToInt32(CsEstoriaDomain.NaoIniciado);
}
EstoriaDAO.SalvarEstoria(contexto, estoria);
return(estoria);
}
/// <summary>
/// Consultar situações inativas.
/// </summary>
///
/// <returns>Coleção de Situações Planejamento Inativas</returns>
public static List <WexProject.BLL.Entities.Planejamento.SituacaoPlanejamento> ConsultarSituacoesInativas()
{
using (WexDb contexto = ContextFactoryManager.CriarWexDb())
{
return(contexto.SituacaoPlanejamento.Where(o => (int)o.CsSituacao == (int)CsTipoSituacaoPlanejamento.Inativo).ToList());
}
}
public void ConstruirContextoPadraoParaIniciarTeste()
{
ContextFactoryMock.AbrirConexao = AbrirConexaoMock;
ContextFactoryManager.SetContextFactory(new ContextFactoryMock());
contexto = ContextFactoryManager.CriarWexDb();
colaboradorPadrao = CriarColaboradoPadrao();
}
public static void SalvarUltimoCronogramaSelecionado(string login, Guid oidCronograma)
{
using (WexDb contexto = ContextFactoryManager.CriarWexDb())
{
CronogramaUltimaSelecaoDao.SalvarUltimoCronogramaSelecionado(contexto, login, oidCronograma);
}
}
/// <summary>
/// Verifica se existe alguma nota fiscal importada
/// </summary>
/// <param name="chaveImportacao">Código do importação</param>
/// <returns></returns>
public static bool VerificarNotasFiscaisImportadas(int chaveImportacao)
{
using (WexDb contexto = ContextFactoryManager.CriarWexDb())
{
return(contexto.NotaFiscal.Any(notaFiscal => notaFiscal.ChaveImportacao == chaveImportacao));
}
}
/// <summary>
/// Método responsável por buscar todos os cronogramas no banco
/// É usado pelo serviço quando solicitado pela tela de cronograma
/// </summary>
/// <param name="contexto">Contexto do banco</param>
/// <returns>Uma coleção com os cronogramas</returns>
public static List <Cronograma> ConsultarCronogramas()
{
using (WexDb contexto = ContextFactoryManager.CriarWexDb())
{
return(contexto.Cronograma.Include(o => o.SituacaoPlanejamento).OrderBy(o => o.TxDescricao).Where(o => !o.CsExcluido).ToList());
}
}
/// <summary>
/// Verifica se o projeto é um projeto micro
/// </summary>
/// <param name="IdProjeto">Id do projeto</param>
/// <returns>Boolean</returns>
public bool VerificarProjetoMicro(Guid IdProjeto)
{
WexDb db = ContextFactoryManager.CriarWexDb();
Projeto projeto = ProjetoDao.Instancia.ConsultarProjetoPorGuid(db, IdProjeto);
return(projeto != null && projeto.ProjetoMacro != null);
}
/// <summary>
/// Métodos responsável por buscar um cronograma pelo Oid.
/// </summary>
/// <param name="session">Sessão corrente</param>
/// <param name="oidCronograma">Oid do Cronograma (ID)</param>
/// <returns>Objeto Cronograma</returns>
public static Cronograma ConsultarCronogramaPorOid(Guid oidCronograma, params Expression <Func <Cronograma, object> >[] includes)
{
using (WexDb contexto = ContextFactoryManager.CriarWexDb())
{
return(ConsultarCronogramaPorOid(contexto, oidCronograma, includes));
}
}
/// <summary>
/// CriarColaborador
/// </summary>
/// <param name="contexto">contexto do banco</param>
/// <param name="matricula">matricula</param>
/// <param name="admissao">admissao</param>
/// <param name="email">email</param>
/// <param name="fistName">fistName</param>
/// <param name="middleName">middleName</param>
/// <param name="lastName">lastName</param>
/// <param name="username">username</param>
/// <param name="cargo">Cargo do Colaborador</param>
/// <param name="save">save</param>
/// <returns>colaborador</returns>
public static Colaborador CriarColaborador(WexDb contexto, string username, Guid?OidColaboradorUltimoFiltro = null, string matricula = "", DateTime admissao = new DateTime(), string email = "",
string fistName = "", string middleName = "", string lastName = "", Cargo cargo = null)
{
Colaborador colaborador = new Colaborador();
colaborador.Usuario = new User()
{
Person = new Person()
{
Party = new Party()
}
};
colaborador.Oid = Guid.NewGuid();
colaborador.TxMatricula = matricula;
colaborador.DtAdmissao = admissao;
colaborador.OidColaboradorUltimoFiltro = OidColaboradorUltimoFiltro;
colaborador.Usuario.Person.Email = email;
colaborador.Usuario.Person.FirstName = fistName;
colaborador.Usuario.Person.MiddleName = middleName;
colaborador.Usuario.Person.LastName = lastName;
colaborador.Usuario.UserName = username;
contexto.Colaboradores.Add(colaborador);
contexto.SaveChanges();
return(colaborador);
}
/// <summary>
/// Método responsável por ConsultarIncluindoRelacionamentos um objeto CronogramaTarefa pelo Oid do Objeto Tarefa
/// </summary>
/// <param name="oidTarefa">Oid da tarefa que será procurada</param>
/// <returns>Tarefa encontrada</returns>
public static CronogramaTarefa ConsultarCronogramarTarefaPorTarefaOid(Guid oidTarefa, params Expression <Func <CronogramaTarefa, object> >[] includes)
{
using (WexDb contexto = ContextFactoryManager.CriarWexDb())
{
return(contexto.CronogramaTarefa.MultiploInclude(includes).FirstOrDefault(o => o.Tarefa.Oid == oidTarefa && !o.CsExcluido));
}
}