Ejemplo n.º 1
0
        private void DeleteNorma_Click(object sender, EventArgs e)
        {
            int id = -1;

            if (!NormaID.Equals("-1") && NormaID != null)
            {
                id = Int32.Parse(NormaID.Text);
                Normas norm = _context.Normas.Where(n => n.NormaId == id).FirstOrDefault();
                if (norm != null)
                {
                    var confirmation = MessageBox.Show("¿Estás seguro/a que quieres eliminar esta nroma de uso: " + norm.NormaContent + "?", "LTI Administration", MessageBoxButtons.YesNo);
                    if (DialogResult.Yes == confirmation)
                    {
                        _context.Normas.Remove(norm);
                        _context.SaveChanges();
                        MessageBox.Show("La norma ha sido eliminada exitosamente.", "LTI Administration", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        PopulatList();
                    }
                }
                else
                {
                    MessageBox.Show("Error: No se pudo obtener la norma seleccionada. Selecione la fila completa haciendo clic en la fila correspondiente de la primera columna (que no tiene nombre de columna).", "LTI Administration", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
            else
            {
                MessageBox.Show("Error: No se pudo obtener la norma seleccionada. Selecione la fila completa haciendo clic en la fila correspondiente de la primera columna (que no tiene nombre de columna).", "LTI Administration", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
Ejemplo n.º 2
0
        private void LeeFromOracleVersiones()
        {
            #region NORMAS VERSION
            NormasOracle = new Dictionary <string, Normas>();

            #region Query a ejecutar (carga inicial o incremental)
            string queryTot = Oracle.QueryNormasAll;

            if (!ComunGlobal.FechaFinIncremental.Equals("0") && !ComunGlobal.FechaIniIncremental.Equals("0"))
            {
                queryTot = queryTot + " WHERE " + NombreCamposNormas.Aen_Fecha_ActualizacionORACLE + " BETWEEN '" + ComunGlobal.FechaIniIncremental + "' AND '" + ComunGlobal.FechaFinIncremental + "'";
            }

            #endregion Query a ejecutar  (carga inicial o incremental)

            OracleDataAdapter oda = new OracleDataAdapter(queryTot, ComunGlobal.ConnStringOracle);
            var dt = new DataTable();
            oda.Fill(dt);

            foreach (DataRow fila in dt.Rows)
            {
                Normas norAux = new Normas();
                norAux.NormasFromOracle(fila, TercerosOrganismosCRM, MaestroComitesCRM, RaicesNormasCRM);

                if (norAux != null)
                {
                    NormasOracle.Add(norAux.Aen_Articulo, norAux);
                }
            }
            #endregion NORMAS VERSION
        }
Ejemplo n.º 3
0
 public IActionResult Post([FromBody] Normas norma)
 {
     if (!ModelState.IsValid)
     {
         return(BadRequest("Los datos para el registro no son validos"));
     }
     _normativasContext.InsertOne(norma);
     return(CreatedAtRoute("PostNormative", norma));
 }
Ejemplo n.º 4
0
        public void IfIsAlive4()
        {
            int  celulasVecinas = 4;
            bool EstadoInicial  = true;
            bool ChangeEstado;

            ChangeEstado = Normas.IsAlive(EstadoInicial, celulasVecinas);

            Assert.IsFalse(ChangeEstado);
        }
Ejemplo n.º 5
0
        public void IfIsDied3()
        {
            int  celulasVecinas = 3;
            bool EstadoInicial  = false;
            bool ChangeEstado;

            ChangeEstado = Normas.IsAlive(EstadoInicial, celulasVecinas);

            Assert.IsTrue(ChangeEstado);
        }
Ejemplo n.º 6
0
        private void SaveChanges_Click(object sender, EventArgs e)
        {
            int    id   = Int32.Parse(NormaList.SelectedValue.ToString());
            Normas norm = _context.Normas.Where(n => n.NormaId == id).FirstOrDefault();

            norm.NormaContent = Content.Text;
            norm.CreatedBy    = CreatedBy.Text;
            _context.SaveChanges();
            MessageBox.Show("Los cambios se han guardado con éxito.");
            this.Close();
        }
Ejemplo n.º 7
0
        public IActionResult Put(string id, [FromBody] Normas value)
        {
            var norma = _normativasContext.Find <Normas>(x => x.id == id).FirstOrDefault();

            // si no existe un articulo con ese Id
            if (norma == null)
            {
                return(NotFound("No se ha encontrado una norma con el Id: " + id));
            }
            _normativasContext.ReplaceOne(x => x.id == id, value);
            return(NoContent());
        }
Ejemplo n.º 8
0
        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);
            _context         = new StudentModel();
            _contextSubjects = new SubjectModel();
            var reglas = _context.NormasReglas;

            foreach (var regla in reglas)
            {
                Normas.AppendText(regla.NormaID + ") " + regla.NormaContent + "\n\n");
            }
        }
Ejemplo n.º 9
0
        private void DeleteNormaBtn_Click(object sender, EventArgs e)
        {
            DialogResult confirmation = MessageBox.Show("¿Está seguro que desea eliminar esta norma de uso?", "LTI Administration", MessageBoxButtons.YesNo, MessageBoxIcon.Question);

            if (confirmation == DialogResult.Yes)
            {
                int    id   = Int32.Parse(NormaList.SelectedValue.ToString());
                Normas norm = _context.Normas.Where(n => n.NormaId == id).FirstOrDefault();
                _context.Normas.Remove(norm);
                _context.SaveChanges();
                MessageBox.Show("La norma se ha eliminado con éxito.", "LTI Administration");
                this.Close();
            }
        }
Ejemplo n.º 10
0
 private void SaveChanges_Click(object sender, EventArgs e)
 {
     if (Content.Text.Equals("") || CreatedBy.Text.Equals(""))
     {
         MessageBox.Show("Por favor, llene los campos obligatorios, marcados con un *.");
     }
     else
     {
         Normas norm = new Normas();
         norm.CreatedBy    = displayName;
         norm.NormaContent = Content.Text;
         _context.Normas.Add(norm);
         _context.SaveChanges();
         MessageBox.Show("La norma de uso ha sido agregada con éxito.");
         this.Close();
     }
 }
Ejemplo n.º 11
0
        private void NormaList_SelectedIndexChanged(object sender, EventArgs e)
        {
            ComboBox cb = (ComboBox)sender;

            if (cb.SelectedIndex > 0)
            {
                SetFieldsBehaviour(true);
                int    id   = Int32.Parse(cb.SelectedValue.ToString());
                Normas norm = _context.Normas.Where(n => n.NormaId == id).FirstOrDefault();
                Content.Text   = norm.NormaContent;
                CreatedBy.Text = norm.CreatedBy;
            }
            else
            {
                SetFieldsBehaviour(false);
            }
        }
Ejemplo n.º 12
0
        private void LeeFromCRMVersiones()
        {
            #region NORMAS VERSION
            NormasCRM          = new Dictionary <string, Normas>();
            VersionesNormasCRM = new Dictionary <string, Guid>();

            string[] camposN =
            {
                NombreCamposNormas.EntityIDVersion,
                NombreCamposNormas.Aen_Es_RatificadaCRM,          NombreCamposNormas.Aen_Royalty_UneCRM,
                NombreCamposNormas.Aen_Royalty_OrganismoCRM,      NombreCamposNormas.Aen_Identificador_NexoCRM,
                NombreCamposNormas.Aen_Fecha_EdicionCRM,          NombreCamposNormas.Aen_Fecha_AnulacionCRM,
                NombreCamposNormas.Aen_Nu_PaginasCRM,             NombreCamposNormas.Aen_Grupo_PrecioCRM,
                NombreCamposNormas.Aen_OrganismoCRM,              NombreCamposNormas.Aen_ArticuloCRM,
                NombreCamposNormas.Aen_Organismo_NormaCRM,        NombreCamposNormas.Aen_Formato_EspecialCRM,
                NombreCamposNormas.Aen_Organismo_InternacionalCRM,NombreCamposNormas.Aen_Organismo_GrupoCRM,
                NombreCamposNormas.Aen_EstadoCRM,                 NombreCamposNormas.Aen_Codigo_NormaCRM,
                NombreCamposNormas.Aen_Raiz_NormaCRM,             NombreCamposNormas.Aen_Ambito_NormaCRM,
                NombreCamposNormas.Aen_Codigo_ComiteCRM,          NombreCamposNormas.Aen_Titulo_Norma_ENCRM,
                NombreCamposNormas.Aen_Titulo_Norma_ESCRM,        NombreCamposNormas.Aen_EstatusCRM,
                NombreCamposNormas.Aen_TipoNormaCRM
            };
            var entityName = NombreCamposNormas.EntityNameVersion;

            #region Query
            var filter           = new FilterExpression();
            var conditionNotNull = new ConditionExpression();
            conditionNotNull.AttributeName = NombreCamposNormas.Aen_ArticuloCRM;
            conditionNotNull.Operator      = ConditionOperator.NotNull;
            filter.Conditions.Add(conditionNotNull);

            var query = new QueryExpression(entityName);
            query.ColumnSet.AddColumns(camposN);
            query.Criteria.AddFilter(filter);
            #endregion Query
            #region PagingCookie
            int fetchCount = 5000;
            int pageNumber = 1;

            query.PageInfo              = new PagingInfo();
            query.PageInfo.Count        = fetchCount;
            query.PageInfo.PageNumber   = pageNumber;
            query.PageInfo.PagingCookie = null;
            #endregion PagingCookie

            while (true)
            {
                EntityCollection versionColeccion = CrmGlobal.GetIOS().RetrieveMultiple(query);

                if (versionColeccion.Entities.Count > 0)
                {
                    foreach (Entity versCRM in versionColeccion.Entities)
                    {
                        Normas v = new Normas();
                        v.VersionFromCRM(versCRM);
                        NormasCRM.Add(v.Aen_Articulo, v);
                        VersionesNormasCRM.Add(v.Aen_Articulo, versCRM.Id);
                    }
                }

                if (versionColeccion.MoreRecords)
                {
                    query.PageInfo.PageNumber++;
                    query.PageInfo.PagingCookie = versionColeccion.PagingCookie;
                }
                else
                {
                    break;
                }
            }
            #endregion NORMAS VERSION
        }
Ejemplo n.º 13
0
        public void Iniciar(Oracle ora, Comun com, Crm crm)
        {
            try
            {
                OracleGlobal = ora;
                ComunGlobal  = com;
                CrmGlobal    = crm;

                ComunGlobal.LogText("*************************************************************************");

                /*1. Carga Comités Padres (Tabla 'Comites Tecnicos')
                 * 2. Carga resto Comités (Tabla 'Comites Tecnicos')*/
                MaestroComitesCRM = new LanzadorComitesTecnicos().Iniciar(OracleGlobal, ComunGlobal, CrmGlobal);
                ComunGlobal.LogText("*************************************************************************");


                /*3. Carga Normas ICS sin padres (Tabla 'ICS')
                 * 4. Carga resto de Normas ICS (Tabla 'ICS') */
                MaestroICSCRM = new LanzadorICS().Iniciar(OracleGlobal, ComunGlobal, CrmGlobal);
                ComunGlobal.LogText("*************************************************************************");


                LeeFromCRMMaestros();
                LeeFromOracleRaices();

                //5. Cargar Normas (Raíz: De las tablas de 'Normas' obtener los distintos valores de Aen_Raiz_Norma y cargarlos en la entidad aen_norma)
                //  5.1 Diccionario <código, Guid> de Normas Raices
                #region PROCESAR NORMAS RAIZ
                bool   ok;
                Guid   normRGuid;
                Entity auxRaiz;
                if (RaicesNormas.Any())
                {
                    ComunGlobal.LogText("----   Iniciando CARGA NORMAS RAIZ  ------");
                    ComunGlobal.LogText("****   Registros a cotejar: " + RaicesNormas.Count);
                    foreach (var rz in RaicesNormas)
                    {
                        ok = RaicesNormasCRM.TryGetValue(rz, out normRGuid);
                        //No existe, creamos
                        if (!ok)
                        {
                            auxRaiz = new Entity(NombreCamposNormas.EntityNameRaiz);
                            auxRaiz[NombreCamposNormas.Aen_CodigoRaizNorma] = rz;
                            CrmGlobal.AnadirElementoEmr(new CreateRequest {
                                Target = auxRaiz
                            });
                        }
                        else
                        {
                            CrmGlobal.Iguales++;
                        }
                    }
                    CrmGlobal.ProcesarUltimosEmr();

                    if (RaicesNormas.Count > 0)
                    {
                        CargaMaestroRaicesCRM();
                    }

                    CrmGlobal.MostrarEstadisticas("NORMAS RAIZ");
                    ComunGlobal.LogText("----   FINALIZADA CARGA NORMAS RAIZ  ------");
                }
                else
                {
                    ComunGlobal.LogText("No hay NORMAS RAIZ en origen, terminamos");
                }
                #endregion PROCESAR NORMAS RAIZ
                ComunGlobal.LogText("*************************************************************************");


                //6. Cargar Normas-Version (Tabla 'Normas' enlazando ya el campo Aen_Raiz_Norma)
                LeeFromCRMVersiones();
                LeeFromOracleVersiones();
                if (NormasOracle.Any())
                {
                    #region PROCESA NORMAS VERSION
                    ComunGlobal.LogText("----   Iniciando CARGA NORMAS VERSION  ------");
                    ComunGlobal.LogText("****   Registros a cotejar: " + NormasOracle.Count);
                    Normas auxNormCRM = new Normas();
                    Entity norUpdate;

                    foreach (var nor in NormasOracle)
                    {
                        ok = NormasCRM.TryGetValue(nor.Value.Aen_Articulo, out auxNormCRM);

                        try
                        {
                            if (ok) // Existe, actualizamos
                            {
                                norUpdate = new Entity(NombresCamposICS.EntityName);

                                bool res = nor.Value.VersionesIguales(auxNormCRM, ref norUpdate);

                                if (res)
                                {
                                    CrmGlobal.AnadirElementoEmr(new UpdateRequest {
                                        Target = norUpdate
                                    });
                                }
                                else
                                {
                                    CrmGlobal.Iguales++;
                                }
                            }
                            else //No existe, creamos
                            {
                                Entity newI = nor.Value.GetEntity();
                                CrmGlobal.AnadirElementoEmr(new CreateRequest {
                                    Target = newI
                                });
                            }
                        }
                        catch (Exception e)
                        {
                            ComunGlobal.LogText("ERROR con la Norma Versión " + nor.Value.Aen_Articulo + " ::: " + e.ToString());
                        }
                    }
                    CrmGlobal.ProcesarUltimosEmr();
                    CrmGlobal.MostrarEstadisticas("NORMAS VERSION");
                    ComunGlobal.LogText("----   Finalizada CARGA NORMAS VERSION  ------");
                    #endregion PROCESA NORMAS VERSION
                }
                else
                {
                    ComunGlobal.LogText("No hay NORMAS VERSION en origen, terminamos");
                }
                ComunGlobal.LogText("*************************************************************************");


                //7. Cargar Productos (Tabla 'Normas-Producto')
                CargaMaestroVersionesCRM();
                LeeFromCRMProductoseICS();
                LeeFromOracleProductoseICS();
                if (NormasProductosOracle.Any())
                {
                    #region PROCESA PRODUCTOS
                    ComunGlobal.LogText("----   Iniciando CARGA PRODUCTOS  ------");
                    ComunGlobal.LogText("****   Registros a cotejar: " + NormasProductosOracle.Count);
                    NormasProductos auxNpCRM = new NormasProductos();
                    Entity          npUpdate;

                    foreach (var norP in NormasProductosOracle)
                    {
                        ok = NormasProductosCRM.TryGetValue(norP.Value.Aen_Codigo_Producto, out auxNpCRM);

                        try
                        {
                            if (ok) // Existe, actualizamos
                            {
                                npUpdate = new Entity(NombreCamposNormasProductos.EntityName);

                                bool res = norP.Value.NormasProductosIguales(auxNpCRM, ref npUpdate, CrmGlobal.TipoProductoNorma, CrmGlobal.UOMID, CrmGlobal.SheduleUOMID);

                                if (res)
                                {
                                    CrmGlobal.AnadirElementoEmr(new UpdateRequest {
                                        Target = npUpdate
                                    });
                                }
                                else
                                {
                                    CrmGlobal.Iguales++;
                                }
                            }
                            else //No existe, creamos
                            {
                                Entity newE = norP.Value.GetEntity(CrmGlobal.TipoProductoNorma, CrmGlobal.UOMID, CrmGlobal.SheduleUOMID);
                                CrmGlobal.AnadirElementoEmr(new CreateRequest {
                                    Target = newE
                                });
                            }
                        }
                        catch (Exception e)
                        {
                            ComunGlobal.LogText("ERROR con el producto " + norP.Value.Aen_Codigo_Producto + " ::: " + e.ToString());
                        }
                    }
                    CrmGlobal.ProcesarUltimosEmr();
                    CrmGlobal.MostrarEstadisticas("PRODUCTOS Carga");
                    ComunGlobal.LogText("----   Finalizada CARGA PRODUCTOS  ------");
                    #endregion PROCESA PRODUCTOS
                }
                else
                {
                    ComunGlobal.LogText("No hay PRODUCTOS en origen, terminamos");
                }
                ComunGlobal.LogText("*************************************************************************");


                //8. Asociar Normas ICS (Tabla 'ICS' + intermedia 'Normas-ICS') a Normas Versión
                if (NormasICSOracle.Any())
                {
                    #region PROCESA RELACIONES NORMAS VERSION - ICS
                    ComunGlobal.LogText("----   Iniciando ENLACE ICS-VERSION  ------");
                    ComunGlobal.LogText("****   Registros a cotejar: " + NormasICSOracle.Count);
                    KeyValuePair <Guid, Guid> aux;
                    foreach (var nicsOra in NormasICSOracle)
                    {
                        if (nicsOra.Key != Guid.Empty && nicsOra.Value != Guid.Empty)
                        {
                            bool enlazado = NormasICSCRM.TryGetValue(nicsOra.Key.ToString() + "&" + nicsOra.Value.ToString(),
                                                                     out aux);
                            if (!enlazado)
                            {
                                CrmGlobal.AnadirElementoEmr(CrmGlobal.getAssociateRequest(NombresCamposICS.EntityName, nicsOra.Value, NombresCamposNormasICS.RelationshipName, NombreCamposNormas.EntityNameVersion, nicsOra.Key));
                            }
                            else
                            {
                                CrmGlobal.Iguales++;
                            }
                        }
                    }
                    CrmGlobal.ProcesarUltimosEmr();
                    CrmGlobal.MostrarEstadisticas("ENLACES ICS-VERSION");
                    ComunGlobal.LogText("----   Finalizado ENLACE ICS-VERSION  ------");
                    #endregion PROCESA RELACIONES NORMAS VERSION - ICS
                }
                else
                {
                    ComunGlobal.LogText("No hay ICS a enlazar en NORMAS VERSION, terminamos");
                }
                ComunGlobal.LogText("*************************************************************************");

                LimpiezaDiccionarios();

                ComunGlobal.LogText("----   FIN CARGA   ------");
            }
            catch (Exception e)
            {
                ComunGlobal.LogText("ERROR en Lanzador de NORMAS ::: " + e.ToString());
                if (OracleGlobal != null && OracleGlobal.OraConnParaLog.State == ConnectionState.Open)
                {
                    OracleGlobal.OraConnParaLog.Dispose();
                }
            }
        }