Esempio n. 1
0
        public HttpResponseMessage Synchronize([FromBody] List <ERP_LOCALIDADES> lista)
        {
            log.Info("Ingreso Synchronize");

            HttpResponseMessage             response     = new HttpResponseMessage();
            ServiceSyncErpLocalidadesEntity resultSQLite = null;

            try
            {
                ServiceErpLocalidadesBusiness serviceErpLocalidadesBusiness = new ServiceErpLocalidadesBusiness();

                //Comparo el input enviado desde SQLite con la base local
                log.Info("Ejecuta serviceErpLocalidadesBusiness.SynchronizeSQLite(lista): " + JsonConvert.SerializeObject(lista));
                resultSQLite = serviceErpLocalidadesBusiness.SynchronizeSQLite(lista);
                log.Info("Respuesta serviceErpLocalidadesBusiness.SynchronizeSQLite(lista): " + JsonConvert.SerializeObject(lista));

                response = Request.CreateResponse(HttpStatusCode.Created, resultSQLite);
            }
            catch (Exception ex)
            {
                log.Error("Mensaje de Error: " + ex.Message);
                if (ex.InnerException != null)
                {
                    log.Error("Inner exception: " + ex.InnerException.Message);
                }

                response = Request.CreateResponse(HttpStatusCode.BadRequest, ex.Message);
            }

            log.Info("Salio Synchronize");
            return(response);
        }
Esempio n. 2
0
        public HttpResponseMessage Synchronize([FromBody] TablasItris tablasItris)
        {
            log.Info("Ingreso Synchronize");
            string usuarioItris = this.ObtenerUsuarioItris();

            string[]                arregloTablasItris = tablasItris.NombreTablas.Select(x => x.ToUpper()).ToArray();
            MiddlewareModel         model              = new MiddlewareModel();
            HttpResponseMessage     response           = new HttpResponseMessage();
            ItrisAuthenticateEntity authenticateEntity = null;

            ServiceConfigurationBusiness serviceConfigurationBusiness = new ServiceConfigurationBusiness();
            string lastUpdate = string.Empty;

            try
            {
                if (arregloTablasItris.Contains(ITRIS_CLASE_EMPRESAS))
                {
                    //Obtengo fecha ultima actualizacion de la tabla de configuraciones
                    Func <tbConfiguration, bool> predicado = x => x.con_code == LAST_SYNC_EMPRESAS;
                    var listRead = (List <tbConfiguration>)serviceConfigurationBusiness.Read(predicado);
                    var conf     = listRead.FirstOrDefault();

                    authenticateEntity = new ItrisAuthenticateEntity(ITRIS_SERVER, ITRIS_PUERTO_API3, ITRIS_CLASE_EMPRESAS,
                                                                     ITRIS_API3_APP, ITRIS_API3_CONFIG, ITRIS_API3_USER, ITRIS_API3_PASS);
                    ServiceErpEmpresasBusiness serviceErpEmpresasBusiness = new ServiceErpEmpresasBusiness();

                    //Actualizo base de datos local respecto de las modificaciones en la base de itris
                    log.Info("Ejecuta serviceErpEmpresasBusiness.SynchronizeErpEmpresasDACS(authenticateEntity)");
                    model.resultDACSEmpresas =
                        serviceErpEmpresasBusiness.SynchronizeErpEmpresasDACS(authenticateEntity, conf.con_value);
                    log.Info("Respuesta serviceErpEmpresasBusiness.SynchronizeErpEmpresasDACS(authenticateEntity): " + JsonConvert.SerializeObject(model.resultDACSEmpresas));

                    //Actualizo la fecha de ultima actualizacion con del dia que es la ultima actualizacion
                    conf.con_value = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                    serviceConfigurationBusiness.Update(conf);
                }

                if (arregloTablasItris.Contains(ITRIS_CLASE_ASESORES))
                {
                    //Obtengo fecha ultima actualizacion de la tabla de configuraciones
                    Func <tbConfiguration, bool> predicado = x => x.con_code == LAST_SYNC_ASESORES;
                    var listRead = (List <tbConfiguration>)serviceConfigurationBusiness.Read(predicado);
                    var conf     = listRead.FirstOrDefault();

                    authenticateEntity = new ItrisAuthenticateEntity(ITRIS_SERVER, ITRIS_PUERTO_API3, ITRIS_CLASE_ASESORES,
                                                                     ITRIS_API3_APP, ITRIS_API3_CONFIG, ITRIS_API3_USER, ITRIS_API3_PASS);
                    ServiceErpAsesoresBusiness serviceErpAsesoresBusiness = new ServiceErpAsesoresBusiness();

                    //Actualizo base de datos local respecto de las modificaciones en la base de itris
                    log.Info("Ejecuta serviceErpAsesoresBusiness.SynchronizeErpAsesoresDACS(authenticateEntity)");
                    model.resultDACSAsesores = serviceErpAsesoresBusiness.SynchronizeErpAsesoresDACS(authenticateEntity, conf.con_value);
                    log.Info("Respuesta serviceErpAsesoresBusiness.SynchronizeErpAsesoresDACS(authenticateEntity): " + JsonConvert.SerializeObject(model.resultDACSAsesores));

                    //Actualizo la fecha de ultima actualizacion con del dia que es la ultima actualizacion
                    conf.con_value = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                    serviceConfigurationBusiness.Update(conf);
                }

                if (arregloTablasItris.Contains(ITRIS_CLASE_LOCALIDADES))
                {
                    //Obtengo fecha ultima actualizacion de la tabla de configuraciones
                    Func <tbConfiguration, bool> predicado = x => x.con_code == LAST_SYNC_LOCALIDADES;
                    var listRead = (List <tbConfiguration>)serviceConfigurationBusiness.Read(predicado);
                    var conf     = listRead.FirstOrDefault();

                    authenticateEntity = new ItrisAuthenticateEntity(ITRIS_SERVER, ITRIS_PUERTO_API3, ITRIS_CLASE_LOCALIDADES,
                                                                     ITRIS_API3_APP, ITRIS_API3_CONFIG, ITRIS_API3_USER, ITRIS_API3_PASS);
                    ServiceErpLocalidadesBusiness serviceErpLocalidadesBusiness = new ServiceErpLocalidadesBusiness();

                    //Actualizo base de datos local respecto de las modificaciones en la base de itris
                    log.Info("Ejecuta serviceErpLocalidadesBusiness.SynchronizeErpLocalidadesDACS(authenticateEntity)");
                    model.resultDACSLocalidades = serviceErpLocalidadesBusiness.SynchronizeErpLocalidadesDACS(authenticateEntity, conf.con_value);
                    log.Info("Respuesta serviceErpLocalidadesBusiness.SynchronizeErpLocalidadesDACS(authenticateEntity): " + JsonConvert.SerializeObject(model.resultDACSLocalidades));

                    //Actualizo la fecha de ultima actualizacion con del dia que es la ultima actualizacion
                    conf.con_value = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                    serviceConfigurationBusiness.Update(conf);
                }

                if (arregloTablasItris.Contains(ITRIS_CLASE_ARTICULOS))
                {
                    //Obtengo fecha ultima actualizacion de la tabla de configuraciones
                    Func <tbConfiguration, bool> predicado = x => x.con_code == LAST_SYNC_ARTICULO;
                    var listRead = (List <tbConfiguration>)serviceConfigurationBusiness.Read(predicado);
                    var conf     = listRead.FirstOrDefault();

                    authenticateEntity = new ItrisAuthenticateEntity(ITRIS_SERVER, ITRIS_PUERTO_API3, ITRIS_CLASE_ARTICULOS,
                                                                     ITRIS_API3_APP, ITRIS_API3_CONFIG, ITRIS_API3_USER, ITRIS_API3_PASS);
                    ServiceArticuloBusiness serviceArticuloBusiness = new ServiceArticuloBusiness();

                    //Actualizo base de datos local respecto de las modificaciones en la base de itris
                    log.Info("Ejecuta serviceArticuloBusiness.SynchronizeArticuloDACS(authenticateEntity)");
                    model.resultDACSArticulos = serviceArticuloBusiness.SynchronizeArticuloDACS(authenticateEntity, conf.con_value);
                    log.Info("Respuesta serviceArticuloBusiness.SynchronizeArticuloDACS(authenticateEntity): " + JsonConvert.SerializeObject(model.resultDACSArticulos));

                    //Actualizo la fecha de ultima actualizacion con del dia que es la ultima actualizacion
                    conf.con_value = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                    serviceConfigurationBusiness.Update(conf);
                }

                response = Request.CreateResponse(HttpStatusCode.Created, model);
            }
            catch (Exception ex)
            {
                log.Error("Mensaje de Error: " + ex.Message);
                if (ex.InnerException != null)
                {
                    log.Error("Inner exception: " + ex.InnerException.Message);
                }

                response = Request.CreateResponse(HttpStatusCode.BadRequest, ex.Message);
            }

            log.Info("Salio Synchronize");
            return(response);
        }