public static int Modificar(Clase clase)
{
int retorno = -1;
retorno = ClaseDA.Modificar(clase);
return(retorno);
}
public static int Eliminar(Clase clase)
{
int retorno = -1;
retorno = ClaseDA.Eliminar(clase);
return(retorno);
}
public static int Crear(Clase clase)
{
int retorno = -1;
retorno = ClaseDA.Crear(clase);
return(retorno);
}
public static Clase Obtener(int id)
{
Clase aux = new Clase();
aux = ClaseDA.Obtener(id);
return(aux);
}
public void Agregar(Clase Base nuevo)
{
if (raiz == null)
raiz = nuevo;
else
Agreagr(nuevo, ref.HIzquierdo);
}
/// <summary> Toma el id de la materia seleccionada y los nuevos creditos para modificarlos </summary>
private void bttnGuardarCreditos_Click(object sender, EventArgs e)
{
Clase c = lstListaMateriasProfesores.SelectedItem as Clase;
Conector.actualizarClase(c.Id, (int)UpDwnCreditos.Value);
LlenarListaMaterias();
}
public async Task <IActionResult> Edit(int id, [Bind("ClaseId,Name,Quantity,StartDate,FinishDate,StartHour,EndHour,CursoId,ProfesorId")] Clase clase)
{
if (id != clase.ClaseId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(clase);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ClaseExists(clase.ClaseId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["CursoId"] = new SelectList(_context.Cursos, "CursoId", "Name", clase.CursoId);
ViewData["ProfesorId"] = new SelectList(_context.Profesores, "ProfesorId", "FirstName", clase.ProfesorId);
return(View(clase));
}
public void updateInformacionClase()
{
clase = crudClases.ObtenerClase(this.CodigoClase);
lblNombreDocente.Text = clase.NombreDocente;
lblGrupo.Text = clase.Grupo;
lblMateria.Text = clase.Materia;
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Descripcion")] Clase clase)
{
if (id != clase.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(clase);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ClaseExists(clase.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(clase));
}
public void ObtenerPropiedadesInstancia()
{
var target = new Clase();
var result = target.GetType().GetProperties();
Assert.AreEqual(1, result.Count());
}
private void btoModificar(object sender, RoutedEventArgs e)
{
try
{
if (string.IsNullOrEmpty(this.NomTxt.Text))
{
throw new Exception("Debe especificar un nombre para la Clase");
}
if (string.IsNullOrEmpty(this.DesTxt.Text))
{
throw new Exception("Debe especificar una Descripción para la Clase");
}
Clase SelectItem = (Clase)ListClase.SelectedItem;
SelectItem.Nombre = NomTxt.Text;
SelectItem.Descripcion = DesTxt.Text;
int modClase = ClaseBL.Modificar(SelectItem);
if (modClase > 0)
{
MessageBox.Show("Clase Modificada Correctamente", "Correcto");
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Errorr");
}
ListClase.ItemsSource = ClaseBL.Listar();
}
private void btoCargar(object sender, RoutedEventArgs e)
{
try
{
if (string.IsNullOrEmpty(this.NomTxt.Text))
{
throw new Exception("Debe especificar un nombre para la Clase");
}
if (string.IsNullOrEmpty(this.DesTxt.Text))
{
throw new Exception("Debe especificar una Descripción para la Clase");
}
Clase laclase = new Clase();
laclase.Nombre = NomTxt.Text;
laclase.Descripcion = DesTxt.Text;
int newClase = ClaseBL.Crear(laclase);
if (newClase > 0)
{
MessageBox.Show("Clase Ingresada Correctamente", "Correcto");
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Errorr");
}
ListClase.ItemsSource = ClaseBL.Listar();
}
public int PostClase(Clase clase)
{
Token token = (Token)Request.Properties["token"];
clase.IdEscuela = token.IdEscuela;
return(claseService.PostClase(clase).Id);
}
private void btnEliminar_Click(object sender, EventArgs e)
{
try
{
if (noVacio())
{
Clase clases = new Clase();
clases = tablaClases.Encontrar(txtCodigoClase.Text);
if (clases != null)
{
tablaClases.EliminarClases(txtCodigoClase.Text);
MessageBox.Show("Clase Eliminada");
}
else
{
MessageBox.Show("No existe ese clase para eliminar.");
}
this.clasesTableAdapter.Fill(this.proyectoDataSet5.Clases);
}
else
{
MessageBox.Show("Campo Vacío. Intente otra vez.");
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public static Clase obtenerPorIdPersonaje(int id)
{
Clase aux = new Clase();
aux = ClaseDA.obtenerPorIdPersonaje(id);
return(aux);
}
public async Task <IHttpActionResult> PutClase(int id, Clase clase)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != clase.id)
{
return(BadRequest());
}
db.Entry(clase).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ClaseExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public static int Modificar(Personaje p, Clase clase, Raza raza)
{
int retorno = -1;
retorno = PersonajeDA.Modificar(p, clase, raza);
return(retorno);
}
private void btnModificar_Click(object sender, EventArgs e)
{
try
{
if (noVacio())
{
Clase clases = new Clase();
clases = tablaClases.Encontrar(txtCodigoClase.Text);
if (clases != null)
{
tablaClases.ModificarClases(txtCodigoClase.Text, txtDescripcionClase.Text, cmbTipo.Text);
MessageBox.Show("Usuario/Clase modificado con éxito!");
}
else
{
MessageBox.Show("Codigo de Clase incorrecto o no existente!");
}
this.clasesTableAdapter.Fill(this.proyectoDataSet5.Clases);
}
else
{
MessageBox.Show("Campo Vacío. Intente otra vez.");
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private void BtnCrear_Click(object sender, EventArgs e)
{
//MessageBox.Show(listaClases.Count().ToString() + cmbClase1.Items.Count);
for (int i = 0; i < listaClases.Count(); i++)
{
if (listaClases.Count() >= 1)
{
if (listaClases[i].getNombre().Equals(cmbClase1.Text))
{
this.clase1 = listaClases[i];
//MessageBox.Show("\n\nAsignacion Clase1\n\n");
}
}
if (listaClases.Count() > 0)
{
if (listaClases[i].getNombre().Equals(cmbClase2.Text))
{
this.clase2 = listaClases[i];
//MessageBox.Show("\nAsignacion clase2\n\n");
}
}
}
for (int i = 0; i < listaInterfaces.Count(); i++)
{
if (listaInterfaces.Count() >= 1)
{
if (listaInterfaces[i].getNombre().Equals(cmbClase1.Text))
{
this.interfaz1 = listaInterfaces[i];
//MessageBox.Show("\n\nAsiganacion interfaz1\n\n");
}
}
if (listaInterfaces.Count() > 0)
{
if (listaInterfaces[i].getNombre().Equals(cmbClase2.Text))
{
this.interfaz2 = listaInterfaces[i];
//MessageBox.Show("\nAsignacion interfaz2\n\n");
}
}
}
if (cmbClase1.Text.Equals(cmbClase2.Text))
{
MessageBox.Show("No puedes relacionar la misma clase");
}
else if (cmbClase1.Text.Substring(0, 1).Equals("C") && cmbClase2.Text.Substring(0, 1).Equals("C") && !cmbClase1.Text.Equals(cmbClase2.Text) && validar(clase1, clase2))
{
//MessageBox.Show("\n\nentra a funcion\n\n");
this.pnlPrincipal.agregarHerencia(this.clase1, this.clase2);
this.Close();
}
else
{
MessageBox.Show("Tienes errores por resolver o estas tratando de relacionar dos clases que no pueden relacionarse");
this.Close();
}
}
public void ModificarPregunta(Pregunta preguntaModificada, int[] ListaClases, int[] ListaTemas, int idProfesor)
{
MyContext ctx = new MyContext();
int idPregunta = preguntaModificada.IdPregunta;
Pregunta preguntaPorId = ctx.Pregunta.Find(idPregunta);
preguntaModificada.FechaHoraModificacion = DateTime.Now;
preguntaPorId.Nro = preguntaModificada.Nro;
preguntaPorId.Pregunta1 = preguntaModificada.Pregunta1;
preguntaPorId.FechaHoraModificacion = preguntaModificada.FechaHoraModificacion;
preguntaPorId.FechaDisponibleDesde = preguntaModificada.FechaDisponibleDesde;
preguntaPorId.FechaDisponibleHasta = preguntaModificada.FechaDisponibleHasta;
preguntaPorId.IdProfesorModificacion = idProfesor;
foreach (int IdClase in ListaClases)
{
Clase c = new Clase();
c = ctx.Clase.Find(IdClase);
preguntaPorId.Clase = c;
}
foreach (int IdTema in ListaTemas)
{
Tema t = new Tema();
t = ctx.Tema.Find(IdTema);
preguntaPorId.Tema = t;
}
ctx.SaveChanges();
}
public async Task<IActionResult> Edit(int id, [Bind("Id,ProfesorId,EstudianteId,FechaClase")] Clase clase)
{
if (id != clase.Id)
{
return NotFound();
}
if (ModelState.IsValid)
{
try
{
_context.Update(clase);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ClaseExists(clase.Id))
{
return NotFound();
}
else
{
throw;
}
}
return RedirectToAction(nameof(Index));
}
ViewData["EstudianteId"] = new SelectList(_context.Estudiante, "Id", "NombreEstudiante", clase.EstudianteId);
ViewData["ProfesorId"] = new SelectList(_context.Profesor, "Id", "Nombre", clase.ProfesorId);
return View(clase);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Nombre,Descripcion,Tipo,Imagen")] Clase clase)
{
if (id != clase.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
await _ClaseServices.UpdateClaseAsync(clase);
}
catch (DbUpdateConcurrencyException)
{
if (!_ClaseServices.ClaseExist(clase.Id)) // como lo metemos aquí, podemos borrar el Método ClaseExist del final.
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(clase));
}
public static void crearDocumento(List <AlmAsistencia> asistencia, Clase clase)
{
Document doc = new Document();
PdfWriter.GetInstance(doc, new FileStream(clase.CodigoClase + ".pdf", FileMode.Create));
doc.Open();
Paragraph title = new Paragraph();
title.Font = FontFactory.GetFont(FontFactory.TIMES, 18f, BaseColor.BLUE);
title.Add("Reporte pase de lista clase: " + clase.CodigoClase);
doc.Add(title);
doc.Add(new Paragraph("Profesor: " + clase.NombreDocente));
doc.Add(new Paragraph("Materia: " + clase.Materia));
doc.Add(new Paragraph("Grupo: " + clase.Grupo));
doc.Add(new Paragraph("\n"));
doc.Add(new Paragraph("\n"));
PdfPTable table = new PdfPTable(3);
//titulos
table.AddCell("Fecha");
table.AddCell("Numero de control");
table.AddCell("Asistencia");
foreach (var alm in asistencia)
{
table.AddCell(alm.Fecha);
table.AddCell(alm.NoControl);
table.AddCell(alm.Asistio.ToString());
}
doc.Add(table);
doc.Close();
}
/// <summary>
/// Autores: Samuel y Valeria
/// 10/10/19
/// Este método retorna una lista con todos los elementos del catalogo
/// </summary>
/// <returns>List<Clase></returns>
///
public List <Clase> ConsultarClases()
{
List <Clase> clases = new List <Clase>();
SqlConnection sqlConnection = conexion.conexion();
SqlCommand sqlCommand = new SqlCommand(@"EXEC PA_ConsultarClase ", sqlConnection);
SqlDataReader reader;
sqlConnection.Open();
reader = sqlCommand.ExecuteReader();
Clase clase;
while (reader.Read())
{
clase = new Clase();
clase.IdClase = Convert.ToInt32(reader["TN_IdClase"].ToString());
clase.Nombre = reader["TC_Nombre"].ToString();
clases.Add(clase);
}
sqlConnection.Close();
return(clases);
}
// GET: Clases
public ActionResult Index()
{
ViewBag.title = "Vista Clases";
var clases = new Clase().ListarClases();
return(View(clases));
}
public ActionResult Editar(int id)
{
Clase clase = new Clase();
clase.Seleccionar(id);
return(View(clase));
}
public async Task <IActionResult> CuentaAsistenciasPorClases([FromBody] Clase clase)
{
var usuario = contexto.Clientes.FirstOrDefault(x => x.Email == User.Identity.Name);
var asistenciaTotal = contexto.Horarios.Include(x => x.Cliente).Include(x => x.Clase).Where(x => x.Cliente.Email == usuario.Email && x.Clase.ClaseId == clase.ClaseId).Count();
return(Ok(asistenciaTotal));
}
public static List <Clase> Listar()
{
List <Clase> retorno = null;
using (SqlConnection Connection = new SqlConnection(Conectar.Instancia.CadenaConexion()))
{
string query = "SELECT Id,Nombre, Descripcion FROM Clase";
SqlCommand Comando = new SqlCommand(query, Connection);
Connection.Open();
SqlDataReader reader = Comando.ExecuteReader();
while (reader.Read())
{
if (retorno == null)
{
retorno = new List <Clase>();
}
Clase c = new Clase();
c.Id = (int)reader["Id"];
c.Nombre = reader["Nombre"].ToString();
c.Descripcion = reader["Descripcion"].ToString();
retorno.Add(c);
}
}
return(retorno);
}
public List <Clase> ObtenerClasesDeUnCiclo(string periodo)
{
List <Clase> listaDeClases = new List <Clase>();
Clase clase = null;
string consultaSQL = "select c.cla_codigo, cur.cur_nombre, p.per_nombre, p.per_apellido_pat, p.per_apellido_mat,h.hor_dia, h.hor_inicio, h.hor_fin from Clase c " +
"inner join Horario h on c.hor_id = h.hor_id " +
"inner join Curso cur on c.cur_id = cur.cur_id " +
"inner join Docente d on c.doc_dni = d.per_dni " +
"inner join Persona p on d.per_dni = p.per_dni " +
"inner join Ciclo_Academico ca on c.cic_id = ca.cic_id " +
"where ca.cic_periodo = '" + periodo + "' ";
try
{
SqlDataReader resultadoSQL = gestorSQL.EjecutarConsulta(consultaSQL);
while (resultadoSQL.Read())
{
clase = ObtenerClase(resultadoSQL);
listaDeClases.Add(clase);
}
}
catch (Exception err)
{
throw err;
}
return(listaDeClases);
}
public async Task <IHttpActionResult> PostClase(Clase clase)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Clases.Add(clase);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (ClaseExists(clase.Codigo))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtRoute("DefaultApi", new { id = clase.Codigo }, clase));
}
public static InfanteAuxResponse Get(this InfanteAux request, Factory factory, IHttpRequest httpRequest)
{
var clase=new Clase();
var claseResponse= clase.Get(factory,httpRequest);
var curso= new Curso();
var cursoResponse= curso.Get(factory,httpRequest);
return new InfanteAuxResponse{
ClaseList= claseResponse.Data,
CursoList= cursoResponse.Data
};
}
