Пример #1
0
    def crear_registro_devolucion_tienda(self, linea):

        codigo = linea["codcomanda"]
        curDevolT = qsatype.FLSqlCursor("eg_devolucionestienda")
        curDevolT.select("codcomandaoriginal = '" + "WEB" +
                         str(self.init_data["increment_id"]) +
                         "' AND coddevolucion = '" + str(codigo) + "'")
        if curDevolT.first():
            return True

        curDevolT = qsatype.FLSqlCursor("eg_devolucionestienda")
        curDevolT.setModeAccess(curDevolT.Insert)
        curDevolT.refreshBuffer()
        curDevolT.setValueBuffer("codcomandaoriginal",
                                 "WEB" + str(self.init_data["increment_id"]))
        curDevolT.setValueBuffer("coddevolucion", str(codigo))
        curDevolT.setValueBuffer("sincronizada", True)
        curDevolT.setValueBuffer("fecha", str(qsatype.Date())[:10])
        curDevolT.setValueBuffer("hora", self.get_hora(str(qsatype.Date())))
        curDevolT.setValueBuffer(
            "idsincro",
            str(codigo) + "_" + str(curDevolT.valueBuffer("id")))
        curDevolT.setValueBuffer("codtienda", "AWEB")

        if "items_requested" in self.init_data:
            curDevolT.setValueBuffer("codcomandacambio", str(codigo))
            curDevolT.setValueBuffer("cambio", True)
        else:
            curDevolT.setNull("codcomandacambio")
            curDevolT.setValueBuffer("cambio", False)

        if not curDevolT.commitBuffer():
            return False

        return True
Пример #2
0
    def diagnosis_field_ultsincro(self, model):
        q = qsatype.FLSqlQuery()
        q.setSelect("timestamp, texto")
        q.setFrom("yb_log")
        q.setWhere(
            "cliente = '{}' AND tipo = '{}' AND texto LIKE 'Exito%' ORDER BY timestamp DESC LIMIT 1"
            .format(model.cliente.cliente, model.proceso))

        if not q.exec_():
            return "Error. Falló la query."

        if not q.first():
            return "No hay registros."

        tm = qsatype.Date(q.value("timestamp"))
        stm = tm.toString()
        f = stm[:10]
        h = stm[11:19]
        ahora = qsatype.Date()
        if f == ahora.toString()[:10]:
            if parseFloat(str(ahora - tm)[2:4]) < 10.0:
                return "Sincronizado {}".format(h)
            f = "Hoy"
        elif f == qsatype.FLUtil.addDays(qsatype.Date(), -1)[:10]:
            f = "Ayer"
        else:
            f = qsatype.FLUtil.dateAMDtoDMA(f)

        return "{} - {}".format(f, h)
Пример #3
0
    def elganso_sync_eglogtarjetasweb(self, params):
        try:
            if "auth" not in self.params:
                self.params = syncppal.iface.get_param_sincro('apipass')
            if "passwd" in params and params['passwd'] == self.params['auth']:

                if "customer" not in params:
                    return {"Error": "Formato Incorrecto. No viene informado el parametro customer", "status": 0}

                if "email" not in params["customer"]:
                    return {"Error": "Formato Incorrecto. No viene informado el parametro email", "status": 0}

                curLogTarjetasWeb = qsatype.FLSqlCursor("eg_logtarjetasweb")
                curLogTarjetasWeb.setModeAccess(curLogTarjetasWeb.Insert)
                curLogTarjetasWeb.refreshBuffer()
                curLogTarjetasWeb.setValueBuffer("procesado", False)
                curLogTarjetasWeb.setValueBuffer("fechaalta", str(qsatype.Date())[:10])
                curLogTarjetasWeb.setValueBuffer("horaalta", str(qsatype.Date())[-8:])
                curLogTarjetasWeb.setValueBuffer("email", str(params["customer"]["email"]))
                curLogTarjetasWeb.setValueBuffer("website", "magento2")
                curLogTarjetasWeb.setValueBuffer("cuerpolog", str(params["customer"]))
                if not curLogTarjetasWeb.commitBuffer():
                    return False
                return True
            else:
                return {"Error": "Petición Incorrecta", "status": 10}
        except Exception as e:
            print(e)
            qsatype.debug(ustr(u"Error inesperado", e))
            return {"Error": "Petición Incorrecta", "status": 0}
        return False
Пример #4
0
    def crear_registro_puntos(self):
        canPuntos = parseFloat(self.init_data["discount_refunded"])
        if self.init_data["tipo_linea"] == "PuntosNegativos":
            canPuntos = canPuntos * (-1)

        curMP = qsatype.FLSqlCursor("tpv_movpuntos")
        curMP.setModeAccess(curMP.Insert)
        curMP.setActivatedCommitActions(False)
        curMP.refreshBuffer()
        curMP.setValueBuffer("codtarjetapuntos",
                             str(self.get_codtarjetapuntos()))
        curMP.setValueBuffer("fecha", str(qsatype.Date())[:10])
        curMP.setValueBuffer("fechamod", str(qsatype.Date())[:10])
        curMP.setValueBuffer("horamod", self.get_hora(str(qsatype.Date())))
        curMP.setValueBuffer("canpuntos", canPuntos)
        curMP.setValueBuffer("operacion", self.init_data["codcomanda"])
        curMP.setValueBuffer("sincronizado", False)
        curMP.setValueBuffer("codtienda", "AWEB")

        if not qsatype.FactoriaModulos.get(
                'flfact_tpv').iface.controlIdSincroMovPuntos(curMP):
            return False

        if not curMP.commitBuffer():
            return False

        if not qsatype.FLUtil.execSql(
                ustr(
                    u"UPDATE tpv_tarjetaspuntos SET saldopuntos = CASE WHEN (SELECT SUM(canpuntos) FROM tpv_movpuntos WHERE codtarjetapuntos = tpv_tarjetaspuntos.codtarjetapuntos) IS NULL THEN 0 ELSE (SELECT SUM(canpuntos) FROM tpv_movpuntos WHERE codtarjetapuntos = tpv_tarjetaspuntos.codtarjetapuntos) END WHERE codtarjetapuntos = '{}'"
                    .format(str(self.get_codtarjetapuntos())))):
            return False

        return True
Пример #5
0
    def crear_lineas_viaje_recogidatienda(self, id_viaje, linea, num_linea,
                                          codtiendaentrega):

        if parseFloat(linea["qty"]) <= 0:
            raise NameError(
                "La cantidad de la línea es menor o igual que cero.")
            return False

        curLV = qsatype.FLSqlCursor("tpv_lineasmultitransstock")
        curLV.setModeAccess(curLV.Insert)
        curLV.setActivatedCommitActions(False)
        curLV.setActivatedCheckIntegrity(False)
        curLV.refreshBuffer()
        curLV.setValueBuffer("idviajemultitrans", id_viaje)
        curLV.setValueBuffer("referencia", self.get_referencia(linea["sku"]))
        curLV.setValueBuffer("descripcion", self.get_descripcion(linea["sku"]))
        curLV.setValueBuffer("barcode", self.get_barcode(linea["sku"]))
        curLV.setValueBuffer("talla", self.get_talla(linea["sku"]))
        curLV.setValueBuffer("codalmaorigen", "AWEB")
        curLV.setValueBuffer("codalmadestino", str(codtiendaentrega))
        curLV.setValueBuffer("estado", "RECIBIDO")
        curLV.setValueBuffer("cantidad", parseFloat(linea["qty"]))
        curLV.setValueBuffer("numlinea", num_linea)
        curLV.setValueBuffer("cantpteenvio", 0)
        curLV.setValueBuffer("cantenviada", parseFloat(linea["qty"]))
        curLV.setValueBuffer("cantpterecibir", parseFloat(linea["qty"]))
        curLV.setValueBuffer("cantrecibida", parseFloat(linea["qty"]))
        curLV.setValueBuffer("excentral", "OK")
        curLV.setValueBuffer("extienda", "OK")
        curLV.setValueBuffer("rxcentral", "OK")
        curLV.setValueBuffer("rxtienda", "OK")
        curLV.setValueBuffer("ptestockcentral", False)
        curLV.setValueBuffer("cerradorx", False)
        curLV.setValueBuffer("cerradoex", False)
        curLV.setValueBuffer("revisada", False)
        curLV.setValueBuffer("ptestockrx", False)
        curLV.setValueBuffer("fechaex", str(qsatype.Date())[:10])
        curLV.setValueBuffer("horaex", self.get_hora(str(qsatype.Date())))
        curLV.setValueBuffer("fecharx", str(qsatype.Date())[:10])
        curLV.setValueBuffer("horarx", self.get_hora(str(qsatype.Date())))
        curLV.setValueBuffer("idsincro",
                             "CENTRAL_" + str(curLV.valueBuffer("idlinea")))

        if not curLV.commitBuffer():
            raise NameError("Error al guardar la línea del viaje.")
            return False

        if not qsatype.FactoriaModulos.get(
                "flfactalma").iface.generarEstructuraMTOrigen(curLV):
            raise NameError(
                "No se ha podido crear los movimientos de stock de origen.")
            return False

        if not qsatype.FactoriaModulos.get(
                "flfactalma").iface.generarEstructuraMTDestino(curLV):
            raise NameError(
                "No se ha podido crear los movimientos de stock de destino.")
            return False

        return True
Пример #6
0
    def crear_linearegstock(self, refArticulo, talla, qty, cod_almacen):

        id_stock = qsatype.FLUtil.sqlSelect("stocks", "idstock", "referencia = '{}' AND talla = '{}' AND codalmacen = '{}'".format(str(refArticulo), str(talla), str(cod_almacen)))
        barCode = qsatype.FLUtil.sqlSelect("atributosarticulos", "barcode", "referencia = '{}' AND talla = '{}'".format(str(refArticulo), str(talla)))
        if not id_stock:
            oArticulo = {}
            oArticulo["referencia"] = refArticulo
            oArticulo["barcode"] = barCode
            id_stock = qsatype.FactoriaModulos.get('flfactalma').iface.crearStock(cod_almacen, oArticulo)
            if not id_stock or str(id_stock) == "None":
                raise NameError("No se ha encontrado idstock para el barcode: " + str(barCode))
                return False

        curLineaRegStock = qsatype.FLSqlCursor("lineasregstocks")
        curLineaRegStock.setModeAccess(curLineaRegStock.Insert)
        curLineaRegStock.refreshBuffer()
        curLineaRegStock.setValueBuffer("idstock", id_stock)
        curLineaRegStock.setValueBuffer("fecha", qsatype.Date())
        curLineaRegStock.setValueBuffer("hora", str(qsatype.Date())[-8:])
        curLineaRegStock.setValueBuffer("cantidadini", qsatype.FLUtil.sqlSelect("stocks", "cantidad", "idstock = {}".format(id_stock)))
        curLineaRegStock.setValueBuffer("cantidadfin", qty)
        curLineaRegStock.setValueBuffer("barcode", barCode)
        curLineaRegStock.setValueBuffer("referencia", refArticulo)
        curLineaRegStock.setValueBuffer("talla", talla)

        if not curLineaRegStock.commitBuffer():
            return False

        return True
Пример #7
0
    def sanhigia_sync_cerrarVentaWeb(self, curPedido):
        _i = self.iface

        try:
            idComanda = curPedido.valueBuffer("idtpv_comanda")

            codArqueo = _i.crearArqueoVentaWeb(curPedido)
            if not codArqueo:
                syncppal.iface.log(ustr("Error. No se pudo crear el arqueo"), "shsyncorders")
                return False

            if not _i.crearPagoVentaWeb(curPedido, codArqueo):
                syncppal.iface.log(ustr("Error. No se pudo crear el pago para el arqueo ", str(codArqueo)), "shsyncorders")
                return False

            if not qsatype.FLSqlQuery().execSql(u"UPDATE tpv_comandas SET estado = 'Cerrada', editable = true, pagado = total WHERE idtpv_comanda = " + str(idComanda)):
                syncppal.iface.log(ustr("Error. No se pudo cerrar la venta ", str(idComanda)), "shsyncorders")
                return False

            d = qsatype.Date()
            if not qsatype.FactoriaModulos.get('formtpv_tiendas').iface.marcaFechaSincroTienda("AWEB", "VENTAS_TPV", d):
                return False

            return True

        except Exception as e:
            qsatype.debug(e)
            return False
Пример #8
0
    def get_data(self):

        idarqueo = self.init_data["idarqueo"]
        if not idarqueo:
            return False

        self.set_data_value("anulado", False)
        self.set_data_value("editable", True)
        self.set_data_value("nogenerarasiento", True)
        self.set_string_value("estado", "Pagado")
        self.set_string_value("codtienda", self.init_data["codtienda"])
        self.set_string_value("codtpv_agente", "0350")
        self.set_string_value("codtpv_puntoventa",
                              self.init_data["puntoventa"])
        self.set_string_value("fecha", str(qsatype.Date())[:10])
        self.set_string_value("idtpv_arqueo", idarqueo, max_characters=8)
        self.set_string_value("codcomanda", str(self.init_data["codcomanda"]))

        importe = float(
            self.init_data["total_pay"]) * self.init_data["tasaconv"]
        if str(self.init_data["tipo_pago"]) == "Negativo":
            importe = importe * (-1)
        self.set_string_value("importe", importe)

        codPago = self.get_codpago()
        self.set_string_value("codpago", codPago)

        return True
Пример #9
0
    def crear_registro_movistock(self, cursor):
        codtiendaentrega = "AWEB"
        if "codtiendaentrega" in self.data and parseFloat(cursor.valueBuffer("cantidad")) < 0:
            codtiendaentrega = str(self.data["codtiendaentrega"])

        idStock = str(qsatype.FLUtil.quickSqlSelect("stocks", "idstock", "barcode = '" + str(cursor.valueBuffer("barcode")) + "' AND codalmacen = 'AWEB'"))
        if not idStock or str(idStock) == "None":
            raise NameError("No se ha encontrado idstock para el barcode: " + str(cursor.valueBuffer("barcode")))
            return False

        curMoviStock = qsatype.FLSqlCursor("movistock")
        curMoviStock.setModeAccess(curMoviStock.Insert)
        curMoviStock.refreshBuffer()
        curMoviStock.setValueBuffer("idlineaco", cursor.valueBuffer("idtpv_linea"))
        if str(codtiendaentrega) == "AWEB":
            curMoviStock.setValueBuffer("estado", "PTE")
        else:
            curMoviStock.setValueBuffer("estado", "HECHO")
            now = str(qsatype.Date())
            current_date = now[:10]
            current_time = now[-(8):]
            curMoviStock.setValueBuffer("fechareal", current_date)
            curMoviStock.setValueBuffer("horareal", current_time)

        curMoviStock.setValueBuffer("cantidad", (parseFloat(cursor.valueBuffer("cantidad")) * (-1)))
        curMoviStock.setValueBuffer("referencia", str(cursor.valueBuffer("referencia")))
        curMoviStock.setValueBuffer("barcode", str(cursor.valueBuffer("barcode")))
        curMoviStock.setValueBuffer("idstock", idStock)
        curMoviStock.setValueBuffer("concepto", "DEVOLUCION " + str(cursor.valueBuffer("codcomanda")))
        if not curMoviStock.commitBuffer():
            return False

        return True
Пример #10
0
    def get_data(self):
        q = qsatype.FLSqlQuery()
        q.setSelect("smw.referencia, smw.talla, smw.cantidad, smw.id, smw.idstock, s.codalmacen")
        q.setFrom("eg_sincromovistockweb  smw INNER JOIN stocks s ON smw.idstock = s.idstock")
        q.setWhere("NOT smw.sincronizado OR smw.sincronizado = false ORDER BY smw.referencia LIMIT 25")

        q.exec_()

        body = []
        if not q.size():
            return body

        while q.next():
            sku = self.dame_sku(q.value("smw.referencia"), q.value("smw.talla"))
            cant_disponible = parseInt(q.value("cantidad"))
            hoy = qsatype.Date()
            
            aListaAlmacenes = self.dame_almacenessincroweb().split(",")
            if q.value("s.codalmacen") not in aListaAlmacenes:
                raise NameError("Error. Existe un registro cuyo almacen no está en la lista de almacenes de sincronización con Magento. " + str(q.value("ssw.idssw")))


            body.append({"sku": sku, "qty": cant_disponible, "almacen": q.value("s.codalmacen")})

            if not self._smsw:
                self._smsw = ""
            else:
                self._smsw += ","
            self._smsw += str(q.value("smw.id"))

        return body
Пример #11
0
    def gesttare_validar_user(self, model, oParam, cursor):
        if cursor.valueBuffer("validado_user"):
            return True

        if "confirmacion" not in oParam:
            resul = {}
            if cursor.valueBuffer(
                    "horasordinarias") < flgesttare_def.iface.time_to_seconds(
                        cursor.valueBuffer("horasextra")):
                resul["status"] = 1
                resul[
                    "msg"] = "Las horas extraordinarias no pueden superar el total de tiempo"
                return resul
            resul['status'] = 2
            resul[
                'confirm'] = "Vas a validar el mes con los siguientes datos: " + str(
                    cursor.valueBuffer("horasordinariasstring")
                ) + " como tiempo de trabajo ordinario, y " + str(
                    cursor.valueBuffer("horasextra")
                ) + " como tiempo de trabajo extraordinario. ¿Son correctos los datos?"
            resul["msg"] = "Validado como trabajador"
            return resul
        else:
            now = str(qsatype.Date())
            fecha = now[:10]
            cursor.setValueBuffer("validado_user", True)
            cursor.setValueBuffer("fechavalidadouser", fecha)
            if not cursor.commitBuffer():
                return False

        return True
Пример #12
0
    def crear_viaje_recogidatienda(self, codcomanda, codtiendaentrega):

        id_viaje = qsatype.FactoriaModulos.get(
            "formRecordtpv_comandas").iface.obtenerIdViaje()

        if not id_viaje or str(id_viaje) == "None" or id_viaje == None:
            raise NameError("No se ha podido calcular el idviaje.")
            return False

        cantidad_viaje = 0
        for linea in self.init_data["items_refunded"]:
            cantidad_viaje += parseFloat(linea["qty"])

        if cantidad_viaje <= 0:
            raise NameError(
                "La cantidad para crear el viaje es menor o igual que cero.")
            return False

        nombre_destino = str(
            qsatype.FLUtil.quickSqlSelect(
                "almacenes", "nombre",
                "codalmacen = '" + str(codtiendaentrega) + "'"))
        curViaje = qsatype.FLSqlCursor("tpv_viajesmultitransstock")
        curViaje.setModeAccess(curViaje.Insert)
        curViaje.refreshBuffer()
        curViaje.setValueBuffer("idviajemultitrans", id_viaje)
        curViaje.setValueBuffer("fecha", qsatype.Date())
        curViaje.setValueBuffer("codalmaorigen", "AWEB")
        curViaje.setValueBuffer("nombreorigen", "WEB")
        curViaje.setValueBuffer("codalmadestino", str(codtiendaentrega))
        curViaje.setValueBuffer("nombredestino", nombre_destino)
        curViaje.setValueBuffer("cantidad", cantidad_viaje)
        curViaje.setValueBuffer("estado", "RECIBIDO")
        curViaje.setValueBuffer("enviocompletado", True)
        curViaje.setValueBuffer("ptesincroenvio", True)
        curViaje.setValueBuffer("recepcioncompletada", True)
        curViaje.setValueBuffer("azkarok", False)
        curViaje.setValueBuffer("egnumseguimiento", codcomanda)

        if not curViaje.commitBuffer():
            raise NameError("Error al guardar la cabecera del viaje.")
            return False

        num_linea = 1
        for linea in self.init_data["items_refunded"]:
            if not self.crear_lineas_viaje_recogidatienda(
                    id_viaje, linea, num_linea, str(codtiendaentrega)):
                raise NameError("Error al crear las líneas del viaje.")
                return False
            num_linea += 1

        if not qsatype.FLUtil.execSql(
                "INSERT INTO eg_viajeswebtiendaptes (idviajemultitrans) VALUES ('"
                + str(id_viaje) + "')"):
            raise NameError(
                "Error al insertar el registro en eg_viajeswebtiendaptes.")
            return False

        return True
Пример #13
0
    def diagnosis_checkContinuos(self, cliente, proceso):
        _i = self.iface
        response = {}

        hSyncCont = datetime.datetime.now() - _i.dameTiempoSincro("continuo")
        sincronizadosCont = qsatype.FLUtil.sqlSelect(
            "yb_log", "COUNT(*)",
            "cliente = '" + cliente + "' AND timestamp >= '" + str(hSyncCont) +
            "' AND tipo = '" + proceso + "' AND texto NOT LIKE 'Info.%'")

        hSyncHora = datetime.datetime.now() - datetime.timedelta(hours=1)
        sincronizadosHora = qsatype.FLUtil.sqlSelect(
            "yb_log", "COUNT(*)",
            "cliente = '" + cliente + "' AND timestamp >= '" + str(hSyncHora) +
            "' AND tipo = '" + proceso + "' AND texto NOT LIKE 'Info.%'")

        errores = qsatype.FLUtil.sqlSelect(
            "yb_log", "texto LIKE '%Error%'", "cliente = '" + cliente +
            "' AND tipo = '" + proceso + "' ORDER BY timestamp DESC LIMIT 1")

        if sincronizadosCont == 0:
            curProc = qsatype.FLSqlCursor("yb_procesos")
            curProc.select("proceso = '" + proceso + "' AND cliente = '" +
                           cliente + "'")
            if not curProc.first():
                return False
            if not curProc.valueBuffer("activo"):
                return {"status": "ok"}
            qsatype.FLSqlQuery().execSql(
                "INSERT INTO yb_log (texto, cliente, tipo, timestamp) VALUES ('Info. Detectado bloqueo', '"
                + cliente + "', '" + proceso + "', '" + qsatype.Date().now() +
                "')")
            # yb_procesos.stop(None, curProc)
            # curProc.setValueBuffer("activo", False)
            # time.sleep(200)
            # yb_procesos.start(None, curProc)

            response = {"status": "ok"}
            status = notifications.sendNotification(
                "Error. " + proceso + " - " + cliente, "Reinicie proceso",
                _i.dameNotificadosSincro("continuo"))
            if status:
                response = {"status": "ok"}
            else:
                response = {"status": "error"}
        elif errores or sincronizadosHora == 0:
            response = {"status": "ok"}
            status = notifications.sendNotification(
                proceso + " - " + cliente, "Error sincronización",
                _i.dameNotificadosSincro("continuo"))
            if status:
                response = {"status": "ok"}
            else:
                response = {"status": "error"}
        else:
            response = {"status": "ok"}
        qsatype.debug(ustr(proceso, response))

        return response
Пример #14
0
    def get_hora(self):
        # hour = self.init_data["created_at"][-(8):]
        # hour = "23:59:59" if hour == "00:00:00" else hour

        now = str(qsatype.Date())
        hour = now[-(8):]

        return hour
Пример #15
0
    def __init__(self, process_name, params=None):
        self.process_name = process_name
        self.params = params

        self.logs = []

        now = str(qsatype.Date())
        self.start_date = now[:10]
        self.start_time = now[-(8):]
Пример #16
0
    def get_data(self):
        existe_tarjeta = qsatype.FLUtil.sqlSelect(
            "tpv_tarjetaspuntos", "codtarjetapuntos",
            "email = '" + str(self.init_data["email"]) + "'")

        if existe_tarjeta:
            raise NameError("La tarjeta con email " +
                            str(self.init_data["email"]) +
                            " ya existe en la BBDD.")
            return False

        codtarjeta = self.get_codtarjeta("AWEB")
        self.set_data_value("activa", True)
        self.set_string_value("nombre", str(self.init_data["nombre"]))
        self.set_data_value("sincronizada", True)
        self.set_string_value("telefono", str(self.init_data["telefono"]))
        self.set_string_value("email", str(self.init_data["email"]))
        if str(self.init_data["cifnif"]) == "None":
            self.set_string_value("cifnif", "-")
        else:
            self.set_string_value("cifnif", str(self.init_data["cifnif"]))
        self.set_string_value("direccion", str(self.init_data["direccion"]))
        self.set_string_value("provincia", str(self.init_data["provincia"]))
        self.set_string_value("ciudad", str(self.init_data["ciudad"]))
        self.set_string_value("codpais", str(self.init_data["codpais"]))
        self.set_string_value("codpostal", str(self.init_data["codpostal"]))
        if str(self.init_data["genero"]) == "1":
            self.set_string_value("sexo", "Masculino")
        elif str(self.init_data["genero"]) == "1":
            self.set_string_value("sexo", "Femenino")
        else:
            self.set_string_value("sexo", "-")

        self.set_string_value("codtarjetapuntos", str(codtarjeta))
        self.set_string_value("codbarrastarjeta", str(codtarjeta))
        self.set_string_value("fechaalta", str(qsatype.Date())[:10])
        self.set_string_value("horaalta", str(qsatype.Date())[-8:])
        self.set_string_value("fechamod", str(qsatype.Date())[:10])
        self.set_string_value("horamod", str(qsatype.Date())[-8:])
        self.set_string_value("idusuariomod", str("sincro"))
        self.set_string_value("idusuarioalta", str("sincro"))

        return True
Пример #17
0
    def elganso_sync_acumularPuntosOperacionesMagento(self, params):
        curTpvTarjetas = qsatype.FLSqlCursor("tpv_tarjetaspuntos")
        q = qsatype.FLSqlQuery()
        q.setSelect("codtarjetapuntos, saldopuntos")
        q.setFrom("tpv_tarjetaspuntos")
        q.setWhere("email = '" + str(params['email']) + "'")

        if not q.exec_():
            return False

        while q.next():

            curTpvTarjetas.select("codtarjetapuntos = '" + q.value("codtarjetapuntos") + "'")
            if not curTpvTarjetas.first():
                return False

            curTpvTarjetas.setModeAccess(curTpvTarjetas.Edit)
            curTpvTarjetas.refreshBuffer()

            curMP = qsatype.FLSqlCursor("tpv_movpuntos")
            curMP.setModeAccess(curMP.Insert)
            curMP.refreshBuffer()
            curMP.setValueBuffer("codtarjetapuntos", str(q.value("codtarjetapuntos")))
            curMP.setValueBuffer("fecha", str(qsatype.Date())[:10])
            curMP.setValueBuffer("fechamod", str(qsatype.Date())[:10])
            curMP.setValueBuffer("horamod", str(qsatype.Date())[-(8):])
            curMP.setValueBuffer("canpuntos", params['canpuntos'])
            curMP.setValueBuffer("operacion", str(params['operacion']))
            curMP.setValueBuffer("sincronizado", True)
            curMP.setValueBuffer("codtienda", "AWEB")

            if not qsatype.FactoriaModulos.get('flfact_tpv').iface.controlIdSincroMovPuntos(curMP):
                return False

            if not curMP.commitBuffer():
                return False

            if not curTpvTarjetas.commitBuffer():
                return False

            params["saldo"] = qsatype.FactoriaModulos.get("formRecordtpv_tarjetaspuntos").iface.pub_commonCalculateField("saldopuntos", curTpvTarjetas)

        return True
Пример #18
0
    def diagnosis_field_timestamp(self, model):
        tm = None
        if isinstance(model, dict):
            tm = model["yb_log.timestamp"]
        else:
            tm = model.timestamp

        stm = str(tm)
        f = stm[:10]
        h = stm[11:19]
        ahora = qsatype.Date()
        if f == ahora.toString()[:10]:
            f = "Hoy"
        elif f == qsatype.FLUtil.addDays(qsatype.Date(), -1)[:10]:
            f = "Ayer"
        else:
            f = qsatype.FLUtil.dateAMDtoDMA(f)

        return f + " - " + h
Пример #19
0
    def elganso_sync_quitarPuntosTarjetaOrigen(self, params):
        curTpvTarjetas = qsatype.FLSqlCursor("tpv_tarjetaspuntos")
        q = qsatype.FLSqlQuery()
        q.setSelect("codtarjetapuntos, saldopuntos")
        q.setFrom("tpv_tarjetaspuntos")
        q.setWhere("email = '" + str(params['emailOrigen']) + "'")

        if not q.exec_():
            return False

        while q.next():

            curTpvTarjetas.select("codtarjetapuntos = '" + q.value("codtarjetapuntos") + "'")
            if not curTpvTarjetas.first():
                return False

            curTpvTarjetas.setModeAccess(curTpvTarjetas.Edit)
            curTpvTarjetas.refreshBuffer()
            saldoPuntos = float(q.value("saldopuntos")) * (-1)

            curMP = qsatype.FLSqlCursor("tpv_movpuntos")
            curMP.setModeAccess(curMP.Insert)
            curMP.refreshBuffer()
            curMP.setValueBuffer("codtarjetapuntos", str(q.value("codtarjetapuntos")))
            curMP.setValueBuffer("fecha", str(qsatype.Date())[:10])
            curMP.setValueBuffer("fechamod", str(qsatype.Date())[:10])
            curMP.setValueBuffer("horamod", str(qsatype.Date())[-(8):])
            curMP.setValueBuffer("canpuntos", saldoPuntos)
            curMP.setValueBuffer("operacion", "UNIFICACION PUNTOS " + str(params['emailDestino']))
            curMP.setValueBuffer("sincronizado", False)
            curMP.setValueBuffer("codtienda", "AWEB")

            if not qsatype.FactoriaModulos.get('flfact_tpv').iface.controlIdSincroMovPuntos(curMP):
                return False

            if not curMP.commitBuffer():
                return False

            if not curTpvTarjetas.commitBuffer():
                return False

        return True
Пример #20
0
    def get_data(self):

        barcode = str(self.init_data["s.barcode"])
        referencia = str(self.init_data["s.referencia"]) + "-" + str(
            self.init_data["s.talla"])
        if str(self.init_data["s.talla"]) == "TU":
            referencia = str(self.init_data["s.referencia"])

        self.set_string_value("sku", referencia)
        self.set_string_value("source_code",
                              str(self.init_data["s.codalmacen"]))

        hoy = qsatype.Date()
        stockReservado = qsatype.FLUtil.sqlSelect(
            "eg_anulacionstockreservado", "idstock",
            "idstock = {} AND activo = true AND fechatope >= '{}'".format(
                self.init_data["s.idstock"], hoy))
        if stockReservado and stockReservado != 0:
            cantA = parseInt(
                qsatype.FLUtil.sqlSelect(
                    "eg_anulacionstockreservado", "cantstockreservadoanulado",
                    "idstock = {} AND activo = true AND fechatope >= '{}'".
                    format(self.init_data["s.idstock"], hoy)))
            if not cantA:
                cantA = 0

            qty = parseInt(self.dame_stock(
                self.init_data["s.disponible"])) + cantA
        else:
            qty = parseInt(self.dame_stock(self.init_data["s.disponible"]))

        aListaAlmacenes = self.dame_almacenessincroweb().split(",")
        if str(self.init_data["s.codalmacen"]) not in aListaAlmacenes:
            raise NameError(
                "Error. Existe un registro cuyo almacén no está en la lista de almacenes de sincronización con Magento. "
                + str(self.init_data["ssw.idssw"]))

        cant_disponible = qty
        if str(str(self.init_data["s.codalmacen"])) != "AWEB":
            cant_reservada = self.get_cantreservada(
                str(self.init_data["s.codalmacen"]))
            cant_disponible = parseFloat(qty) - parseFloat(cant_reservada)

        cant_rv = self.get_reservado(barcode,
                                     str(self.init_data["s.codalmacen"]))
        cant_disponible += cant_rv

        status = 0
        if cant_disponible > 0:
            status = 1

        self.set_string_value("quantity", cant_disponible)
        self.set_string_value("status", status)
        return True
Пример #21
0
    def gesttare_desbloquear_user(self, model, cursor):
        if not cursor.valueBuffer("validado_user"):
            return True
        now = str(qsatype.Date())
        fecha = now[:10]
        cursor.setValueBuffer("validado_user", False)
        cursor.setValueBuffer("fechavalidadouser", fecha)
        if not cursor.commitBuffer():
            return False

        return True
Пример #22
0
    def elganso_sync_desuscribesm(self, params):
        try:
            bdparams = self.params
            if "auth" not in bdparams:
                bdparams = syncppal.iface.get_param_sincro('apipass')
            if "passwd" in params and params['passwd'] == bdparams['auth']:
                if "email" not in params:
                    return {"Error": "Formato Incorrecto", "status": -1}
                qsatype.debug(ustr(u"desuscribesm: ", params['email']))
                curTpvTarjetas = qsatype.FLSqlCursor(u"tpv_tarjetaspuntos")

                q = qsatype.FLSqlQuery()
                q.setSelect(u"codtarjetapuntos")
                q.setFrom(u"tpv_tarjetaspuntos")
                q.setWhere(ustr(u"email = '", params['email'], "'"))
                if not q.exec_():
                    return False

                while q.next():
                    curTpvTarjetas.select(ustr(u"codtarjetapuntos = '", q.value(u"codtarjetapuntos"), "'"))
                    if not curTpvTarjetas.first():
                        return False
                    curTpvTarjetas.setModeAccess(curTpvTarjetas.Edit)
                    curTpvTarjetas.refreshBuffer()
                    curTpvTarjetas.setValueBuffer("fechamod", str(qsatype.Date())[:10])
                    curTpvTarjetas.setValueBuffer("horamod", str(qsatype.Date())[-8:])
                    curTpvTarjetas.setValueBuffer("sincronizada", False)
                    curTpvTarjetas.setValueBuffer("suscritocrm", False)
                    if not curTpvTarjetas.commitBuffer():
                        return False

                return True
            else:
                return {"Error": "Formato Incorrecto", "status": -1}
        except Exception as e:
            qsatype.debug(ustr(u"Error inesperado desuscribesm: ", e))
            return {"Error": "Petición Incorrecta", "status": 0}
        return False
Пример #23
0
    def cerrar_devolucionweb(self, codigo):

        idComandaPago = qsatype.FLUtil.sqlSelect(
            "tpv_comandas c INNER JOIN tpv_pagoscomanda p ON c.idtpv_comanda = p.idtpv_comanda",
            "p.idtpv_comanda", "c.codigo = '" + str(codigo) + "'")
        if idComandaPago:
            raise NameError("La devolución ya tiene un pago creado.")
            return False

        self.data.update({"fecha": qsatype.Date()})
        arqueo_web = EgCashCountSerializer().serialize(self.data)

        if "skip" in arqueo_web and arqueo_web["skip"]:
            self.data["children"]["cashcount"] = False
        else:
            self.data["children"]["cashcount"] = arqueo_web

        self.crear_pagos_devolucionweb(arqueo_web, codigo)

        idFactura = qsatype.FLUtil.sqlSelect("tpv_comandas", "idfactura",
                                             "codigo = '" + str(codigo) + "'")

        if (not idFactura or str(idFactura) == "None" or idFactura
                == 0) and (not "items_requested" in self.init_data):
            self.set_string_value("ptesincrofactura", True)
            self.set_string_value("fecha", str(qsatype.Date())[:10])

        self.set_string_value("estado", 'Cerrada')
        self.set_string_value("editable", True)

        if "items_requested" in self.init_data:
            self.set_string_value("pagado", "0")
        else:
            self.set_string_value("pagado",
                                  float(self.init_data["total_pay"]) * (-1))

        return True
Пример #24
0
    def after_sync(self):
        success_records = []
        error_records = [order["increment_id"] for order in self.error_data]
        after_sync_error_records = []

        for order in self.success_data:
            try:
                qsatype.FLSqlQuery().execSql(
                    "UPDATE eg_logpedidosweb SET procesado = true, fechaprocesado = CURRENT_DATE, horaprocesado = CURRENT_TIME, estadoprocesado = 'OK' WHERE idlog IN ({}) AND increment_id = '{}'"
                    .format(self.idlogs, order["increment_id"]))
                success_records.append(order["increment_id"])
            except Exception as e:
                self.after_sync_error(order, e)
                after_sync_error_records.append(order["increment_id"])

        for order in self.error_data:
            try:
                qsatype.FLSqlQuery().execSql(
                    "UPDATE eg_logpedidosweb SET procesado = true, fechaprocesado = CURRENT_DATE, horaprocesado = CURRENT_TIME, estadoprocesado = 'ERROR' WHERE idlog IN ({}) AND increment_id = '{}'"
                    .format(self.idlogs, order["increment_id"]))
            except Exception as e:
                self.after_sync_error(order, e)
                after_sync_error_records.append(order["increment_id"])

        if success_records:
            self.log(
                "Exito",
                "Los siguientes pedidos se han sincronizado correctamente: {}".
                format(success_records))

        if error_records:
            self.log(
                "Error",
                "Los siguientes pedidos no se han sincronizado correctamente: {}"
                .format(error_records))

        if after_sync_error_records:
            self.log(
                "Error",
                "Los siguientes pedidos no se han marcado como sincronizados: {}"
                .format(after_sync_error_records))

        d = qsatype.Date()
        if not qsatype.FactoriaModulos.get(
                "formtpv_tiendas").iface.marcaFechaSincroTienda(
                    "AWEB", "VENTAS_TPV", d):
            return False

        return self.small_sleep
Пример #25
0
    def crear_pedido_reserva_stock(self, codigo):

        for linea in self.init_data["items"]:
            now = str(qsatype.Date())
            self.start_date = now[:10]
            self.start_time = now[-(8):]
            curPedido = qsatype.FLSqlCursor("pedidoscli")
            curPedido.setModeAccess(curPedido.Insert)
            curPedido.refreshBuffer()
            curPedido.setValueBuffer("observaciones", codigo)
            curPedido.setValueBuffer("codejercicio", self.get_codejercicio())
            curPedido.setValueBuffer("codserie", "SW")
            curPedido.setValueBuffer("codalmacen", linea["almacen"])

            numero = qsatype.FactoriaModulos.get("flfacturac").iface.siguienteNumero("SW", self.get_codejercicio(), "npedidocli")
            curPedido.setValueBuffer("numero", numero)
            codpedido = qsatype.FactoriaModulos.get("flfacturac").iface.pub_construirCodigo("SW", self.get_codejercicio(), numero)
            curPedido.setValueBuffer("codigo", codpedido)
            curPedido.setValueBuffer("totaleuros", 0)
            curPedido.setValueBuffer("direccion", "-")
            curPedido.setValueBuffer("codpago", "CONT")
            curPedido.setValueBuffer("tasaconv", 1)
            curPedido.setValueBuffer("total", 0)
            curPedido.setValueBuffer("irpf", 0)
            curPedido.setValueBuffer("servido", "No")
            curPedido.setValueBuffer("editable", True)
            curPedido.setValueBuffer("cifnif", "-")
            curPedido.setValueBuffer("recfinanciero", 0)
            curPedido.setValueBuffer("fecha", now)
            curPedido.setValueBuffer("neto", 0)
            curPedido.setValueBuffer("totalirpf", 0)
            curPedido.setValueBuffer("totaliva", 0)
            curPedido.setValueBuffer("fechasalida", now)
            curPedido.setValueBuffer("egenviado", False)
            curPedido.setValueBuffer("coddivisa", "EUR")

            if not curPedido.commitBuffer():
                raise NameError("Error al guardar la cabecera del pedido.")
                return False

            if not curPedido.valueBuffer("idpedido") or str(curPedido.valueBuffer("idpedido")) == "None":
                return False

            cont = 1
            if not self.crear_linea_pedido_reserva_stock(cont, linea, curPedido.valueBuffer("idpedido")):
                raise NameError("Error al crear la línea del pedido de reserva de stock.")
                return False

        return True
Пример #26
0
    def gesttare_desbloquear_admin(self, model, cursor):
        if not cursor.valueBuffer("validado_admin"):
            return True

        usuario = qsatype.FLUtil.nameUser()
        now = str(qsatype.Date())
        fecha = now[:10]
        cursor.setValueBuffer("idadmin", usuario)
        cursor.setValueBuffer("idvalidador", usuario)
        cursor.setValueBuffer("validado_admin", False)
        cursor.setValueBuffer("fechavalidadoadmin", fecha)
        if not cursor.commitBuffer():
            return False

        return True
Пример #27
0
    def diagnosis_log(self, text, process, customer):
        tmstmp = qsatype.Date().now()
        tsDel = qsatype.FLUtil.addDays(tmstmp, -5)

        qsatype.FLSqlQuery().execSql(
            "DELETE FROM yb_log WHERE cliente = '{}' AND tipo = '{}' AND timestamp < '{}'"
            .format(customer, process, tsDel))

        grupoprocesos = qsatype.FLUtil.sqlSelect(
            "yb_procesos", "grupoprocesos",
            "cliente = '{}' AND proceso = '{}'".format(customer, process))

        qsatype.FLSqlQuery().execSql(
            "INSERT INTO yb_log (texto, cliente, tipo, grupoprocesos, timestamp) VALUES ('{}', '{}', '{}', '{}', '{}')"
            .format(text, customer, process, grupoprocesos, tmstmp))
Пример #28
0
    def blackstar_petroleum_albaranes_nuevacargapedidos(self, model):
        print("nueva carga de pedidos")
        usr = qsatype.FLUtil.nameUser()
        agente = agentes.objects.filter(dnicif__exact=usr)
        codagente = agente[0].codagente
        curLCP = qsatype.FLSqlCursor(u"bi_cargapedidoscli")
        curLCP.setModeAccess(curLCP.Insert)
        curLCP.refreshBuffer()
        curLCP.setValueBuffer("estado", "Abierta")
        curLCP.setValueBuffer("codagente", codagente)
        curLCP.setValueBuffer("fechaalta", str(qsatype.Date())[:10])

        if not curLCP.commitBuffer():
            return False
        return True
Пример #29
0
    def diagnosis_failed(self, customer, process, error, pk):
        tmstmp = qsatype.Date().now()
        tsDel = qsatype.FLUtil.addDays(tmstmp, -10)

        qsatype.FLSqlQuery().execSql(
            "DELETE FROM yb_procesos_erroneos WHERE resuelto AND cliente = '{}' AND timestamp < '{}'"
            .format(customer, tsDel))

        grupoprocesos = qsatype.FLUtil.sqlSelect(
            "yb_procesos", "grupoprocesos",
            "cliente = '{}' AND proceso = '{}'".format(customer, process))

        qsatype.FLSqlQuery().execSql(
            "INSERT INTO yb_procesos_erroneos (cliente, proceso, grupoprocesos, error, codregistro, resuelto, timestamp) VALUES ('{}', '{}', '{}', '{}', '{}', {}, '{}')"
            .format(customer, process, grupoprocesos, error, pk, False,
                    tmstmp))
Пример #30
0
    def get_data(self):
        now = str(qsatype.Date())

        self.set_string_relation("idventaweb", "order_id")
        self.set_string_value("estado", "PENDIENTE")
        self.set_string_value("datosdevol",
                              self.init_data["body"],
                              max_characters=None,
                              skip_replace=True)
        self.set_data_value("recibida", False)
        self.set_string_value("fechaalta", now[:10])
        self.set_string_value("horaalta", now[-8:])
        self.set_string_relation("date_created", "date_created")
        self.set_string_value("valdemoro", True)

        return True