public void SalvarTipoDisciplina(TipoDisciplinaDto tipoDisciplinaDto)
        {
            var graphClient = ConexaoGrafo.GetConnection();

            if (tipoDisciplinaDto.Id > 0)
            {
                graphClient.Cypher.Match("(tipoDisciplina:TipoDisciplina)")
                .Where <TipoDisciplinaDto>(tipoDisciplina => tipoDisciplina.Id == tipoDisciplinaDto.Id)
                .Set("tipoDisciplina.Nome = {Nome}")
                .Set("tipoDisciplina.Codigo = {Codigo}")
                .WithParam("Nome", tipoDisciplinaDto.Nome)
                .WithParam("Codigo", tipoDisciplinaDto.Codigo)
                .ExecuteWithoutResults();
            }
            else
            {
                tipoDisciplinaDto.Id = graphClient.Cypher.Match($"(tipoDisciplina:TipoDisciplina)")
                                       .Return(() => Neo4jClient.Cypher.Return.As <int>("MAX(tipoDisciplina.Id)"))
                                       .Results
                                       .SingleOrDefault() + 1;

                graphClient.Cypher.Create("(tipoDisciplina:TipoDisciplina { Nome: {Nome}, Codigo: {Codigo} , Id: {Id} })")
                .WithParam("Nome", tipoDisciplinaDto.Nome)
                .WithParam("Codigo", tipoDisciplinaDto.Codigo)
                .WithParam("Id", tipoDisciplinaDto.Id)
                .ExecuteWithoutResults();
            }

            graphClient.Dispose();
        }
        public List <SalaDeAulaDto> ListarSalaDeAulaPorFiltros(ConceitoDto conceitoDto, DisciplinaDto disciplinaDto, PessoaDto pessoaDto, TurmaDto turmaDto)
        {
            var graphClient = ConexaoGrafo.GetConnection();

            Nullable <int> valorNulo = null;

            List <SalaDeAulaDto> list = graphClient.Cypher.Match("(salaDeAula:SalaDeAula), (pessoa:Pessoa) , (conceito:Conceito)")
                                        .Where(" pessoa.Id = salaDeAula.PessoaId and salaDeAula.Nota > conceito.Minimo and salaDeAula.Nota <= conceito.Maximo")
                                        .With(" salaDeAula,{ PessoaId: pessoa.Id, PessoaNome: pessoa.Nome} as Pessoas, conceito")
                                        .With(" conceito,{ Id: salaDeAula.Id, Semestre: salaDeAula.Semestre, DisciplinaId: salaDeAula.DisciplinaId,Nota: salaDeAula.Nota,TurmaId: salaDeAula.TurmaId, PessoaId: Pessoas.PessoaId, PessoaNome: Pessoas.PessoaNome} as salaDeAula")
                                        .Where <SalaDeAulaDto>(salaDeAula => salaDeAula.TurmaId == turmaDto.Id)

                                        .AndWhere(" salaDeAula.DisciplinaId = coalesce({disciplinaId},salaDeAula.DisciplinaId)  ")
                                        .WithParam("disciplinaId", disciplinaDto == null ? valorNulo : disciplinaDto.Id)

                                        .AndWhere(" salaDeAula.PessoaId = coalesce({pessoaId},salaDeAula.PessoaId)  ")
                                        .WithParam("pessoaId", pessoaDto == null ? valorNulo : pessoaDto.Id)

                                        .AndWhere(" conceito.Id = coalesce({conceitoId},conceito.Id)  ")
                                        .WithParam("conceitoId", conceitoDto == null ? valorNulo : conceitoDto.Id)

                                        .Return(salaDeAula => salaDeAula.As <SalaDeAulaDto>())
                                        .Results
                                        .ToList();

            graphClient.Dispose();
            return(list);
        }
Beispiel #3
0
        public void SalvarTurma(TurmaDto turmaDto)
        {
            var graphClient = ConexaoGrafo.GetConnection();

            if (turmaDto.Id > 0)
            {
                graphClient.Cypher.Match("(turma:Turma)")
                .Where <TurmaDto>(turma => turma.Id == turmaDto.Id)
                .Set("turma.DataIngresso = {DataIngresso}")
                .Set("turma.Codigo = {Codigo}")
                .WithParam("DataIngresso", turmaDto.DataIngresso)
                .WithParam("Codigo", turmaDto.Codigo)
                .ExecuteWithoutResults();
            }
            else
            {
                turmaDto.Id = graphClient.Cypher.Match($"(turma:Turma)")
                              .Return(() => Neo4jClient.Cypher.Return.As <int>("MAX(turma.Id)"))
                              .Results
                              .SingleOrDefault() + 1;

                graphClient.Cypher.Create("(turma :Turma  { DataIngresso: {DataIngresso}, Codigo: {Codigo} , Id: {Id} })")
                .WithParam("DataIngresso", turmaDto.DataIngresso)
                .WithParam("Codigo", turmaDto.Codigo)
                .WithParam("Id", turmaDto.Id)
                .ExecuteWithoutResults();
            }

            //DeletarTurmaTipoTurma(turmaDto);
            //SalvarTurmaTipoTurma(turmaDto);

            graphClient.Dispose();
        }
        public void DeletarTipoDisciplina(TipoDisciplinaDto tipoDisciplinaDto)
        {
            var graphClient = ConexaoGrafo.GetConnection();

            graphClient.Cypher.Match($"(tipoDisciplina:TipoDisciplina)")
            .Where <PessoaDto>(tipoDisciplina => tipoDisciplina.Id == tipoDisciplinaDto.Id)
            .DetachDelete("tipoDisciplina")
            .ExecuteWithoutResults();

            graphClient.Dispose();
        }
Beispiel #5
0
        public List <DisciplinaDto> ListarDisciplinas()
        {
            var graphClient           = ConexaoGrafo.GetConnection();
            List <DisciplinaDto> list = graphClient.Cypher.Match($"(disciplina:Disciplina)")
                                        .Return(disciplina => disciplina.As <DisciplinaDto>())
                                        .Results
                                        .ToList();

            graphClient.Dispose();

            return(list);
        }
Beispiel #6
0
        public List <TurmaDto> ListarTurmas()
        {
            var             graphClient = ConexaoGrafo.GetConnection();
            List <TurmaDto> list        = graphClient.Cypher.Match($"(turma:Turma)")
                                          .Return(turma => turma.As <TurmaDto>())
                                          .Results
                                          .ToList();

            graphClient.Dispose();

            return(list);
        }
        public List <SalaDeAulaDto> ListarSalasDeAula()
        {
            var graphClient           = ConexaoGrafo.GetConnection();
            List <SalaDeAulaDto> list = graphClient.Cypher.Match($"(salaDeAula:SalaDeAula)")
                                        .Return(salaDeAula => salaDeAula.As <SalaDeAulaDto>())
                                        .Results
                                        .ToList();

            graphClient.Dispose();

            return(list);
        }
        public List <TipoDisciplinaDto> ListarTiposDisciplina()
        {
            var graphClient = ConexaoGrafo.GetConnection();
            List <TipoDisciplinaDto> list = graphClient.Cypher.Match($"(tipoDisciplina:TipoDisciplina)")
                                            .Return(tipoDisciplina => tipoDisciplina.As <TipoDisciplinaDto>())
                                            .Results
                                            .ToList();

            graphClient.Dispose();

            return(list);
        }
Beispiel #9
0
        public DisciplinaDto ListarDisciplina(int id)
        {
            var           graphClient   = ConexaoGrafo.GetConnection();
            DisciplinaDto disciplinaDto = graphClient.Cypher.Match($"(disciplina:Disciplina)")
                                          .Where <DisciplinaDto>(disciplina => disciplina.Id == id)
                                          .Return(disciplina => disciplina.As <DisciplinaDto>())
                                          .Results
                                          .SingleOrDefault();

            graphClient.Dispose();

            return(disciplinaDto);
        }
Beispiel #10
0
        public List <DisciplinaDto> ListarDisciplinaPorTipo(TipoDisciplinaDto tipoDisciplinaDto)
        {
            var graphClient           = ConexaoGrafo.GetConnection();
            List <DisciplinaDto> list = graphClient.Cypher.Match($"(disciplina:Disciplina)")
                                        .Where <DisciplinaDto>(disciplina => disciplina.TipoDisciplinaId == tipoDisciplinaDto.Id)
                                        .Return(disciplina => disciplina.As <DisciplinaDto>())
                                        .Results
                                        .ToList();

            graphClient.Dispose();

            return(list);
        }
        public SalaDeAulaDto ListarSalaDeAula(int id)
        {
            var           graphClient   = ConexaoGrafo.GetConnection();
            SalaDeAulaDto salaDeAulaDto = graphClient.Cypher.Match($"(salaDeAula:SalaDeAula)")
                                          .Where <SalaDeAulaDto>(salaDeAula => salaDeAula.Id == id)
                                          .Return(salaDeAula => salaDeAula.As <SalaDeAulaDto>())
                                          .Results
                                          .SingleOrDefault();

            graphClient.Dispose();

            return(salaDeAulaDto);
        }
Beispiel #12
0
        public void DeletarTurma(TurmaDto turmaDto)
        {
            //DeletarDisciplinaTipoDisciplina(disciplinaDto);

            var graphClient = ConexaoGrafo.GetConnection();

            graphClient.Cypher.Match($"(turma :Turma)")
            .Where <DisciplinaDto>(turma => turma.Id == turmaDto.Id)
            .DetachDelete("turma")
            .ExecuteWithoutResults();

            graphClient.Dispose();
        }
Beispiel #13
0
        public void DeletarDisciplina(DisciplinaDto disciplinaDto)
        {
            DeletarDisciplinaTipoDisciplina(disciplinaDto);

            var graphClient = ConexaoGrafo.GetConnection();

            graphClient.Cypher.Match($"(disciplina:Disciplina)")
            .Where <DisciplinaDto>(disciplina => disciplina.Id == disciplinaDto.Id)
            .DetachDelete("disciplina")
            .ExecuteWithoutResults();

            graphClient.Dispose();
        }
        public List <TipoPessoaDto> ListarTipoPessoaPorPessoa(PessoaDto pessoa)
        {
            var graphClient           = ConexaoGrafo.GetConnection();
            List <TipoPessoaDto> list = graphClient.Cypher.Match($"(tipoPessoa:TipoPessoa)")
                                        .Where <TipoPessoaDto>(tipoPessoa => tipoPessoa.Id == pessoa.Id)
                                        .Return(tipoPessoa => tipoPessoa.As <TipoPessoaDto>())
                                        .Results
                                        .ToList();

            graphClient.Dispose();

            return(list);
        }
        public TipoDisciplinaDto ListarTipoDisciplina(int id)
        {
            var graphClient = ConexaoGrafo.GetConnection();
            TipoDisciplinaDto tipoDisciplinaDto = graphClient.Cypher.Match($"(tipoDisciplina:TipoDisciplina)")
                                                  .Where <TipoDisciplinaDto>(tipoDisciplina => tipoDisciplina.Id == id)
                                                  .Return(tipoDisciplina => tipoDisciplina.As <TipoDisciplinaDto>())
                                                  .Results
                                                  .SingleOrDefault();

            graphClient.Dispose();

            return(tipoDisciplinaDto);
        }
        public List <SalaDeAulaDto> ListarSalaDeAulaPorPessoa(PessoaDto pessoaDto)
        {
            var graphClient = ConexaoGrafo.GetConnection();

            List <SalaDeAulaDto> list = graphClient.Cypher.Match("(salaDeAula:SalaDeAula),(pessoa:Pessoa)")
                                        .Where(" pessoa.Id = salaDeAula.PessoaId ")
                                        .With(" salaDeAula,{ PessoaId: pessoa.Id, PessoaNome: pessoa.Nome} as Pessoas")
                                        .With(" { Id: salaDeAula.Id, Semestre: salaDeAula.Semestre, DisciplinaId: salaDeAula.DisciplinaId,Nota: salaDeAula.Nota,TurmaId: salaDeAula.TurmaId, PessoaId: Pessoas.PessoaId, PessoaNome: Pessoas.PessoaNome} as salaDeAula")
                                        .Where <SalaDeAulaDto>(salaDeAula => salaDeAula.PessoaId == pessoaDto.Id).Return(salaDeAula => salaDeAula.As <SalaDeAulaDto>())
                                        .Results
                                        .ToList();

            graphClient.Dispose();
            return(list);
        }
Beispiel #17
0
        public void SalvarDisciplina(DisciplinaDto disciplinaDto)
        {
            var graphClient = ConexaoGrafo.GetConnection();

            if (disciplinaDto.Id > 0)
            {
                graphClient.Cypher.Match("(disciplina:Disciplina)")
                .Where <DisciplinaDto>(disciplina => disciplina.Id == disciplinaDto.Id)
                .Set("disciplina.Nome = {Nome}")
                .Set("disciplina.Codigo = {Codigo}")
                .Set("disciplina.TipoDisciplinaId = {TipoDisciplinaId}")
                .WithParam("Nome", disciplinaDto.Nome)
                .WithParam("Codigo", disciplinaDto.Codigo)
                .WithParam("TipoDisciplinaId", disciplinaDto.TipoDisciplinaId)
                .ExecuteWithoutResults();
            }
            else
            {
                disciplinaDto.Id = graphClient.Cypher.Match($"(disciplina:Disciplina)")
                                   .Return(() => Neo4jClient.Cypher.Return.As <int>("MAX(disciplina.Id)"))
                                   .Results
                                   .SingleOrDefault() + 1;

                graphClient.Cypher.Create("(disciplina :Disciplina  { Nome: {Nome}, Codigo: {Codigo} ,TipoDisciplinaId: {TipoDisciplinaId}, Id: {Id} })")
                .WithParam("Nome", disciplinaDto.Nome)
                .WithParam("Codigo", disciplinaDto.Codigo)
                .WithParam("TipoDisciplinaId", disciplinaDto.TipoDisciplinaId)
                .WithParam("Id", disciplinaDto.Id)
                .ExecuteWithoutResults();
            }

            DeletarDisciplinaTipoDisciplina(disciplinaDto);
            SalvarDisciplinaTipoDisciplina(disciplinaDto);

            graphClient.Dispose();
        }