public ResultadoProcesoImportacionArchivosBMVDto ProcesarArchivosEmisorasBMV(Stream archivoEmisoras, Stream archivoFideicomisos)
        {
            var resultadoProceso = new ResultadoProcesoImportacionArchivosBMVDto();

            resultadoProceso.FechaHoraProceso = DateTime.Now;

            resultadoProceso.EmisorasImportadas           = new List <EmisoraImportadaBMVDto>();
            resultadoProceso.FideicomisosImportados       = new List <FideicomisoImportadoBMVDto>();
            resultadoProceso.ErroresGeneralesEmisoras     = new List <String>();
            resultadoProceso.ErroresGeneralesFideicomisos = new List <String>();
            if (archivoEmisoras != null)
            {
                LeerContenidoArchivoEmisoras(resultadoProceso, archivoEmisoras);
            }
            if (archivoFideicomisos != null)
            {
                LeerContenidoArchivoFideicomisos(resultadoProceso, archivoFideicomisos);
            }

            ComplementarListaEmisorasConFideicomisos(resultadoProceso);

            AplicarCambiosEnCatalogEmpresas(resultadoProceso);

            return(resultadoProceso);
        }
        /// <summary>
        /// Parsea el contenido del archivo de fideicomisos, coloca los errores y los valores leidos en las listas correspondientes
        /// </summary>
        /// <param name="resultadoProceso">Objecto destino para los datos o errores</param>
        private void LeerContenidoArchivoFideicomisos(ResultadoProcesoImportacionArchivosBMVDto resultadoProceso, Stream archivoFideicomiso)
        {
            using (var stReader = new System.IO.StreamReader(archivoFideicomiso))
            {
                String linea                = null;
                long   numLinea             = 1;
                var    fideicomisosPorClave = new Dictionary <String, String>();
                while ((linea = stReader.ReadLine()) != null)
                {
                    try
                    {
                        var fideicomisoLeido = PocesarDatosFideicomiso(linea, numLinea);
                        if (!String.IsNullOrEmpty(fideicomisoLeido.ClaveFideicomiso))
                        {
                            if (!fideicomisosPorClave.ContainsKey(fideicomisoLeido.ClaveFideicomiso))
                            {
                                resultadoProceso.FideicomisosImportados.Add(fideicomisoLeido);
                                fideicomisosPorClave[fideicomisoLeido.ClaveFideicomiso] = fideicomisoLeido.ClaveFideicomiso;
                            }
                        }
                        else
                        {
                            resultadoProceso.ErroresGeneralesFideicomisos.Add("Fideicomiso leído sin clave de cotización: línea :" + numLinea);
                        }
                    }
                    catch (Exception ex)
                    {
                        resultadoProceso.ErroresGeneralesFideicomisos.Add("Línea: " + numLinea + ":" + ex.Message);
                    }

                    numLinea++;
                }
            }
        }
예제 #3
0
        public void TestProcesarArchivoEmisoras()
        {
            using (var streamArchivoEmisoras =
                       new FileStream(@"C:\Users\Emigdio\Dropbox\2H\CNBV\CNBV-BMV Sincronización\archivos\Emisoras_160616.txt", FileMode.Open))
            {
                using (var streamArchivoFideicomiso =
                           new FileStream(@"C:\Users\Emigdio\Dropbox\2H\CNBV\CNBV-BMV Sincronización\archivos\Fideicomisos_160616.txt", FileMode.Open))
                {
                    ResultadoProcesoImportacionArchivosBMVDto resultado = service.ProcesarArchivosEmisorasBMV(streamArchivoEmisoras, streamArchivoFideicomiso);

                    Debug.WriteLine(resultado.ErroresGeneralesEmisoras);
                }
            }
        }
        /// <summary>
        /// Parsea el contenido del archivo de emisoras, coloca los errores y los valores leidos en las listas correspondientes
        /// </summary>
        /// <param name="resultadoProceso">Objecto destino para los datos o errores</param>
        private void LeerContenidoArchivoEmisoras(ResultadoProcesoImportacionArchivosBMVDto resultadoProceso, Stream archivoEmisora)
        {
            var emisorasPorClave = new Dictionary <String, String>();

            using (var stReader = new System.IO.StreamReader(archivoEmisora))
            {
                String linea    = null;
                long   numLinea = 1;

                while ((linea = stReader.ReadLine()) != null)
                {
                    try
                    {
                        var emisoraLeida = PocesarDatosEmisora(linea, numLinea);
                        if (!String.IsNullOrEmpty(emisoraLeida.Clave))
                        {
                            if (!emisorasPorClave.ContainsKey(emisoraLeida.Clave))
                            {
                                resultadoProceso.EmisorasImportadas.Add(emisoraLeida);
                                emisorasPorClave[emisoraLeida.Clave] = emisoraLeida.Clave;
                            }
                        }
                        else
                        {
                            resultadoProceso.ErroresGeneralesEmisoras.Add("Emisora leída sin clave de cotización: línea :" + numLinea);
                        }
                    }
                    catch (Exception ex)
                    {
                        resultadoProceso.ErroresGeneralesEmisoras.Add("Línea: " + numLinea + ":" + ex.Message);
                    }

                    numLinea++;
                }
            }
        }
        /// <summary>
        /// Aplica los cambios al catálog de emisoras leidas del archivo importado
        /// </summary>
        /// <param name="resultadoProceso"></param>
        private void AplicarCambiosEnCatalogEmpresas(ResultadoProcesoImportacionArchivosBMVDto resultadoProceso)
        {
            foreach (var emisoraImportada in resultadoProceso.EmisorasImportadas)
            {
                Debug.WriteLine(emisoraImportada.Clave + "|" + emisoraImportada.ClaveFiduciarioEmisor +
                                "|" + emisoraImportada.EsFideicomiso + "|" + emisoraImportada.RazonSocial + "|" + emisoraImportada.RazonSocialFideicomiso);
            }

            var emisorasEnBD            = EmpresaRepository.GetQueryable().Where(x => (x.Borrado == null || x.Borrado.Value == false));
            var emisoraBDPorNombreCorto = new Dictionary <String, Empresa>();

            foreach (var emBD in emisorasEnBD)
            {
                emisoraBDPorNombreCorto[emBD.NombreCorto] = emBD;
            }

            foreach (var emisoraImportada in resultadoProceso.EmisorasImportadas)
            {
                if (String.IsNullOrEmpty(emisoraImportada.Error))
                {
                    emisoraImportada.TipoMovimiento = TipoMovimiento.SIN_CAMBIOS;

                    if (emisoraImportada.Estatus != null && !emisoraImportada.Estatus.Equals(EstatusEmisora.SUSPENDIDA))
                    {
                        //Insertar emisora si no existe
                        Empresa empresaEncontrada = null;
                        if (emisoraBDPorNombreCorto.ContainsKey(emisoraImportada.Clave))
                        {
                            empresaEncontrada = emisoraBDPorNombreCorto[emisoraImportada.Clave];
                        }
                        if (empresaEncontrada == null)
                        {
                            empresaEncontrada                = new Empresa();
                            empresaEncontrada.Borrado        = false;
                            empresaEncontrada.RazonSocial    = emisoraImportada.EsFideicomiso ? emisoraImportada.RazonSocialFideicomiso : emisoraImportada.RazonSocial;
                            empresaEncontrada.NombreCorto    = emisoraImportada.Clave;
                            empresaEncontrada.RFC            = emisoraImportada.RFC;
                            empresaEncontrada.Fideicomitente = emisoraImportada.EsFideicomiso;
                            EmpresaRepository.Add(empresaEncontrada);
                            emisoraImportada.IdReferencia   = empresaEncontrada.IdEmpresa;
                            emisoraImportada.TipoMovimiento = TipoMovimiento.ALTA;
                        }
                        else
                        {
                            //Verificar si se actualiza la emisora
                            String razolSocialFinal = emisoraImportada.EsFideicomiso ? emisoraImportada.RazonSocialFideicomiso : emisoraImportada.RazonSocial;
                            if (ValorDiferente(empresaEncontrada.RazonSocial, razolSocialFinal) || ValorDiferente(empresaEncontrada.RFC, emisoraImportada.RFC))
                            {
                                empresaEncontrada.RazonSocial    = razolSocialFinal;
                                empresaEncontrada.RFC            = emisoraImportada.RFC;
                                empresaEncontrada.Fideicomitente = emisoraImportada.EsFideicomiso;
                                emisoraImportada.IdReferencia    = empresaEncontrada.IdEmpresa;
                                emisoraImportada.TipoMovimiento  = TipoMovimiento.CAMBIO;
                                EmpresaRepository.Update(empresaEncontrada);
                            }
                        }
                    }
                }
            }
            //TODO: On hold, se recomendará que en el archivo de fiduciarios se incluya la clave del fiduciario emisor

            /*
             * foreach (var emisoraImportada in resultadoProceso.EmisorasImportadas)
             * {
             *  if (String.IsNullOrEmpty(emisoraImportada.Error) && emisoraImportada.EsFideicomiso && !String.IsNullOrEmpty(emisoraImportada.ClaveFiduciarioEmisor))
             *  {
             *      if (emisoraImportada.Estatus != null && !emisoraImportada.Estatus.Equals(EstatusEmisora.SUSPENDIDA))
             *      {
             *          //Verificar las relaciones entre fideicomiso y fiduciario
             *          Empresa empresaFideicomiso = EmpresaRepository.GetQueryable().Where(x => x.NombreCorto == emisoraImportada.Clave
             *              && (x.Borrado == null || x.Borrado.Value == false)).FirstOrDefault();
             *          Empresa empresaFiduciario = EmpresaRepository.GetQueryable().Where(x => x.NombreCorto == emisoraImportada.ClaveFiduciarioEmisor &&
             *              (x.Borrado == null || x.Borrado.Value == false)).FirstOrDefault();
             *
             *          if (empresaFiduciario != null && empresaFideicomiso != null)
             *          {
             *              var relacionEmpresas = RelacionEmpresasRepository.GetQueryable().
             *              Where(x => x.IdEmpresaPrimaria == empresaFiduciario.IdEmpresa &&
             *                  x.IdEmpresaSecundaria == empresaFideicomiso.IdEmpresa &&
             *                  x.IdTipoRelacionEmpresa == ConstantsTipoRelacionEmpresa.FIDUCIARIO_DE_FIDEICOMITENTE).
             *                  FirstOrDefault();
             *              if (relacionEmpresas == null)
             *              {
             *                  //Relacionar empresas
             *                  var relacion = new RelacionEmpresas
             *                  {
             *                      TipoRelacionEmpresa = TipoRelacionEmpresaRepository.GetById(ConstantsTipoRelacionEmpresa.FIDUCIARIO_DE_FIDEICOMITENTE),
             *                      IdEmpresaPrimaria = empresaFiduciario.IdEmpresa,
             *                      IdEmpresaSecundaria = empresaFideicomiso.IdEmpresa
             *                  };
             *
             *                  //RelacionEmpresasRepository.Add(relacion);
             *                  emisoraImportada.TipoMovimiento = TipoMovimiento.CAMBIO;
             *              }
             *          }
             *      }
             *  }
             * }*/
        }
        /// <summary>
        /// Comeplementa la lista de emisoras con los datos de relación entre fideicomisos y fiduciarios
        /// </summary>
        /// <param name="resultadoProceso"></param>
        private void ComplementarListaEmisorasConFideicomisos(ResultadoProcesoImportacionArchivosBMVDto resultadoProceso)
        {
            var indicePorClaveCotizacion = new Dictionary <String, EmisoraImportadaBMVDto>();
            var indicePorRazonSocial     = new Dictionary <String, EmisoraImportadaBMVDto>();

            foreach (var emisoraTmp in resultadoProceso.EmisorasImportadas)
            {
                if (!String.IsNullOrEmpty(emisoraTmp.Clave))
                {
                    indicePorClaveCotizacion[emisoraTmp.Clave] = emisoraTmp;
                }
                else
                {
                    emisoraTmp.TipoMovimiento = TipoMovimiento.ERROR;
                    emisoraTmp.Error          = "Clave de pizarra vacía";
                }
            }
            EmisoraImportadaBMVDto emisora = null;

            //Actualizar las razones sociales de los fideicomisos
            foreach (var fideicomiso in resultadoProceso.FideicomisosImportados)
            {
                if (!String.IsNullOrEmpty(fideicomiso.ClaveFideicomiso))
                {
                    if (indicePorClaveCotizacion.ContainsKey(fideicomiso.ClaveFideicomiso))
                    {
                        indicePorClaveCotizacion[fideicomiso.ClaveFideicomiso].RazonSocial            = fideicomiso.RazonSocialFideicomitente;
                        indicePorClaveCotizacion[fideicomiso.ClaveFideicomiso].EsFideicomiso          = true;
                        indicePorClaveCotizacion[fideicomiso.ClaveFideicomiso].RazonSocialFideicomiso = fideicomiso.RazonSocialFideicomitente;
                    }
                }
            }

            foreach (var emisoraTmp in resultadoProceso.EmisorasImportadas)
            {
                if (!String.IsNullOrEmpty(emisoraTmp.RazonSocial))
                {
                    indicePorRazonSocial[emisoraTmp.RazonSocial] = emisoraTmp;
                }
                else
                {
                    emisoraTmp.TipoMovimiento = TipoMovimiento.ERROR;
                    emisoraTmp.Error          = "Razón social vacía";
                }
            }



            foreach (var fideicomiso in resultadoProceso.FideicomisosImportados)
            {
                if (!String.IsNullOrEmpty(fideicomiso.ClaveFideicomiso))
                {
                    if (indicePorClaveCotizacion.ContainsKey(fideicomiso.ClaveFideicomiso))
                    {
                        emisora = indicePorClaveCotizacion[fideicomiso.ClaveFideicomiso];

                        if (indicePorRazonSocial.ContainsKey(fideicomiso.RazonSocialFiduciario))
                        {
                            if (!indicePorRazonSocial[fideicomiso.RazonSocialFiduciario].EsFideicomiso)
                            {
                                emisora.ClaveFiduciarioEmisor = indicePorRazonSocial[fideicomiso.RazonSocialFiduciario].Clave;
                            }
                        }
                        else
                        {
                            fideicomiso.TipoMovimiento = TipoMovimiento.ERROR;
                            fideicomiso.Error          = "Emisora fiduciaria no encontrada utilizando el dato razón social";
                        }
                    }
                    else
                    {
                        fideicomiso.TipoMovimiento = TipoMovimiento.ERROR;
                        fideicomiso.Error          = "Fideicomiso no existe en la lista de emisoras";
                    }
                }
                else
                {
                    fideicomiso.TipoMovimiento = TipoMovimiento.ERROR;
                    fideicomiso.Error          = "Clave de fideicomiso vacía";
                }
            }
        }