Example #1
0
        public override void MapearADatos()
        {
            switch (this.Modo)
            {
            case Modoform.Alta:
                Business.Entities.DocenteCurso docentecurso = new Business.Entities.DocenteCurso();
                this.DocenteCursoActual       = docentecurso;
                this.DocenteCursoActual.State = BusinessEntity.States.New;
                break;

            case Modoform.Modificacion:
                this.DocenteCursoActual.State = BusinessEntity.States.Modified;
                break;

            case Modoform.Baja:
                this.DocenteCursoActual.State = BusinessEntity.States.Deleted;
                break;
            }

            if (this.Modo == Modoform.Alta || Modo == Modoform.Modificacion)
            {
                DocenteCursoActual.Cargo = (DocenteCurso.TiposCargos)Enum.Parse(typeof(DocenteCurso.TiposCargos), this.cboCargos.SelectedValue.ToString());

                DocenteCursoActual.Docente = new Persona();
                int itemSeleccionadoDocente = cboDocente.SelectedIndex;
                DocenteCursoActual.Docente.ID = this.listaDocentes[itemSeleccionadoDocente].ID;
                DocenteCursoActual.Curso      = new Business.Entities.Curso();
                int itemSeleccionadoCurso = cboCurso.SelectedIndex;
                DocenteCursoActual.Curso.ID = this.listaCursos[itemSeleccionadoCurso].ID;
            }
        }
 public override void MapearADatos()
 {
     if (ModoFormulario == ModoForm.Alta)
     {
         DocenteCurso DC = new DocenteCurso();
         DocenteCursoActual = DC;
     }
     if (ModoFormulario == ModoForm.Alta || ModoFormulario == ModoForm.Modificacion)
     {
         DocenteCursoActual.IDCurso = Convert.ToInt32(this.cbCurso.SelectedValue);
         DocenteCursoActual.IDDocente = Convert.ToInt32(this.cbDocente.SelectedValue);
         if(this.rbTitular.Checked)
             DocenteCursoActual.Cargo = DocenteCurso.TiposCargos.Profesor;
         else if(this.rbAuxiliar.Checked)
             DocenteCursoActual.Cargo = DocenteCurso.TiposCargos.Auxiliar;
     }
     if (ModoFormulario == ModoForm.Alta)
         DocenteCursoActual.State = BusinessEntity.States.New;
     if (ModoFormulario == ModoForm.Modificacion)
     {
         DocenteCursoActual.ID.ToString(this.txtId.Text);
         DocenteCursoActual.State = BusinessEntity.States.Modified;
     }
     if (ModoFormulario == ModoForm.Baja)
         DocenteCursoActual.State = BusinessEntity.States.Deleted;
 }
Example #3
0
        protected void BotonAceptar_Click(object sender, EventArgs e)
        {
            switch (FormMode)
            {
            case FormModes.Alta:
                Entity = new Business.Entities.DocenteCurso();
                MapearAEntidad(Entity);
                Guardar(Entity, BusinessEntity.States.New, null);
                LoadGrid();
                break;

            case FormModes.Baja:
                Entity = new Business.Entities.DocenteCurso();
                Guardar(Entity, BusinessEntity.States.Deleted, SelectedID);
                LoadGrid();
                break;

            case FormModes.Modificacion:
                Entity = new Business.Entities.DocenteCurso();
                MapearAEntidad(Entity);
                Guardar(Entity, BusinessEntity.States.Modified, SelectedID);
                LoadGrid();
                break;

            default:
                break;
            }
            GridViewDocentesCursos.SelectedIndex = -1;
            GridViewDocentesCursos.Enabled       = true;
            PanelBotonesGrilla.Visible           = true;
            PanelABM.Visible      = false;
            PanelAcciones.Visible = false;
        }
Example #4
0
        public override void MapearADatos()
        {
            switch (this.Modo)
            {
            case ModoForm.Alta:
                //InscripcionActual = new Business.Entities.AlumnoInscripcion();

                DocenteCursoActual           = new Business.Entities.DocenteCurso();
                DocenteCursoActual.IDDocente = Int32.Parse(this.boxDocente.SelectedValue.ToString());
                DocenteCursoActual.IDCurso   = Int32.Parse(this.boxCurso.SelectedValue.ToString());
                DocenteCursoActual.Cargo     = (DocenteCurso.TiposCargos)Enum.Parse(typeof(DocenteCurso.TiposCargos), this.txtCargo.Text.ToString());

                DocenteCursoActual.State = BusinessEntity.States.New;
                //InscripcionActual.State = BusinessEntity.States.New;
                break;

            case ModoForm.Modificacion:
                InscripcionActual.IDAlumno  = Int32.Parse(this.boxAlumno.SelectedValue.ToString());
                InscripcionActual.Condicion = this.txtCondicion.Text;
                InscripcionActual.Nota      = Int32.Parse(this.txtNota.Text);
                InscripcionActual.IDCurso   = Int32.Parse(this.boxCurso.SelectedValue.ToString());

                DocenteCursoActual.IDDocente = Int32.Parse(this.boxDocente.SelectedValue.ToString());
                DocenteCursoActual.IDCurso   = Int32.Parse(this.boxCurso.SelectedValue.ToString());
                DocenteCursoActual.Cargo     = (DocenteCurso.TiposCargos)Enum.Parse(typeof(DocenteCurso.TiposCargos), this.txtCargo.Text.ToString());

                DocenteCursoActual.State = BusinessEntity.States.Modified;
                InscripcionActual.State  = BusinessEntity.States.Modified;
                break;
            }
        }
 public DocenteCursoDesktop(ModoForm modo, Curso c)
     : this()
 {
     this._Modo = modo;
     _CursoActual = c;
     _DocenteCursoActual = new DocenteCurso();
 }
Example #6
0
        public DocenteCursoDesktop(int ID, Modoform modo) : this()
        {
            this.Modo = modo;
            DocentesCursosLogic docentecursoLogic = new DocentesCursosLogic();

            this.DocenteCursoActual = docentecursoLogic.GetOneD(ID);
            this.MapearDeDatos();
        }
Example #7
0
        public DocentesCursosDesktop(int id, ModoForm modo) : this()
        {
            this.Modo = modo;
            DocenteCurso docenteCurso = new DocenteCursoLogic().GetOne(id);

            this.DocenteCursoActual = docenteCurso;
            this.MapearDeDatos();
        }
 private void btnInscribir_Click(object sender, EventArgs e)
 {
     DocenteCursoLogic dcl = new DocenteCursoLogic();
     DocenteCurso dc=new DocenteCurso();
     dc.IDCurso=idCurso;
     dc.Cargo = (DocenteCurso.TiposCargos)cmbCargo.SelectedValue;
     dc.IDDocente=UsuarioSesion.Sesion.ID;
     dcl.AgregarDocenteACurso(dc);
     Notificar("Registro a curso generado correctamente", MessageBoxButtons.OK, MessageBoxIcon.Information);
     this.Dispose();
 }
        public DocentesCursos GetAll()
        {
            SqlConnection oCnn = this.CreateConnection();
            using (oCnn)
            {
                oCnn.Open();

                SqlCommand oCmd = new SqlCommand();
                using (oCmd)
                {
                    oCmd.Connection = oCnn;

                    oCmd.CommandType = CommandType.StoredProcedure;
                    oCmd.CommandText = "docentesCursosGetAll";

                    DocentesCursos oDocentes_Cursos = new DocentesCursos();

                    try
                    {
                        SqlDataReader oReader = oCmd.ExecuteReader();
                        using (oCnn)
                        {
                            while (oReader.Read())
                            {
                                DocenteCurso oDocente_Curso = new DocenteCurso();

                                oDocente_Curso.ID = Convert.ToInt32(oReader["id_dictado"]);
                                oDocente_Curso.IDCurso = Convert.ToInt32(oReader["id_curso"]);
                                oDocente_Curso.IDDocente = Convert.ToInt32(oReader["id_docente"]);
                                oDocente_Curso.Cargo = (DocenteCurso.TiposCargos)Convert.ToInt32(oReader["cargo"]);

                                oDocentes_Cursos.Add(oDocente_Curso);
                                oDocente_Curso = null;
                            }
                            return oDocentes_Cursos;
                        }
                    }
                    catch (Exception Ex)
                    {
                        Exception ExcepcionManejada =
                        new Exception("Error al recuperar lista de Docentes_Cursos", Ex);
                        throw ExcepcionManejada;
                    }
                    finally
                    {
                        oDocentes_Cursos = null;
                    }
                }
            }
        }
 public DocenteCursoDesktop(int ID, ModoForm modo, Curso c)
     : this()
 {
     this._Modo = modo;
     try
     {
         _CursoActual = c;
         DocenteCursoLogic DocCursNegocio = new DocenteCursoLogic();
         _DocenteCursoActual = DocCursNegocio.GetOne(ID);
         this.MapearDeDatos();
     }
     catch (Exception ex)
     {
         this.Notificar("Error", ex.Message, MessageBoxButtons.OK, MessageBoxIcon.Error);
     }
 }
Example #11
0
        public new void MapearADatos()
        {
            if (this.Modo == ModoForm.Alta)
            {
                DocenteCurso docenteCurso = new DocenteCurso();
                DocenteCursoActual = docenteCurso;


                this.DocenteCursoActual.IdCurso   = Convert.ToInt32(this.textBoxIdCurso.Text);
                this.DocenteCursoActual.IdDocente = Convert.ToInt32(this.textBoxIdDocente.Text);
                this.DocenteCursoActual.Cargo     = (DocenteCurso.TiposCargos)(int) comboBoxCargo.SelectedValue;
            }
            else if (this.Modo == ModoForm.Modificacion)
            {
                this.DocenteCursoActual.IdCurso   = Convert.ToInt32(this.textBoxIdCurso.Text);
                this.DocenteCursoActual.IdDocente = Convert.ToInt32(this.textBoxIdDocente.Text);
                this.DocenteCursoActual.Cargo     = (DocenteCurso.TiposCargos)(int) comboBoxCargo.SelectedValue;
            }

            switch (this.Modo)
            {
            case ModoForm.Alta:
            {
                this.DocenteCursoActual.State = BusinessEntity.States.New;
                break;
            }

            case ModoForm.Modificacion:
            {
                this.DocenteCursoActual.State = BusinessEntity.States.Modified;
                break;
            }

            case ModoForm.Baja:
            {
                this.DocenteCursoActual.State = BusinessEntity.States.Deleted;
                break;
            }

            case ModoForm.Consulta:
            {
                this.DocenteCursoActual.State = BusinessEntity.States.Unmodified;
                break;
            }
            }
        }
        public void Insert(DocenteCurso docente_curso)
        {
            //Creamos la conexiĆ³n a utilizar.
            SqlConnection oCnn = this.CreateConnection();
            using (oCnn)
            {
                try
                {
                    //abrimos conexion
                    oCnn.Open();

                    //Creamos un commando para realizar el alta en la base de datos
                    SqlCommand oCmd = new SqlCommand();
                    using (oCmd)
                    {
                        //asignamos la conexion que habiamos creado
                        oCmd.Connection = oCnn;

                        //Indicamos que stored procedure vamos a usar
                        oCmd.CommandType = CommandType.StoredProcedure;
                        oCmd.CommandText = "docentesCursosAdd";

                        //le asignamos los parƔmetros para el stored procedure
                        oCmd.Parameters.AddWithValue("@id_curso", docente_curso.IDCurso);
                        oCmd.Parameters.AddWithValue("@id_docente", docente_curso.IDDocente);
                        oCmd.Parameters.AddWithValue("@cargo", docente_curso.Cargo);
                        docente_curso.ID = Decimal.ToInt32((decimal)oCmd.ExecuteScalar());
                    }
                }
                catch (Exception Ex)
                {
                    Exception ExcepcionManejada = new Exception("Error al crear Docente_Curso", Ex);
                    throw ExcepcionManejada;
                }
            }
        }
 public void Save(DocenteCurso dc)
 {
     _DocenteCursoData.Save(dc);
 }
 private void SaveEntity(DocenteCurso docCurso)
 {
     try
     {
         this.Logic.Save(docCurso);
     }
     catch (Exception ex)
     {
         Response.Write("<script>window.alert('" + ex.Message + "');</script>");
     }
 }
 private void LoadEntity(DocenteCurso docCurso)
 {
     docCurso.Cargo = this.ddlCargo.SelectedValue;
     if (this.FormMode == FormModes.Alta)
     {
         docCurso.Curso.ID = this.SelectedIDCurso;
         docCurso.Docente.ID = this.SelectedIDDocente;
     }
 }
 public List<DocenteCurso> GetAll()
 {
     List<DocenteCurso> docentes = new List<DocenteCurso>();
     try
     {
         this.OpenConnection();
         SqlCommand cmdGetAll = new SqlCommand("GetAll_DocentesCursos", SqlConn);
         cmdGetAll.CommandType = CommandType.StoredProcedure;
         SqlDataReader drDocentes = cmdGetAll.ExecuteReader();
         while (drDocentes.Read())
         {
             DocenteCurso dc = new DocenteCurso();
             dc.ID = (int)drDocentes["id_dictado"];
             switch ((int)drDocentes["cargo"])
             {
                 case 1:
                     dc.Cargo = "Titular";
                     break;
                 case 2:
                     dc.Cargo = "Auxiliar";
                     break;
                 case 3:
                     dc.Cargo = "Ayudante";
                     break;
             }
             dc.Curso.ID = (int)drDocentes["id_curso"];
             dc.Curso.AnioCalendario = (int)drDocentes["anio_calendario"];
             dc.Curso.Cupo = (int)drDocentes["cupo"];
             dc.Docente.ID = (int)drDocentes["id_persona"];
             dc.Docente.Nombre = (string)drDocentes["nombre"];
             dc.Docente.Apellido = (string)drDocentes["apellido"];
             dc.Docente.Email = (string)drDocentes["email"];
             dc.Docente.Direccion = (string)drDocentes["direccion"];
             dc.Docente.Telefono = (string)drDocentes["telefono"];
             dc.Docente.FechaNacimiento = (DateTime)drDocentes["fecha_nac"];
             dc.Docente.Legajo = (int)drDocentes["legajo"];
             switch ((int)drDocentes["tipo_persona"])
             {
                 case 1:
                     dc.Docente.TipoPersona = "No docente";
                     break;
                 case 2:
                     dc.Docente.TipoPersona = "Alumno";
                     break;
                 case 3:
                     dc.Docente.TipoPersona = "Docente";
                     break;
             }
             dc.Docente.Plan.ID = (int)drDocentes["id_plan"];
             docentes.Add(dc);
         }
         drDocentes.Close();
     }
     catch (Exception e)
     {
         Exception ExcepcionManejada = new Exception("Error al recuperar datos de los docentes.", e);
         throw ExcepcionManejada;
     }
     finally
     {
         this.CloseConnection();
     }
     return docentes;
 }
        public DocentesCursos GetAllPorCurso(int id)
        {
            SqlConnection oCnn = this.CreateConnection();
            using (oCnn)
            {
                oCnn.Open();

                SqlCommand oCmd = new SqlCommand();
                using (oCmd)
                {
                    oCmd.Connection = oCnn;

                    oCmd.CommandType = CommandType.StoredProcedure;
                    oCmd.CommandText = "docentesCursosGetAllPorCurso";

                    oCmd.Parameters.AddWithValue("@id_curso", id);

                    //Aunque debemos buscar solo un elemento, siempre devolvemos
                    //una colecciĆ³n. Es mĆ”s fĆ”cil de manipular y controlar
                    DocentesCursos oDocentes_Cursos = new DocentesCursos();

                    //No retornamos DataSets, siempre utilizamos objetos para hacernos
                    //independientes de la estructura de las tablas en el resto
                    //de las capas. Para ellos leemos con el DataReader y creamos
                    //los objetos asociados que se esperan
                    try
                    {
                        //Ejecutamos el comando y retornamos los valores
                        SqlDataReader oReader = oCmd.ExecuteReader();
                        using (oReader)
                        {
                            while (oReader.Read())
                            {
                                //si existe algun valor, creamos el objeto y lo almacenamos en la colecciĆ³n
                                DocenteCurso oDocente_Curso = new DocenteCurso();

                                oDocente_Curso.ID = Convert.ToInt32(oReader["id_dictado"]);
                                oDocente_Curso.IDCurso = Convert.ToInt32(oReader["id_curso"]);
                                oDocente_Curso.IDDocente = Convert.ToInt32(oReader["id_docente"]);
                                oDocente_Curso.Cargo = (DocenteCurso.TiposCargos)Convert.ToInt32(oReader["cargo"]);

                                //Agregamos el objeto a la coleccion de resultados
                                oDocentes_Cursos.Add(oDocente_Curso);

                                oDocente_Curso = null;
                            }
                            //retornamos los valores encontrados
                            return oDocentes_Cursos;
                        }
                    }
                    catch (Exception Ex)
                    {
                        Exception ExcepcionManejada = new Exception("Error al recuperar datos del Docente_Curso", Ex);
                        throw ExcepcionManejada;
                    }
                    finally
                    {
                        //liberamos la memoria utilizada por los objetos
                        oDocentes_Cursos = null;
                    }
                }
            }
        }
        protected void Update(DocenteCurso docenteCurso)
        {
            try
            {
                this.OpenConnection();

                SqlCommand cmdSave = new SqlCommand(
                    "UPDATE docentes_cursos SET id_docente=@id_docente, id_curso=@id_curso, cargo=@cargo" +
                    "WHERE id_dictado=@id", sqlConn);

                cmdSave.Parameters.Add("@id_dictado", SqlDbType.Int).Value = docenteCurso.ID;
                cmdSave.Parameters.Add("@id_docente", SqlDbType.Int).Value = docenteCurso.IDDocente;
                cmdSave.Parameters.Add("@id_curso", SqlDbType.Int).Value = docenteCurso.IDCurso;
                cmdSave.Parameters.Add("@cargo", SqlDbType.VarChar, 50).Value = docenteCurso.TipoCargo;
                cmdSave.ExecuteNonQuery();
            }

            catch (Exception Ex)
            {
                Exception ExcepcionManejeada = new Exception("Error al modificar docentes y cursos", Ex);

                throw ExcepcionManejeada;
            }

            finally
            {
                this.CloseConnection();
            }
        }
 public void Save(DocenteCurso docenteCurso)
 {
     if (docenteCurso.State == BusinessEntity.States.Deleted)
     {
         this.Delete(docenteCurso.ID);
     }
     else if (docenteCurso.State == BusinessEntity.States.New)
     {
         this.Insert(docenteCurso);
     }
     else if (docenteCurso.State == BusinessEntity.States.Modified)
     {
         this.Update(docenteCurso);
     }
     docenteCurso.State = BusinessEntity.States.Unmodified;
 }
 public void Update(DocenteCurso docenteCurso)
 {
     try
     {
         DocenteCursoData.Update(docenteCurso);
     }
     finally
     {
         DocenteCursoData = null;
     }
 }
 public void Insert(DocenteCurso docenteCurso)
 {
     try
     {
         DocenteCursoData.Insert(docenteCurso);
     }
     finally
     {
         DocenteCursoData = null;
     }
 }
Example #22
0
 protected void MapearAEntidad(Business.Entities.DocenteCurso docc)
 {
     docc.IdCurso   = Convert.ToInt32(DropDownListCursos.SelectedValue);
     docc.IdDocente = Convert.ToInt32(DropDownListDocentes.SelectedValue);
     docc.Cargo     = (DocenteCurso.TiposCargos)Convert.ToInt32(DropDownListCargos.SelectedValue);
 }
        public void Update(DocenteCurso docente_curso)
        {
            SqlConnection oCnn = this.CreateConnection();
            using (oCnn)
            {
                try
                {
                    oCnn.Open();

                    SqlCommand oCmd = new SqlCommand();
                    using (oCmd)
                    {
                        oCmd.Connection = oCnn;

                        oCmd.CommandType = CommandType.StoredProcedure;
                        oCmd.CommandText = "docentesCursosUpdate";

                        oCmd.Parameters.AddWithValue("@id_dictado", docente_curso.ID);
                        oCmd.Parameters.AddWithValue("@id_curso", docente_curso.IDCurso);
                        oCmd.Parameters.AddWithValue("@id_docente", docente_curso.IDDocente);
                        oCmd.Parameters.AddWithValue("@cargo", docente_curso.Cargo);

                        oCmd.ExecuteNonQuery();
                    }
                }
                catch (Exception Ex)
                {
                    Exception ExcepcionManejada = new Exception("Error al actualizar datos del Docente_Curso", Ex);
                    throw ExcepcionManejada;
                }
            }
        }
        protected void Insert(DocenteCurso dc)
        {
            try
            {
                this.OpenConnection();
                SqlCommand cmdInsert = new SqlCommand("Insert_DocentesCursos", SqlConn);
                cmdInsert.CommandType = CommandType.StoredProcedure;

                cmdInsert.Parameters.Add("@id_docente", SqlDbType.Int).Value = dc.Docente.ID;
                cmdInsert.Parameters.Add("@id_curso", SqlDbType.Int).Value = dc.Curso.ID;
                switch (dc.Cargo)
                {
                    case "Titular":
                        cmdInsert.Parameters.Add("@cargo", SqlDbType.Int).Value = 1;
                        break;
                    case "Auxiliar":
                        cmdInsert.Parameters.Add("@cargo", SqlDbType.Int).Value = 2;
                        break;
                    case "Ayudante":
                        cmdInsert.Parameters.Add("@cargo", SqlDbType.Int).Value = 3;
                        break;
                }
                dc.ID = Decimal.ToInt32((decimal)cmdInsert.ExecuteScalar());
            }
            catch (Exception e)
            {
                Exception ExcepcionManejada = new Exception("Error al crear un nuevo dictado.", e);
                throw ExcepcionManejada;
            }
            finally
            {
                this.CloseConnection();
            }
        }
        protected void Update(DocenteCurso dc)
        {
            try
            {
                this.OpenConnection();
                SqlCommand cmdUpdate = new SqlCommand("Update_DocentesCursos", SqlConn);
                cmdUpdate.CommandType = CommandType.StoredProcedure;

                cmdUpdate.Parameters.Add("@id", SqlDbType.Int).Value = dc.ID;
                cmdUpdate.Parameters.Add("@id_docente", SqlDbType.Int).Value = dc.Docente.ID;
                cmdUpdate.Parameters.Add("@id_curso", SqlDbType.Int).Value = dc.Curso.ID;
                switch (dc.Cargo)
                {
                    case "Titular":
                        cmdUpdate.Parameters.Add("@cargo", SqlDbType.Int).Value = 1;
                        break;
                    case "Auxiliar":
                        cmdUpdate.Parameters.Add("@cargo", SqlDbType.Int).Value = 2;
                        break;
                    case "Ayudante":
                        cmdUpdate.Parameters.Add("@cargo", SqlDbType.Int).Value = 3;
                        break;
                }
                cmdUpdate.ExecuteNonQuery();
            }
            catch (Exception e)
            {
                Exception ExcepcionManejada = new Exception("Error al modificar datos del dictado.", e);
                throw ExcepcionManejada;
            }
            finally
            {
                this.CloseConnection();
            }
        }
        public DocenteCurso GetOne(int ID)
        {
            DocenteCurso dc = new DocenteCurso();

            try
            {
                this.OpenConnection();

                SqlCommand cmdDocenteCurso = new SqlCommand("SELECT * from docentes_cursos where id_dictado=@id", sqlConn);

                cmdDocenteCurso.Parameters.Add("@id", SqlDbType.Int).Value = ID;

                SqlDataReader drDocenteCurso = cmdDocenteCurso.ExecuteReader();

                if (drDocenteCurso.Read())
                {
                    dc.IDCurso = (int)drDocenteCurso["id_curso"];
                    dc.IDDocente = (int)drDocenteCurso["id_docente"];
                    dc.TipoCargo = (int)drDocenteCurso["cargo"];
                    dc.ID = (int)drDocenteCurso["id_dictado"];
                }

                drDocenteCurso.Close();
            }

            catch (Exception Ex)
            {
                Exception ExcepcionManejada = new Exception("Error al recuperar datos de los cursos y docentes", Ex);

                throw ExcepcionManejada;
            }

            finally
            {
                this.CloseConnection();
            }

            return dc;
        }
Example #27
0
 public void Save( DocenteCurso DocenteCurso)
 {
     DocenteCursoData.Save(DocenteCurso);
 }
        protected void Insert(DocenteCurso docenteCurso)
        {
            try
            {
                this.OpenConnection();

                SqlCommand cmdSave = new SqlCommand(
                    "insert into docentes_cursos (id_docente, id_curso, cargo)" +
                    "values (@id_docente,@id_curso,@cargo)" +
                    "select @@identity", sqlConn);

                cmdSave.Parameters.Add("@id_docente", SqlDbType.Int).Value = docenteCurso.IDDocente;
                cmdSave.Parameters.Add("@id_curso", SqlDbType.Int).Value = docenteCurso.IDCurso;
                cmdSave.Parameters.Add("@cargo", SqlDbType.Int).Value = docenteCurso.TipoCargo;
                docenteCurso.ID = Decimal.ToInt32((decimal)cmdSave.ExecuteScalar());
            }

            catch (Exception Ex)
            {
                Exception ExcepcionManejeada = new Exception("Error al crear curso y docente", Ex);

                throw ExcepcionManejeada;
            }

            finally
            {
                this.CloseConnection();
            }
        }
Example #29
0
 public void Save(Business.Entities.DocenteCurso doc)
 {
     DocenteData.Save(doc);
 }
        public List<DocenteCurso> GetAll()
        {
            //instanciamos el objeto lista a retornar

            List<DocenteCurso> docentecurso = new List<DocenteCurso>();

            try
            {
                this.OpenConnection();

                /*creo el obje sqlcommand que sera la sentencia SQl que vamos a ejecutar
                  contra la BD. (los datos de la bd: usario, contraseƱa, etc estan en connection
                  string.*/

                SqlCommand cmdDocenteCurso = new SqlCommand("select * from docentes_cursos", sqlConn);

                //instancio un obj datareader que va a ser el que recupere los datos de la BD

                SqlDataReader drDocenteCurso = cmdDocenteCurso.ExecuteReader();

                /*read() lee una fila de las devueltas por el comando sql, carga los datos
                  en drUsurios para pdoer accederlos, devuelve erdadero meintras haya podido
                  leer datos y avanza a la fila siguiente para el proximo read.*/

                while (drDocenteCurso.Read())
                {
                    /*creo un obj usuario de la capa de entidades para copiar los datos
                      de la fila del datareader al objeto de entidades.*/

                    DocenteCurso dc = new DocenteCurso();

                    //copio los datos de la fila al obj

                    dc.IDCurso = (int)drDocenteCurso["id_curso"];
                    dc.IDDocente = (int)drDocenteCurso["id_docente"];
                    dc.TipoCargo = (int)drDocenteCurso["cargo"];
                    dc.ID = (int)drDocenteCurso["id_dictado"];

                    //agrego el objeto con datos a la lista que devuelvo

                    docentecurso.Add(dc);
                }

                //cerramos el datareader y la conexion a la BD

                drDocenteCurso.Close();

            }

            catch (Exception Ex)
            {
                Exception ExcepcionManejada = new Exception("Error al recuperar lista de cursos y docentes", Ex);

                throw ExcepcionManejada;
            }

            finally
            {
                this.CloseConnection();
            }

            return docentecurso;
        }
        public DocenteCurso GetOne(int ID)
        {
            DocenteCurso dc = new DocenteCurso();
            try
            {
                this.OpenConnection();
                SqlCommand cmdGetOne = new SqlCommand("GetOne_DocentesCursos", SqlConn);
                cmdGetOne.CommandType = CommandType.StoredProcedure;
                cmdGetOne.Parameters.Add("@id", SqlDbType.Int).Value = ID;
                SqlDataReader drDocentes = cmdGetOne.ExecuteReader();
                if (drDocentes.Read())
                {
                    dc.ID = (int)drDocentes["id_dictado"];
                    switch ((int)drDocentes["cargo"])
                    {
                        case 1:
                            dc.Cargo = "Titular";
                            break;
                        case 2:
                            dc.Cargo = "Auxiliar";
                            break;
                        case 3:
                            dc.Cargo = "Ayudante";
                            break;
                    }
                    dc.Curso.ID = (int)drDocentes["id_curso"];
                    dc.Docente.ID = (int)drDocentes["id_persona"];
                    dc.Docente.Nombre = (string)drDocentes["nombre"];
                    dc.Docente.Apellido = (string)drDocentes["apellido"];
                    dc.Docente.Email = (string)drDocentes["email"];
                    dc.Docente.Direccion = (string)drDocentes["direccion"];
                    dc.Docente.Telefono = (string)drDocentes["telefono"];
                    dc.Docente.FechaNacimiento = (DateTime)drDocentes["fecha_nac"];
                    dc.Docente.Legajo = (int)drDocentes["legajo"];
                    switch ((int)drDocentes["tipo_persona"])
                    {
                        case 1:
                            dc.Docente.TipoPersona = "No docente";
                            break;
                        case 2:
                            dc.Docente.TipoPersona = "Alumno";
                            break;
                        case 3:
                            dc.Docente.TipoPersona = "Docente";
                            break;
                    }
                    dc.Docente.Plan.ID = (int)drDocentes["id_plan"];
                }

                drDocentes.Close();
            }
            catch (Exception e)
            {
                Exception ExcepcionManejada = new Exception("Error al recuperar datos del Docente.", e);
                throw ExcepcionManejada;
            }
            finally
            {
                this.CloseConnection();
            }
            return dc;
        }