public IHttpActionResult PutEscola(string id, Escola escola)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != escola.Id)
{
return(BadRequest());
}
db.Entry(escola).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!EscolaExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public IHttpActionResult PostEscola(Escola escola)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
dbset.Add(escola);
try
{
db.SaveChanges();
}
catch (DbUpdateException)
{
if (EscolaExists(escola.Id))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtRoute("DefaultApi", new { id = escola.Id }, escola));
}
public async Task <Guid> AddAsync(Escola escola)
{
escola.EscolaID = Guid.NewGuid();
await EscolaRepository.SaveNewAsync(escola);
return(escola.EscolaID);
}
static void Main(string[] args)
{
RecapitulacaoLogica ed = new RecapitulacaoLogica();
Classes_Metodos_Atributos_StaticMembers cm = new Classes_Metodos_Atributos_StaticMembers();
Produto p = new Produto("Tv", 500.0, 100);
Produto p2 = new Produto();
Triangulo tri = new Triangulo();
retangulo ret = new retangulo();
Funcionario funcionario = new Funcionario();
Escola escola = new Escola();
ProgramTriangulo triangulo = new ProgramTriangulo();
Cotacao cot = new Cotacao();
p2.Escrita();
Console.ReadKey();
}
public Resultado Atualizar(Escola dadosEscola)
{
Resultado resultado = DadosValidos(dadosEscola);
resultado.Acao = "Atualização de Escola";
try
{
if (resultado.Mensagens.Count == 0)
{
Escola escola = _context.Escolas.Where(
p => p.Id != dadosEscola.Id).FirstOrDefault();
if (escola == null)
{
resultado.Mensagens.Add(
"Escola não encontrada");
}
else
{
escola.Nome = dadosEscola.Nome;
escola.Cidade = dadosEscola.Cidade;
escola.Bairro = dadosEscola.Bairro;
_context.SaveChanges();
}
}
}
catch (Exception ex)
{
resultado.Mensagens.Add("Erro:" + ex.Message);
}
return(resultado);
}
public Resultado Excluir(int idEscola)
{
Resultado resultado = new Resultado();
resultado.Acao = "Exclusão de Escola";
try
{
Escola escola = Obter(idEscola);
if (escola == null)
{
resultado.Mensagens.Add(
"Produto não encontrado");
}
else
{
_context.Escolas.Remove(escola);
_context.SaveChanges();
}
}
catch (Exception ex)
{
resultado.Mensagens.Add("Erro:" + ex.Message);
}
return(resultado);
}
public JsonResult DeleteConfirmed(int id)
{
bool result = false;
Escola escola = db.Escola.Find(id);
AULASDISPONIVEIS aulasDisp = new AULASDISPONIVEIS();
try
{
aulasDisp = db.AULASDISPONIVEIS.Where(m => m.IDESCOLA == id).Where(q => q.EXCLUIDO == 0).FirstOrDefault();
if (aulasDisp == null)
{
escola.Excluido = 1;
db.SaveChanges();
result = true;
}
else
{
result = false;
}
return(Json(result, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
return(Json(result, JsonRequestBehavior.AllowGet));
}
}
public void CadastrarTurma(Escola escola)
{
int idCoodenador, qtd;
Console.WriteLine("Digite a matricula do coodernador!\n");
while (!int.TryParse(Console.ReadLine(), out idCoodenador))
{
Console.WriteLine("matricula inválida, digite novamente!\n");
}
var oCoodenador = escola.Coordenadores.FirstOrDefault(c => c.Matricula == idCoodenador);
while (oCoodenador == null)
{
Console.WriteLine("Coordenador inválido, digite novamente!\n");
Console.WriteLine("Digite a matricula do coodernador!\n");
while (!int.TryParse(Console.ReadLine(), out idCoodenador))
{
Console.WriteLine("matricula inválida, digite novamente!\n");
}
oCoodenador = escola.Coordenadores.FirstOrDefault(c => c.Matricula == idCoodenador);
}
Console.WriteLine("Digite a quantiade maxima da turma!\n");
while (!int.TryParse(Console.ReadLine(), out qtd))
{
Console.WriteLine("quantidade inválida, digite novamente!\n");
}
Coordenador = oCoodenador;
Alunos = new List <Aluno>(qtd);
}
public async Task <ValidationResult> Handle(CriarEscolaCommand request, CancellationToken cancellationToken)
{
if (!request.IsValid())
{
return(request.ValidationResult);
}
var escolaBanco = await _escolaRepository.ObterEscolaPorCodigoAsync(request.Codigo);
if (!(escolaBanco is null))
{
AddErro("Escola já cadastrada");
return(ValidationResult);
}
var endereco = new Endereco(request.Logradouro,
request.Numero, request.Complemento, request.Bairro, request.Cep, request.TipoLocalizacaoId);
var contato = new Contato(request.Telefone, request.Email, request.Site);
var escola = new Escola(request.Nome, request.Codigo, endereco, contato);
await _escolaRepository.AdicionarAsync(escola);
var result = await _escolaRepository.UnitOfWork.CommitAsync();
if (!result)
{
AddErro("Ocorreu um erro inesperado no sistema");
}
return(ValidationResult);
}
private void button1_Click(object sender, EventArgs e)
{
string cpf = TextBoxCpf.Text;
EscolaController ec = new EscolaController();
Escola escola = new Escola();
try
{
escola = ec.PesquisarAluno(cpf);
if (escola == null)
{
MessageBox.Show("Cliente não foi encontrado", "ATENÇÃO", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
NomeAluno.Text = escola.GetNomeAluno();
DataNasc.Text = Convert.ToString(escola.GetDataNascimentoAluno());
AnoEscolar.Text = escola.GetAnoEscolar();
NomeResp.Text = escola.GetNomeResponsavel();
Contato.Text = escola.GetContato();
Email.Text = escola.GetEmail();
button1.Enabled = false;
TextBoxCpf.Enabled = false;
}
}
catch (Exception m)
{
MessageBox.Show(m.Message, "ATENÇÃO", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public override void CadastrarPessoa(Escola escola)
{
base.CadastrarPessoa(escola);
var numValida = Operacoes.ChecaId("aluno", Matricula, escola);
if (numValida != 0)
{
Matricula = numValida;
}
Console.WriteLine("Digite se o aluno é bolsista, sim ou não?");
string opcao = Console.ReadLine();
while (!Operacoes.ValidaOpcao(opcao))
{
Console.WriteLine("Opção inválida, digite novamente!");
opcao = Console.ReadLine();
if (opcao == "SIM")
{
Bolsista = true;
}
else
{
Bolsista = false;
}
}
Console.Clear();
Console.WriteLine($"{Nome} Cadastrado com sucesso! Matricula n° {Matricula} \n");
}
public static async Task <Escola> Create(Escola escola, string token)
{
Escola escolaCriado = new Escola();
try
{
using (var client = new HttpClient())
{
var parseJson = JsonConvert.SerializeObject(escola);
var content = new StringContent(parseJson, Encoding.UTF8, "application/json");
client.DefaultRequestHeaders.Add("Authorization", "Bearer " + token);
var response = await client.PostAsync($"{ConstantesProjeto.URL_BASE}/api/escolas", content);
if (response.IsSuccessStatusCode)
{
var escolasString = await response.Content.ReadAsStringAsync();
escolaCriado = JsonConvert.DeserializeObject <Escola>(escolasString);
return(escolaCriado);
}
return(null);
}
}
catch (Exception ex)
{
Console.WriteLine($"Erro ao conectar com a api {ex.Message}");
return(null);
}
}
public static async Task <Escola> GetEscolaById(long id, string token)
{
Escola escola = new Escola();
try
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer " + token);
var response = await client.GetAsync($"{ConstantesProjeto.URL_BASE}/api/escolas/{id}");
if (response.IsSuccessStatusCode)
{
var escolasString = await response.Content.ReadAsStringAsync();
escola = JsonConvert.DeserializeObject <Escola>(escolasString);
return(escola);
}
return(null);
}
}
catch (Exception)
{
Console.WriteLine("Erro ao conectar com a api");
return(null);
}
}
public IHttpActionResult Update(long id, [FromBody] Escola escola)
{
if (escola == null || escola.ID != id)
{
return(BadRequest());
}
using (var DAL = new elevaEntities())
{
var Model = DAL.Escola.Where(x => x.ID == id).FirstOrDefault();
if (Model == null)
{
return(NotFound());
}
Model.Nome = escola.Nome;
Model.Endereco = escola.Endereco;
DAL.Entry(Model).State = EntityState.Modified;
DAL.SaveChanges();
}
return(Ok());
}
public Resultado Incluir(Escola dadosEscola)
{
Resultado resultado = DadosValidos(dadosEscola);
resultado.Acao = "Inclusão de Escola";
try
{
if (resultado.Mensagens.Count == 0 &&
_context.Escolas.Where(
p => p.Id != dadosEscola.Id && p.Nome == dadosEscola.Nome).Count() > 0)
{
resultado.Mensagens.Add(
"Escola já cadastrada");
}
if (resultado.Mensagens.Count == 0)
{
_context.Escolas.Add(dadosEscola);
_context.SaveChanges();
}
}
catch (Exception ex)
{
resultado.Mensagens.Add("Erro:" + ex.Message);
}
return(resultado);
}
public Task AtualizarAsync(Escola escola)
{
_context.Entry(escola).State = EntityState.Modified;
_context.Escolas.Update(escola);
return(Task.CompletedTask);
}
public List <Escola> ObterTodos(string busca)
{
SqlCommand comando = conexão.Conectar();
comando.CommandText = @"SELECT * FROM escolas WHERE nome LIKE @BUSCA";
busca = $"%{busca}%";
comando.Parameters.AddWithValue("@BUSCA", busca);
List <Escola> escolas = new List <Escola>();
DataTable tabela = new DataTable();
tabela.Load(comando.ExecuteReader());
comando.Connection.Close();
for (int i = 0; i < tabela.Rows.Count; i++)
{
DataRow linha = tabela.Rows[i];
Escola escola = new Escola();
escola.Id = Convert.ToInt32(linha["Id"]);
escola.Nome = linha["Nome"].ToString();
escolas.Add(escola);
}
return(escolas);
}
public List <Escola> ObterTodos(string pesquisa)
{
SqlCommand command = conexao.Conectar();
command.CommandText = @"SELECT * FROM escolas WHERE nome LIKE @PESQUISA";
pesquisa = $"%{pesquisa}%";
command.Parameters.AddWithValue("@PESQUISA", pesquisa);
List <Escola> escolas = new List <Escola>();
DataTable table = new DataTable();
table.Load(command.ExecuteReader());
command.Connection.Close();
for (int i = 0; i < table.Rows.Count; i++)
{
DataRow row = table.Rows[i];
Escola escola = new Escola();
escola.Id = Convert.ToInt32(row["id"]);
escola.Nome = row["nome"].ToString();
escolas.Add(escola);
}
return(escolas);
}
public async Task <ActionResult <Escola> > PostEscola(Escola escola)
{
_context.Escolas.Add(escola);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetEscola", new { id = escola.EscolaId }, escola));
}
public async Task <IActionResult> PutEscola(int id, Escola escola)
{
if (id != escola.EscolaId)
{
return(BadRequest());
}
_context.Entry(escola).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EscolaExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public ActionResult Editar(int id)
{
Escola escola = repository.ObterPeloID(id);
ViewBag.Escola = escola;
return(View());
}
public IActionResult Put([FromBody] Escola escola)
{
if (escola == null)
{
return(BadRequest());
}
return(new ObjectResult(_escolaBusiness.Update(escola)));
}
public ActionResult DeleteConfirmed(string id)
{
Escola escola = dbset.Find(id);
dbset.Remove(escola);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult DeleteConfirmed(int id)
{
EscolaDAO escolaDAO = new EscolaDAO();
Escola escola = escolaDAO.ConsultarPorID(id);
escolaDAO.Excluir(escola.IdEscola);
return(RedirectToAction("Index"));
}
public void Editar(Escola escola)
{
using (MyDatabaseContext DBContext = new MyDatabaseContext())
{
DBContext.Entry(escola).State = System.Data.Entity.EntityState.Modified;
DBContext.SaveChanges();
}
}
public void Inserir(Escola escola)
{
using (MyDatabaseContext DBContext = new MyDatabaseContext())
{
DBContext.Escola.Add(escola);
DBContext.SaveChanges();
}
}
public async Task <IActionResult> Delete(int id)
{
var escola = new Escola();
HttpClient client = _api.Initial();
HttpResponseMessage responseMessage = await client.DeleteAsync($"api/escola/{id}");
return(RedirectToAction("Index"));
}
public ActionResult Cadastrar(string nome)
{
Escola escola = new Escola();
escola.Nome = nome;
repository.Inserir(escola);
return(RedirectToAction("index"));
}
public void criar_escola__com_todos_os_parametros__deve_atribuir_os_valores()
{
_aggregate = new Escola(_escolaId, _nome);
_aggregate.EntityId.Should().Be(_escolaId);
_aggregate.DataCriacao.Date.Should().Be(DateTime.Today);
_aggregate.Nome.Should().Be(_nome);
}
public ActionResult Store(string nome)
{
Escola escola = new Escola();
escola.Nome = nome;
int id = repositorio.Inserir(escola);
return(RedirectToAction("Index"));
}
