/// <summary>
        /// Update statuss Process ServicioImportacion table.
        /// </summary>
        public void DeactivateImportProcess(ServicioImportacion service)
        {
            ValidationUtility.ValidateArgument("service", service);

            SqlParameter[] parameters = new SqlParameter[]
            {
                new SqlParameter("@IdImportacion", service.IdImportacion),
            };
            SqlClientUtility.ExecuteNonQuery(connectionStringName, CommandType.StoredProcedure, "ServicioBajaImportacion", parameters);
        }
 /// <summary>
 /// Method to get all process with errors.
 /// </summary>
 public static List<ServicioImportacion> GetErrorProcess(ServicioImportacion importacion)
 {
     try
     {
         ServicioImportacionDAO errorProcessDAO = new ServicioImportacionDAO(connectionString);
         return errorProcessDAO.GetErrorProcess(importacion.IdTipoImportacion, importacion.IdTipoInscripcion, importacion.TurnoInscripcion, importacion.IdVuelta);
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
 /// <summary>
 /// Method to update statuss process.
 /// </summary>
 public static void DeactivateImportProcess(ServicioImportacion service)
 {
     try
     {
         ServicioImportacionDAO process = new ServicioImportacionDAO(connectionString);
         process.DeactivateImportProcess(service);
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Пример #4
0
 /// <summary>
 /// Method to fill grid
 /// </summary>
 /// <param name="option">Option to select wich grid fill (1: GridActiveProcess/ 2:GridLogProcess)</param>
 private void FillGrid(int option)
 {
     try
     {
         switch (option)
         {
             case 1:
                 gridActiveProcess.DataSource = ServicioImportacionDTO.GetActiveProcess();
                 gridActiveProcess.Columns[9].Visible = true;
                 gridActiveProcess.Columns[10].Visible = true;
                 gridActiveProcess.DataBind();
                 gridActiveProcess.Columns[9].Visible = false;
                 gridActiveProcess.Columns[10].Visible = false;
                 break;
             default:
                 importacion = new ServicioImportacion();
                 importacion.IdTipoImportacion = cboTipoImportacionError.Items.Count > 0 ?
                     cboTipoImportacionError.SelectedIndex != 0 ? cboTipoImportacionError.SelectedValue : null : null;
                 importacion.IdTipoInscripcion = cboTipoInscripcionError.Items.Count > 0 ?
                     cboTipoInscripcionError.SelectedIndex != 0 ? cboTipoInscripcionError.SelectedValue : null : null;
                 importacion.TurnoInscripcion = cboTurnoInscripcionError.Items.Count > 0 ?
                     cboTurnoInscripcionError.SelectedIndex != 0 ? Convert.ToDateTime(cboTurnoInscripcionError.SelectedValue) : (DateTime)SqlDateTime.Null : (DateTime)SqlDateTime.Null;
                 importacion.IdVuelta = cboVueltaInscripcionError.Items.Count > 0 ?
                     cboVueltaInscripcionError.SelectedIndex != 0 ? Convert.ToInt32(cboVueltaInscripcionError.SelectedValue) : 0 : 0;
                 gridLogProcess.DataSource = ServicioImportacionDTO.GetErrorProcess(importacion);
                 gridLogProcess.DataBind();
                 break;
         }
     }
     catch (Exception ex)
     {
         LogWriter log = new LogWriter();
         log.WriteLog(ex.Message, "FillGrid", Path.GetFileName(Request.PhysicalPath));
         throw ex;
     }
 }
Пример #5
0
 /// <summary>
 /// Method to deactivate specific process import
 /// </summary>
 /// <param name="id">Process Id</param>
 private void DeactivateProcess(int id)
 {
     try
     {
         ServicioImportacion proceso = new ServicioImportacion();
         proceso.IdImportacion = id;
         ServicioImportacionDTO.DeactivateImportProcess(proceso);
         FillGrid(1);
     }
     catch (Exception ex)
     {
         LogWriter log = new LogWriter();
         log.WriteLog(ex.Message, "DeactivateProcess", Path.GetFileName(Request.PhysicalPath));
         throw ex;
     }
 }
Пример #6
0
 /// <summary>
 /// Event to execute query by filtered combos
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 protected void cboVueltaInscripcionError_SelectedIndexChanged(object sender, EventArgs e)
 {
     try
     {
         if (cboVueltaInscripcionError.SelectedIndex != 0)
         {
             importacion = new ServicioImportacion();
             importacion.IdTipoImportacion = cboTipoImportacionError.SelectedValue;
             importacion.IdTipoInscripcion = cboTipoInscripcionError.SelectedValue;
             importacion.TurnoInscripcion = Convert.ToDateTime(cboTurnoInscripcionError.SelectedValue);
             importacion.IdVuelta = Convert.ToInt32(cboVueltaInscripcionError.SelectedValue);
             gridLogProcess.DataSource = ServicioImportacionDTO.GetErrorProcess(importacion);
             gridLogProcess.DataBind();
             //ShowGridLogProcess(true);
         }
     }
     catch (Exception ex)
     {
         LogWriter log = new LogWriter();
         log.WriteLog(ex.Message, "cboVueltaInscripcionError_SelectedIndexChanged", Path.GetFileName(Request.PhysicalPath));
         throw ex;
     }
 }
Пример #7
0
        /// <summary>
        /// Event to enable TurnoInscripcion combo
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void cboTurnoInscripcionError_SelectedIndexChanged(object sender, EventArgs e)
        {
            try
            {
                if (cboVueltaInscripcionError.Enabled)
                {
                    cboVueltaInscripcionError.Enabled = false;
                }

                if (cboTurnoInscripcionError.SelectedIndex != 0)
                {
                    importacion = new ServicioImportacion();
                    importacion.IdTipoImportacion = cboTipoImportacionError.SelectedValue;
                    importacion.IdTipoInscripcion = cboTipoInscripcionError.SelectedValue;
                    importacion.TurnoInscripcion = Convert.ToDateTime(cboTurnoInscripcionError.SelectedValue);
                    cboVueltaInscripcionError.DataSource = ServicioImportacionDTO.GetServicioVueltaInscripcionError(importacion);

                    if (cboVueltaInscripcionError.DataSource != null)
                    {
                        cboVueltaInscripcionError.Enabled = true;
                        cboVueltaInscripcionError.DataBind();
                        cboVueltaInscripcionError.Items.Insert(0, new ListItem(ConfigurationManager.AppSettings["ContentComboVueltaDefault"], "0"));

                        cboVueltaInscripcionError.SelectedIndex = 0;
                        //ShowGridLogProcess(false);
                    }
                }
            }
            catch (Exception ex)
            {
                LogWriter log = new LogWriter();
                log.WriteLog(ex.Message, "cboTurnoInscripcionError_SelectedIndexChanged", Path.GetFileName(Request.PhysicalPath));
                throw ex;
            }
        }
 /// <summary>
 /// Method to insert new process register.
 /// </summary>
 public static bool ValidatePredecessor(ServicioImportacion service)
 {
     try
     {
         ServicioImportacionDAO importService = new ServicioImportacionDAO(connectionString);
         return importService.ValidatePredecessor(service);
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
        /// <summary>
        /// Validate the predecessor steps
        /// </summary>
        public bool ValidatePredecessor(ServicioImportacion service)
        {
            ValidationUtility.ValidateArgument("service", service);

            SqlParameter[] parameters = new SqlParameter[]
            {
                new SqlParameter("@IdTipoImportacion", service.IdTipoImportacion),
                new SqlParameter("@IdTipoInscripcion", service.IdTipoInscripcion),
                new SqlParameter("@TurnoInscripcion", service.TurnoInscripcion),
                new SqlParameter("@IdVuelta", service.IdVuelta),
            };
            var validation = Convert.ToBoolean(SqlClientUtility.ExecuteScalar(connectionStringName, CommandType.StoredProcedure, "ServicioValidatePredecessor", parameters));
            SqlConnection.ClearAllPools();
            return validation;
        }
 /// <summary>
 /// Method to insert new process register.
 /// </summary>
 public static void InsertNuevoServicio(ServicioImportacion service)
 {
     try
     {
         ServicioImportacionDAO importService = new ServicioImportacionDAO(connectionString);
         importService.InsertServicio(service);
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
 /// <summary>
 /// Method to get all VueltaTurnos types.
 /// </summary>
 public static List<TipoVuelta> GetServicioVueltaInscripcionError(ServicioImportacion importacion)
 {
     try
     {
         ServicioImportacionDAO tipoVueltaDAO = new ServicioImportacionDAO(connectionString);
         return tipoVueltaDAO.GetServicioVueltaInscripcionError(importacion.IdTipoImportacion, importacion.IdTipoInscripcion, importacion.TurnoInscripcion);
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
        /// <summary>
        /// Creates a new instance of the ServicioImportacion class and populates it with data from the specified SqlDataReader.
        /// </summary>
        private ServicioImportacion MapDataReaderTipoImportacion(SqlDataReader dataReader)
        {
            ServicioImportacion tipoImportacion = new ServicioImportacion();
            tipoImportacion.IdTipoImportacion = dataReader.GetString("IdTipoImportacion", String.Empty);
            tipoImportacion.Descripcion = dataReader.GetString("Descripcion", String.Empty);

            return tipoImportacion;
        }
        /// <summary>
        /// Creates a new instance of the ServicioImportacion class and populates it with data from the specified SqlDataReader.
        /// </summary>
        private ServicioImportacion MapDataReaderErrorProcess(SqlDataReader dataReader)
        {
            ServicioImportacion process = new ServicioImportacion();
            process.IdImportacion = dataReader.GetInt32("IdImportacion", 0);
            process.LogError = dataReader.GetString("LogError", String.Empty);

            return process;
        }
        /// <summary>
        /// Creates a new instance of the ServicioImportacion class and populates it with data from the specified SqlDataReader.
        /// </summary>
        private ServicioImportacion MapDataReaderActiveProcess(SqlDataReader dataReader)
        {
            ServicioImportacion process = new ServicioImportacion();
            process.ArchivoImportacion = dataReader.GetString("ArchivoImportacion", String.Empty);
            process.FechaAlta = dataReader.GetDateTime("FechaAlta", new DateTime(0));
            process.FechaProgramadaImportacion = dataReader.GetDateTime("FechaProgramadaImportacion", new DateTime(0));
            process.IdImportacion = dataReader.GetInt32("IdImportacion", 0);
            process.IdVuelta = dataReader.GetInt32("IdVuelta", 0);
            process.ProcesoActivo = dataReader.GetBoolean("ProcesoActivo", false);
            process.Descripcion = dataReader.GetString("TipoImportacionDescripcion", String.Empty);
            process.TurnoInscripcion = dataReader.GetDateTime("TurnoInscripcion", new DateTime(0));
            process.UsuarioImportador = dataReader.GetInt32("UsuarioImportador", 0);
            process.IdTipoInscripcion = dataReader.GetString("IdTipoInscripcion", String.Empty);
            process.LogError = dataReader.GetString("LogError", String.Empty);

            return process;
        }
Пример #15
0
        /// <summary>
        /// Method to save the process instance
        /// </summary>
        private void Save()
        {
            try
            {
                if (asyncFile.HasFile)
                {
                    if (asyncFile.ContentType.ToLower() == ("text/plain"))
                    {
                        importacion = new ServicioImportacion();

                        importacion.ArchivoImportacion = asyncFile.FileName;
                        importacion.FechaAlta = DateTime.Now;
                        importacion.ProcesoActivo = true;
                        importacion.IdTipoImportacion = cboTipoImportacion.SelectedValue;
                        importacion.FechaImportacion = DateTime.Now;
                        importacion.UsuarioImportador = ((Usuario)Session["userEmployee"]).DNI;
                        importacion.FechaProgramadaImportacion = Convert.ToDateTime(DateTime.Parse(txtFechaProgramada.Text).ToString("yyyy-MM-dd HH:mm:ss"));
                        importacion.ClaseFormato = SetClaseFormato(importacion.IdTipoImportacion);

                        if (importacion.IdTipoImportacion != PadronAalumnos && importacion.IdTipoImportacion != PadronCalificaciones)
                        {
                            importacion.IdTipoInscripcion = cboTipoInscripcion.SelectedValue;
                            importacion.TurnoInscripcion = Convert.ToDateTime(cboTurnoInscripcion.SelectedValue);
                            importacion.IdVuelta = Convert.ToInt32(cboVueltaInscripcion.SelectedValue);
                        }
                        else
                            importacion.TurnoInscripcion = (DateTime)SqlDateTime.Null;

                        if (ServicioImportacionDTO.ValidatePredecessor(importacion))
                        {
                            if (ServicioImportacionDTO.ValidateInscriptionOnCourse(importacion))
                            {
                                SetProcess(importacion);
                                FillGrid(1);
                            }
                            else
                            {
                                lblMessagePopUp.Text = ConfigurationManager.AppSettings["MessageWarningActiveInscription"];
                                mpeMessage.Show();
                            }
                        }
                        else
                        {
                            lblMessagePopUp.Text = ConfigurationManager.AppSettings["MessageProcessInvalidPredecessor"];
                            mpeMessage.Show();
                        }
                    }
                    else
                    {
                        lblMessagePopUp.Text = ConfigurationManager.AppSettings["MessageProcessInvalidFileFormat"];
                        mpeMessage.Show();
                    }
                }
                else
                {
                    lblMessagePopUp.Text = ConfigurationManager.AppSettings["MessageProcessNotFile"];
                    mpeMessage.Show();
                }
            }
            catch (Exception ex)
            {
                LogWriter log = new LogWriter();
                log.WriteLog(ex.Message, "Save", Path.GetFileName(Request.PhysicalPath));
                throw ex;
            }
        }
 /// <summary>
 /// Method to validate if there inscriptions on course
 /// </summary>
 public static bool ValidateInscriptionOnCourse(ServicioImportacion service)
 {
     try
     {
         ServicioImportacionDAO importService = new ServicioImportacionDAO(connectionString);
         return importService.ValidateInscriptionOnCourse(service);
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Пример #17
0
        /// <summary>
        /// Method to set a new process instance
        /// </summary>
        private void SetProcess(ServicioImportacion importacion)
        {
            try
            {
                ServicioImportacionDTO.InsertNuevoServicio(importacion);

                lblMessagePopUp.Text = ConfigurationManager.AppSettings["MessageProcessOk"];
                mpeMessage.Show();
                LimpiarFormulario();
            }
            catch (Exception ex)
            {
                LogWriter log = new LogWriter();
                log.WriteLog(ex.Message, "SetProcess", Path.GetFileName(Request.PhysicalPath));

                asyncFile.BackColor = Color.FromArgb(255, 173, 173);
                lblMessagePopUp.Text = ConfigurationManager.AppSettings["MessageProcessError"];
                mpeMessage.Show();
                LimpiarFormulario();
            }
        }
        /// <summary>
        /// Saves a record to the ServicioImportacion table.
        /// </summary>
        public int InsertServicio(ServicioImportacion service)
        {
            ValidationUtility.ValidateArgument("service", service);

            SqlParameter[] parameters = new SqlParameter[]
            {
                new SqlParameter("@ProcesoActivo", service.ProcesoActivo),
                new SqlParameter("@ArchivoImportacion", service.ArchivoImportacion),
                new SqlParameter("@IdTipoImportacion", service.IdTipoImportacion),
                new SqlParameter("@FechaImportacion", service.FechaImportacion),
                new SqlParameter("@UsuarioImportador", service.UsuarioImportador),
                new SqlParameter("@FechaAlta", service.FechaAlta),
                new SqlParameter("@FechaProgramadaImportacion", service.FechaProgramadaImportacion),
                new SqlParameter("@LogError", service.LogError),
                new SqlParameter("@IdTipoInscripcion", service.IdTipoInscripcion),
                new SqlParameter("@TurnoInscripcion", service.TurnoInscripcion),
                new SqlParameter("@IdVuelta", service.IdVuelta),
                new SqlParameter("@ClaseFormato", service.ClaseFormato),
            };
            var id = Convert.ToInt32(SqlClientUtility.ExecuteScalar(connectionStringName, CommandType.StoredProcedure, "ServicioInsert", parameters));
            SqlConnection.ClearAllPools();
            return id;
        }