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
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)
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
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
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
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
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
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
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
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
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
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
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
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
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):]
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
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
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
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
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
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
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
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
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
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
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
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))
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
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))
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
