def __init__( self, parent, id = 0 , code = "", description = "", monto = Decimal( 0 ), esdebe = 0, childCount = 0 ):
self.itemData = [code, description, esdebe, childCount, monto, parent, id , 0]
self.childItems = []
if self.itemData[HIJOS] > 0 and self.itemData[IDCUENTA] != 0:
query = """
SELECT
cc.codigo,
cc.descripcion,
cc.esdebe,
COUNT(ch.idcuenta) nhijos,
cc.monto,
cc.padre,
cc.idcuenta
FROM
(
SELECT
cc.* ,
SUM(IFNULL(cxd.monto,0)) monto
FROM cuentascontables cc
LEFT JOIN cuentasxdocumento cxd ON cxd.idcuenta = cc.idcuenta
WHERE cc.padre = %d
GROUP BY cc.idcuenta
) cc
LEFT JOIN cuentascontables ch ON cc.idcuenta = ch.padre
GROUP BY cc.idcuenta
""" % self.itemData[IDCUENTA]
query = QSqlQuery( query )
query.exec_()
while query.next():
self.appendChild( Account(
self, #PADRE
query.value( IDCUENTA ).toInt()[0],
query.value( CODIGO ).toString(),
query.value( DESCRIPCION ).toString(),
Decimal( query.value( MONTO ).toString() ),
query.value( ESDEBE ).toInt()[0],
query.value( HIJOS ).toInt()[0] ,
) )
elif self.itemData[IDCUENTA] == 0:
query = QSqlQuery()
if not query.prepare( """
INSERT INTO cuentascontables (padre, codigo, descripcion, esdebe)
VALUES (:padre, :codigo, :descripcion, :esdebe)
""" ):
raise Exception( "No se pudo preparar la consulta" )
query.bindValue( ":padre", self.itemData[PADRE].itemData[IDCUENTA] )
query.bindValue( ":codigo", self.itemData[CODIGO] )
query.bindValue( ":descripcion", self.itemData[DESCRIPCION] )
query.bindValue( ":esdebe", self.itemData[ESDEBE] )
if not query.exec_():
logging.critical( query.lastError().text() )
raise UserWarning( "No se pudo insertar la cuenta contable" )
self.id = query.lastInsertId().toInt()[0]
def save( self, iddocumento, nlinea ):
"""
Este metodo guarda la linea en la base de datos
@param iddocumento: El id del documento al que esta enlazada la LineAddrTable
@type iddocumento: int
@param nlinea: El numero de la linea en el documento
@type nlinea: int
"""
if not self.valid:
raise Exception ( "Se intento guardar una linea no valida" )
query = QSqlQuery()
if not query.prepare( """
INSERT INTO articulosxdocumento (iddocumento, idarticulo, unidades,
costounit, costocompra,nlinea)
VALUES( :iddocumento,:idarticulo, :unidades, :costounit, :costocompra,:linea)
""" ):
raise Exception( "No se pudo preparar la consulta para "\
+ "insertar una de las lineas del documento" )
query.bindValue( ":iddocumento", iddocumento )
query.bindValue( ":idarticulo", self.itemId )
query.bindValue( ":unidades", self.quantity )
query.bindValue( ":costounit", str( self.costoDolar ) )
query.bindValue( ":costocompra", str( self.itemCost ) )
query.bindValue( ":linea", nlinea )
if not query.exec_():
raise Exception( "Error al insertar una de las lineas del documento" )
idarticuloxdocumento = query.lastInsertId()
if not query.prepare( """
INSERT INTO costosxarticuloliquidacion ( idarticuloxdocumento,
dai, isc, comision )
VALUES (:idarticuloxdocumento, :dai, :isc, :comision)
""" ):
raise Exception( "Error al preparar la consulta para insertar"\
+ " una de las lineas del documento" )
query.bindValue( ":idarticuloxdocumento", idarticuloxdocumento )
query.bindValue( ":dai", str( self.daiParcial ) )
query.bindValue( ":isc", str( self.iscParcial ) )
query.bindValue( ":comision", str( self.comisionParcial ) )
if not query.exec_():
logging.error( query.lastError().text() )
raise Exception( "Error al insertar los costos de una de las"\
+ " lineas de la factura " )
def save( self ):
"""
Este metodo guarda la factura en la base de datos
"""
if not self.valid:
raise Exception( u"Se intento guardar una factura no valida " )
query = QSqlQuery()
try:
if not self.database.transaction():
raise Exception( u"No se pudo comenzar la transacción" )
if self.clienteId == 0:
if not query.prepare( """
INSERT INTO personas (nombre,escliente)
VALUES ( :nombre,1)
""" ):
raise Exception( "No se pudo guardar el documento" )
query.bindValue( ":nombre",self.cliente)
if not query.exec_():
raise Exception( "No se pudo insertar el cliente" )
self.clienteId = str(query.lastInsertId())
print "id cliente " + self.clienteId
if not query.prepare( """
INSERT INTO documentos (fechacreado,fecha,idtipodoc,
observaciones,total,idpersona,referencia)
VALUES ( NULL,:fecha,:idtipodoc,:observacion,
:total,:idpersona,:ref)
""" ):
raise Exception( "No se pudo guardar el documento" )
query.bindValue( ":fecha",self.fecha.toString( 'yyyyMMdd' ))
query.bindValue( ":idtipodoc", self.__documentType )
query.bindValue( ":observacion", self.observaciones )
query.bindValue( ":total", self.total.to_eng_string() )
query.bindValue( ":idpersona", self.clienteId )
query.bindValue( ":ref", self.printedDocumentNumber )
if not query.exec_():
raise Exception( "No se pudo insertar el documento" )
inserted_id = str(query.lastInsertId())
for i, linea in enumerate( [line for line in self.lines if line.valid] ):
linea.save( inserted_id, i)
if not self.database.commit():
raise Exception( "No se pudo guardar la factura" )
return True
except Exception as inst:
logging.critical( query.lastError().text() )
logging.critical( unicode( inst ) )
self.database.rollback()
return False
return True
def save(self):
"""
Este metodo guarda el documento actual en la base de datos
"""
query = QSqlQuery()
try:
if not self.valid:
raise Exception("El documento a salvar no es valido")
if not QSqlDatabase.database().transaction():
raise Exception(u"No se puedo comenzar la transacción")
if not query.prepare(
"""
INSERT INTO documentos (ndocimpreso,fechacreacion,idtipodoc,
observacion,total, idtipocambio, idbodega)
VALUES ( :ndocimpreso,:fechacreacion,:idtipodoc,:observacion,
:total, :idtipocambio, :idbodega)
"""
):
raise Exception("No se pudo preparar la consulta para " + "insertar el kardex")
query.bindValue(":ndocimpreso", self.printedDocumentNumber)
query.bindValue(":fechacreacion", self.datetime.toString("yyyyMMddhhmmss"))
query.bindValue(":idtipodoc", self.__documentType)
query.bindValue(":observacion", self.observations)
query.bindValue(":total", str(self.ajusteTotalC))
query.bindValue(":idtipocambio", self.exchangeRateId)
query.bindValue(":idbodega", self.warehouseId)
if not query.exec_():
raise Exception("No se pudo insertar el documento")
inserted_id = query.lastInsertId().toInt()[0]
if not query.prepare(
"""
INSERT INTO personasxdocumento (idpersona, iddocumento,idaccion)
VALUE (:idusuario, :iddocumento,:accion)
"""
):
raise Exception("No se pudo preparar la consulta para " + "ingresar el usuario")
query.bindValue(":idusuario", self.uid)
query.bindValue(":iddocumento", inserted_id)
query.bindValue(":accion", constantes.AUTOR)
if not query.exec_():
raise Exception("No se pudo insertar el usuario")
for i, line in enumerate([line for line in self.lines if line.dirty and line.valid]):
line.save(inserted_id, i)
if not query.prepare(
"""
INSERT INTO docpadrehijos (idpadre, idhijo)
VALUES (:padre, :hijo)
"""
):
raise Exception("No se pudo preparar la relacion entre " + "el documento kardex y el documento padre")
query.bindValue(":padre", self.parentId)
query.bindValue(":hijo", inserted_id)
if not query.exec_():
raise Exception("No se pudo insertar la relacion entre " + "el documento kardex y el documento padre")
if self.ajusteTotalC != 0:
movKardex(inserted_id, self.ajusteTotalC)
if not QSqlDatabase.database().transaction():
raise Exception("No se pudo ejecutar la transaccion")
return True
except Exception as inst:
logging.critical(query.lastError().text())
logging.critical(unicode(inst))
QSqlDatabase.database().rollback()
return False
def save( self ):
"""
Este metodo guarda el documento actual en la base de datos
"""
if not self.valid:
raise UserWarning( "El documento a guardar no es valido" )
query = QSqlQuery()
try:
if not QSqlDatabase.database().transaction():
raise UserWarning( u"No se pudo iniciar la transacción" )
#
#INSERTAR CHEQUE
query.prepare( """
INSERT INTO documentos (ndocimpreso,fechacreacion,idtipodoc,
idestado, observacion,total,idtipocambio,idconcepto)
VALUES ( :ndocimpreso,:fechacreacion,:idtipodoc,
:estado,:observacion,:total,:idtc,:concepto)
""" )
query.bindValue( ":ndocimpreso", self.printedDocumentNumber )
query.bindValue( ":fechacreacion", self.datetime.toString( 'yyyyMMddhhmmss' ) )
query.bindValue( ":idtipodoc", self.__documentType )
query.bindValue( ":estado", constantes.CONFIRMADO )
query.bindValue( ":observacion", self.observations )
query.bindValue( ":total", self.totalDolares.to_eng_string() )
query.bindValue( ":idtc", self.exchangeRateId )
query.bindValue( ":concepto", self.conceptoId )
if not query.exec_():
raise UserWarning( "No se pudo crear el Cheque" )
insertedId = query.lastInsertId().toString()
#INSERTAR LA RELACION CON El USUARIO , EL CLIENTE Y EL PROVEEDOR
if not query.prepare(
"INSERT INTO personasxdocumento (iddocumento,idpersona,idaccion) VALUES" +
"(" + insertedId + ",:iduser,:autor),"
"(" + insertedId + ",:idproveedor,:proveedor)"
):
raise Exception( "No se puedo preparar la consulta para insertar las personas" )
query.bindValue( ":iduser", self.uid )
query.bindValue( ":idproveedor", self.proveedorId )
query.bindValue( ":autor", constantes.AUTOR )
query.bindValue( ":proveedor", constantes.PROVEEDOR )
if not query.exec_():
raise Exception( "No se Inserto la relacion entre el documento y las personas" )
if self.hasiva == True:
# INSERTAR EL ID DEL COSTO IVA
query.prepare( """
INSERT INTO costosxdocumento (iddocumento, idcostoagregado) VALUES( :iddocumento, :idcostoagregado )
""" )
query.bindValue( ":iddocumento", insertedId )
query.bindValue( ":idcostoagregado", self.ivaId )
if not query.exec_():
raise UserWarning( "el costo IVA no se inserto" )
if self.retencion >= 0 and self.retencionId >= 0 and self.hasretencion == True:
#INSERTAR EL DOCUMENTO RETENCION
query.prepare( """
INSERT INTO documentos (ndocimpreso,fechacreacion,idtipodoc,
idestado, observacion,total,escontado,idtipocambio,idconcepto)
VALUES ( :ndocimpreso,:fechacreacion,:idtipodoc,:idestado,
:observacion,:total,:escontado,:idtc,:concepto)
""" )
query.bindValue( ":ndocimpreso", self.printedDocumentNumber )
query.bindValue( ":fechacreacion", self.datetime )
query.bindValue( ":idtipodoc", constantes.IDRETENCION )
query.bindValue( ":idestado", constantes.CONFIRMADO )
query.bindValue( ":observacion", self.observations )
query.bindValue( ":total", self.retencion.to_eng_string() )
query.bindValue( ":escontado", 1 )
query.bindValue( ":idtc", self.exchangeRateId )
query.bindValue( ":concepto", self.conceptoId )
if not query.exec_():
raise UserWarning( u"No se Inserto la retención" )
idret = query.lastInsertId().toInt()[0]
#INSERTAR EL BENEFICIARIO Y USUARIO DE LA RETENCION
query.prepare( """
INSERT INTO personasxdocumento(iddocumento,
idpersona,idaccion) VALUES(:iddocumento,:idusuario,:autor)
""" )
query.bindValue( ":iddocumento", idret )
query.bindValue( ":idusuario", self.uid )
query.bindValue( ":autor", constantes.AUTOR )
if not query.exec_():
raise UserWarning( "No se pudo regitrar el usuario "
"que creo la retencion" )
query.prepare( """
INSERT INTO personasxdocumento(iddocumento,idpersona,
idaccion)
VALUES(:iddocumento,:idproveedor,:proveedor)
""" )
query.bindValue( ":iddocumento", idret )
query.bindValue( ":idproveedor", self.proveedorId )
query.bindValue( ":proveedor", constantes.PROVEEDOR )
if not query.exec_():
raise UserWarning( u"No se pudo insertar el beneficiario de la retención" )
#DOCUMENTO PADRE CHEQUE, DOCUMENTO HIJO RETENCION
query.prepare( """
INSERT INTO docpadrehijos (idpadre,idhijo)
VALUES (:idcheque,:idretencion)
""" )
query.bindValue( ":idcheque", insertedId )
query.bindValue( ":idretencion", idret )
if not query.exec_():
raise UserWarning( "No se Inserto la relacion entre la retención y el Cheque" )
# INSERTAR EL ID DEL COSTO RETENCION
query.prepare( """
INSERT INTO costosxdocumento (iddocumento, idcostoagregado)
VALUES( :iddocumento, :idcostoagregado )
""" )
query.bindValue( ":iddocumento", idret )
query.bindValue( ":idcostoagregado", self.retencionId )
if not query.exec_():
raise UserWarning( "el costo Retención NO SE INSERTO" )
#INSERTAR LAS CUENTAS CONTABLES
for lineid, line in enumerate( self.lines ):
if line.valid:
line.save( insertedId, lineid + 1 )
if not QSqlDatabase.database().commit():
raise UserWarning( "No se pudo realizar la Transacción" )
return True
except UserWarning as inst:
logging.error( unicode( inst ) )
logging.error( query.lastError().text() )
QSqlDatabase.database().rollback()
return False
except Exception as inst:
logging.critical( unicode( inst ) )
logging.critical( query.lastError().text() )
QSqlDatabase.database().rollback()
return False
def save( self ):
"""
Guardar el documento
@return: Si se pudo o no guardar el documento
@rtype: bool
"""
if not self.valid:
raise Exception( "El documento a salvar no es valido" )
query = QSqlQuery()
try:
if not self.database.isOpen():
if not self.database.open():
raise UserWarning( u"No se pudo abrir la base de datos" )
if not self.database.transaction():
raise Exception( u"No se pudo comenzar la transacción" )
#Insertar el documento
if not query.prepare( """
INSERT INTO documentos (ndocimpreso,fechacreacion,idtipodoc, observacion,total, idtipocambio)
VALUES ( :ndocimpreso,:fechacreacion,:idtipodoc,:observacion,:total, :idtc)
""" ):
raise Exception( "No se pudo preparar la consulta para guardar el arqueo" )
query.bindValue( ":ndocimpreso", self.printedDocumentNumber )
query.bindValue( ":fechacreacion", self.datetime.toString( 'yyyyMMddhhmmss' ) )
query.bindValue( ":idtipodoc", self.__documentType )
query.bindValue( ":observacion", self.observations )
query.bindValue( ":total", self.totalD.to_eng_string() )
query.bindValue( ":idtc", self.exchangeRateId )
if not query.exec_():
raise Exception( "No se pudo guardar el arqueo" )
insertedId = query.lastInsertId().toInt()[0]
#Insertar el padre del arqueo
if not query.prepare( """
INSERT INTO docpadrehijos (idpadre, idhijo)
VALUES (:idpadre, :idhijo)
""" ):
raise Exception( u"No se pudo preparar la relación con la sesión" )
query.bindValue( ":idpadre", self.datosSesion.sesionId )
query.bindValue( ":idhijo", insertedId )
if not query.exec_():
raise Exception( u"No se pudo insertar la relación con la sesión" )
#Insertar el usuario
if not query.prepare( """
INSERT INTO personasxdocumento (idpersona, iddocumento, idaccion)
VALUES (:idpersona, :iddocumento, :idaccion)
""" ):
raise Exception( "No se pudo preparar la consulta guardar el usuario" )
query.bindValue( ":idpersona", self.datosSesion.usuarioId )
query.bindValue( ":iddocumento", insertedId )
query.bindValue( ":idaccion", constantes.ACCCREA )
if not query.exec_():
raise Exception( "No se pudo guardar el usuario" )
#Insertar el usuario que autoriza
if not query.prepare( """
INSERT INTO personasxdocumento (idpersona, iddocumento, idaccion)
VALUES (:idpersona, :iddocumento, :idaccion)
""" ):
raise Exception( "No se pudo preparar la consulta guardar el usuario" )
query.bindValue( ":idpersona", self.authorizationId )
query.bindValue( ":iddocumento", insertedId )
query.bindValue( ":idaccion", constantes.ACCAUTORIZA )
if not query.exec_():
raise Exception( u"No se pudo guardar el usuario que da la autorización" )
#Insertar los totales
if not query.prepare(
" INSERT INTO movimientoscaja (iddocumento, idtipomovimiento, idtipomoneda, monto)" +
" VALUES ( " + str( insertedId ) + " , " + str( constantes.IDPAGOEFECTIVO ) + " , " + str( constantes.IDDOLARES ) + " , :cashD )," +
" ( " + str( insertedId ) + " , " + str( constantes.IDPAGOEFECTIVO ) + " , " + str( constantes.IDCORDOBAS ) + " , :cashC )," +
" ( " + str( insertedId ) + " , " + str( constantes.IDPAGOCHEQUE ) + " , " + str( constantes.IDDOLARES ) + " , :ckD )," +
" ( " + str( insertedId ) + " , " + str( constantes.IDPAGOCHEQUE ) + " , " + str( constantes.IDCORDOBAS ) + " , :ckC )," +
" ( " + str( insertedId ) + " , " + str( constantes.IDPAGODEPOSITO ) + " , " + str( constantes.IDDOLARES ) + " , :depositD )," +
" ( " + str( insertedId ) + " , " + str( constantes.IDPAGODEPOSITO ) + " , " + str( constantes.IDCORDOBAS ) + " , :depositC )," +
" ( " + str( insertedId ) + " , " + str( constantes.IDPAGOTRANSFERENCIA ) + " , " + str( constantes.IDDOLARES ) + " , :transferD )," +
" ( " + str( insertedId ) + " , " + str( constantes.IDPAGOTRANSFERENCIA ) + " , " + str( constantes.IDCORDOBAS ) + " , :transferC )," +
" ( " + str( insertedId ) + " , " + str( constantes.IDPAGOTARJETA ) + " , " + str( constantes.IDDOLARES ) + " , :cardD )," +
" ( " + str( insertedId ) + " , " + str( constantes.IDPAGOTARJETA ) + " , " + str( constantes.IDCORDOBAS ) + " , :cardC )"
):
raise Exception( "No se pudo preparar la consulta para guardar los totales del arqueo" )
query.bindValue( ":cashD", self.totalCashD.to_eng_string() )
query.bindValue( ":cashC", self.totalCashC.to_eng_string() )
query.bindValue( ":ckD", self.totalCkD.to_eng_string() )
query.bindValue( ":depositC", self.totalCkC.to_eng_string() )
query.bindValue( ":depositD", self.totalDepositD.to_eng_string() )
query.bindValue( ":depositC", self.totalDepositC.to_eng_string() )
query.bindValue( ":cardD", self.totalCardD.to_eng_string() )
query.bindValue( ":cardC", self.totalCardC.to_eng_string() )
query.bindValue( ":transferD", self.totalTransferD.to_eng_string() )
query.bindValue( ":transferC", self.totalTransferC.to_eng_string() )
if not query.exec_():
raise Exception( "No se pudieron insertar los pagos" )
if self.totalDifferenceC != 0:
movimientos.movArqueo( insertedId, self.totalDifferenceC )
for line in self.lines:
if line.valid:
line.save( insertedId )
if not self.database.commit():
raise Exception( "No se pudo hacer commit" )
result = True
except UserWarning as inst:
logging.error( unicode( inst ) )
logging.error( query.lastError().text() )
self.database.rollback()
result = False
except Exception as inst:
logging.critical( unicode( inst ) )
logging.critical( query.lastError().text() )
self.database.rollback()
result = False
finally:
if self.database.isOpen():
self.database.close()
return result
def save( self ):
"""
Este metodo guarda el documento actual en la base de datos
@rtype: bool
@return: Si el documento se pudo guardar o no
"""
if not self.valid:
raise Exception ( "El documento a salvar no es valido" )
query = QSqlQuery()
try:
if not QSqlDatabase.database().transaction():
raise Exception( u"No se pudo comenzar la transacción" )
#insertar el documento
if not query.prepare( """
INSERT INTO documentos(ndocimpreso, fechacreacion, idtipodoc,
idestado, observacion, idtipocambio, total, idbodega)
VALUES( :ndocimpreso, :fechacreacion, :idtipodoc, :estado,
:observacion, :tipocambio, :total, :idbodega)
""" ):
raise Exception( "No se pudo preparar la consulta para"\
+ " ingresar el documento" )
query.bindValue( ":ndocimpreso",
self.printedDocumentNumber.strip() )
query.bindValue( ":fechacreacion",
self.datetime.toString( 'yyyyMMddhhmmss' ) )
query.bindValue( ":idtipodoc", self.__documentType )
query.bindValue( ":anulado", 0 )
query.bindValue( ":observacion", self.observations )
query.bindValue( ":tipocambio", self.exchangeRateId )
query.bindValue( "total", self.totalD.to_eng_string() )
query.bindValue( ":idbodega", self.warehouseId )
query.bindValue( ":estado", constantes.INCOMPLETO )
if not query.exec_():
raise Exception( "No se pudo insertar el documento" )
#el id del documento que se acaba de insertar
insertedId = query.lastInsertId().toInt()[0]
#insertar el usuario
if not query.prepare( """
INSERT INTO personasxdocumento (idpersona, iddocumento, idaccion)
VALUE (:idusuario, :iddocumento, :accion)
""" ):
raise Exception( "No se pudo preparar la consulta para"\
+ " ingresar el usuario" )
query.bindValue( ":idusuario", self.uid )
query.bindValue( ":iddocumento", insertedId )
query.bindValue( ":accion", constantes.AUTOR )
if not query.exec_():
raise Exception( "No se pudo insertar el usuario" )
#insertar el proveedor
if not query.prepare( """
INSERT INTO personasxdocumento (idpersona, iddocumento,idaccion)
VALUE (:idproveedor, :iddocumento,:accion)
""" ):
raise Exception( "No se pudo preparar la consulta para"\
+ " ingresar proveedor" )
query.bindValue( ":idproveedor", self.providerId )
query.bindValue( ":iddocumento", insertedId )
query.bindValue( ":accion", constantes.PROVEEDOR )
if not query.exec_():
raise Exception( "No se pudo insertar el proveedor" )
#insertar la liquidacion
if not query.prepare( """
INSERT INTO liquidaciones (iddocumento, procedencia, totalagencia,
totalalmacen, porcentajepapeleria, porcentajetransporte, peso,
fletetotal, segurototal, otrosgastos)
VALUES(:iddoc,:procedencia,:agencia,:almacen,:papeleria,
:transporte,:peso,:flete,:seguro,:gastos)
""" ):
raise Exception( "No se pudo preparar la liquidacion" )
query.bindValue( ":iddoc", insertedId )
query.bindValue( ":procedencia", self.origin.strip() )
query.bindValue( ":agencia", self.agencyTotal.to_eng_string() )
query.bindValue( ":almacen", self.storeTotal.to_eng_string() )
query.bindValue( ":papeleria", self.paperworkRate.to_eng_string() )
query.bindValue( ":transporte", self.transportRate.to_eng_string() )
query.bindValue( ":peso", self.weight.to_eng_string() )
query.bindValue( ":flete", self.freightTotal.to_eng_string() )
query.bindValue( ":seguro", self.insuranceTotal.to_eng_string() )
query.bindValue( ":gastos", self.otherTotal.to_eng_string() )
if not query.exec_():
raise Exception( "No se pudieron insertar los "\
+ "datos de la liquidacion" )
#insertar el tsim
if not query.prepare( """
INSERT INTO costosxdocumento ( iddocumento, idcostoagregado)
VALUES ( :iddocumento, :idcostoagregado)
""" ):
raise Exception( "No se pudo preparar la consulta"\
+ " para insertar el tsim" )
query.bindValue( ":iddocumento", insertedId )
query.bindValue( ":idcostoagregado", self.tsimId )
if not query.exec_():
raise Exception( "No se pudo insertar el tsim" )
#insertar el spe
if not query.prepare( """
INSERT INTO costosxdocumento ( iddocumento, idcostoagregado)
VALUES (:iddocumento, :idcostoagregado )
""" ):
raise Exception( "No se pudo preparar la consulta para "\
+ "insertar el spe" )
query.bindValue( ":iddocumento", insertedId )
query.bindValue( ":idcostoagregado", self.speId )
if not query.exec_():
raise Exception( "No se pudo insertar el spe" )
#insertar el iva si aplica
if self.applyIVA:
if not query.prepare( """
INSERT INTO costosxdocumento ( iddocumento, idcostoagregado)
VALUES (:iddocumento, :idcostoagregado )
""" ):
raise Exception( "No se pudo preparar la consulta para "\
+ "insertar el iva" )
query.bindValue( ":iddocumento", insertedId )
query.bindValue( ":idcostoagregado", self.ivaId )
if not query.exec_():
raise Exception( "No se pudo insertar el iva" )
#insertar el iso si aplica
if self.applyISO and self.applyTaxes:
if not query.prepare( """
INSERT INTO costosxdocumento ( iddocumento, idcostoagregado)
VALUES (:iddocumento, :idcostoagregado )
""" ):
raise Exception( "No se pudo preparar la consulta para "\
+ "insertar el iso" )
query.bindValue( ":iddocumento", insertedId )
query.bindValue( ":idcostoagregado", self.isoId )
if not query.exec_():
raise Exception( "No se pudo insertar el iso" )
for i, line in enumerate( [line for line in
self.__lines if line.valid] ):
line.save( insertedId, i )
if not QSqlDatabase.database().commit():
raise Exception( "No se pudo hacer commit" )
except Exception as inst:
logging.critical( query.lastError().text() )
logging.critical( unicode( inst ) )
QSqlDatabase.database().rollback()
return False
return True
def save( self ):
"""
Este metodo guarda el documento actual en la base de datos
@rtype: bool
@return: Si el documento se pudo guardar o no
"""
if not self.valid:
raise Exception ( "El documento a salvar no es valido" )
query = QSqlQuery()
try:
if not QSqlDatabase.database().transaction():
raise Exception( u"No se pudo comenzar la transacción" )
#insertar el documento
if not query.prepare( """
INSERT INTO documentos(ndocimpreso, fechacreacion, idtipodoc,
idestado, observacion, idtipocambio, total, idbodega, idconcepto)
VALUES( :ndocimpreso, :fechacreacion, :idtipodoc, :estado,
:observacion, :tipocambio, :total, :idbodega, :idconcepto)
""" ):
raise Exception( "No se pudo preparar la consulta para "\
+ "ingresar el documento" )
query.bindValue( ":ndocimpreso", self.printedDocumentNumber )
query.bindValue( ":fechacreacion",
self.datetime.toString( 'yyyyMMddhhmmss' ) )
query.bindValue( ":idtipodoc", self.__documentType )
query.bindValue( ":estado", constantes.CONFIRMADO )
query.bindValue( ":observacion", self.observations )
query.bindValue( ":tipocambio", self.exchangeRateId )
query.bindValue( ":total", self.totalCostC.to_eng_string() )
query.bindValue( ":idbodega", self.warehouseId )
query.bindValue( ":idconcepto", self.conceptId )
if not query.exec_():
raise Exception( "No se pudo insertar el documento" )
insertedId = query.lastInsertId() #el id del documento que se acaba de insertar
#insertar el usuario
if not query.prepare( """
INSERT INTO personasxdocumento (idpersona, iddocumento, idaccion)
VALUE (:idusuario, :iddocumento, :accion)
""" ):
raise Exception( "No se pudo preparar la consulta para "\
+ "ingresar el usuario" )
query.bindValue( ":idusuario", self.uid )
query.bindValue( ":iddocumento", insertedId )
query.bindValue( ":accion", constantes.AUTOR )
if not query.exec_():
raise Exception( "No se pudo insertar el usuario" )
#Guardar las cuentas contables
for i, line in enumerate( [line for line in self.accountsmodel.lines if line.valid] ):
line.save( insertedId, i )
#Guardar las lineas
for i, line in enumerate( [line for line in self.lines if line.valid] ):
line.save( insertedId, i )
if not QSqlDatabase.database().commit():
raise Exception( "No se pudo hacer commit" )
return True
except Exception as inst:
logging.critical( unicode( inst ) )
logging.critical( query.lastError().text() )
QSqlDatabase.database().rollback()
return False
def save( self ):
"""
Este metodo guarda el documento actual en la base de datos
"""
query = QSqlQuery()
try:
if not self.valid:
raise Exception( "El documento a salvar no es valido" )
if not QSqlDatabase.database().transaction():
raise Exception( u"No se puedo comenzar la transaccion" )
#Insertar el documento
if not query.prepare( """
INSERT INTO documentos (ndocimpreso,fechacreacion,idtipodoc,idestado, observacion,total, idtipocambio, idconcepto, idbodega)
VALUES ( :ndocimpreso,:fechacreacion,:idtipodoc,:pendiente,:observacion,:total, :idtipocambio, :idconcepto, :idbodega)
""" ):
raise Exception( u"No se pudo preparar la consulta para añadir el documento" )
query.bindValue( ":ndocimpreso", 'S/N' )
query.bindValue( ":fechacreacion", self.datetime.toString( 'yyyyMMddhhmmss' ) )
query.bindValue( ":idtipodoc", self.__documentType )
query.bindValue( ":pendiente", constantes.PENDIENTE )
query.bindValue( ":observacion", self.observations )
query.bindValue( ":total", self.totalD.to_eng_string() )
query.bindValue( ":idtipocambio", self.exchangeRateId )
query.bindValue( ":idconcepto", self.conceptId )
query.bindValue( ":idbodega", self.warehouseId )
if not query.exec_():
raise Exception( "No se pudo insertar el documento" )
insertedId = query.lastInsertId().toInt()[0]
#Insertar el usuario y cliente
if not query.prepare( """
INSERT INTO personasxdocumento (idpersona, iddocumento,idaccion)
VALUES (:idpersona, :iddocumento,:accion)
""" ):
raise Exception( "No se pudo preparar la consulta para los usuarios y las personas" )
query.bindValue( ":idpersona", self.clientId )
query.bindValue( ":iddocumento", insertedId )
query.bindValue( ":accion", constantes.CLIENTE )
if not query.exec_():
raise Exception( u"No se pudo aniadir el cliente" )
if not query.prepare( """
INSERT INTO personasxdocumento (idpersona, iddocumento,idaccion)
VALUES (:idusuario, :iddocumento,:accion)
""" ):
raise Exception( "No se pudo preparar la consulta para el usuario" )
query.bindValue( ":idusuario", self.uid )
query.bindValue( ":iddocumento", insertedId )
query.bindValue( ":accion", constantes.AUTOR )
if not query.exec_():
raise Exception( u"No se pudo añadir el usuario" )
#Insertar la revercion de los articulos
for i, linea in enumerate( [line for line in self.lines if line.valid] ):
linea.save( insertedId, i )
# Crear la relacion con su padre
if not query.prepare( """
INSERT INTO docpadrehijos (idpadre, idhijo) VALUES (:idpadre, :idhijo)
""" ):
raise Exception( u"No se pudo preparar la consulta para "\
+ "insertar la relación de la devolución"\
+ " con la factura" )
query.bindValue( ":idpadre", self.invoiceId )
query.bindValue( ":idhijo", insertedId )
if not query.exec_():
raise Exception( u"No se pudo crear la relacion de la "\
+ "devolución con la factura" )
if not QSqlDatabase.database().commit():
raise Exception( "No se pudo hacer commit" )
except Exception as inst:
logging.critical( query.lastError().text() )
logging.critical( unicode( inst ) )
QSqlDatabase.database().rollback()
return False
return True
def insertChildren( self, position, count, columns ):
if position < 0 :
return False
if not ( self.parent() is None or self.parent().parent() is None ):
return False
for _row in range( count ):
data = columns
if type( columns ) == int:
query = QSqlQuery()
try:
if not QSqlDatabase.database().isOpen():
if not QSqlDatabase.database().open():
raise Exception( "No se pudo conectar con la base"\
+ " de datos" )
if self.parentItem is None:
if not query.prepare( """
INSERT INTO categorias (nombre)
VALUES ( :nombre)
""" ):
raise Exception( "No se pudo preparar la consulta"\
+ " para insertar la categoria" )
else:
if not query.prepare( """
INSERT INTO categorias (nombre, padre)
VALUES ( :nombre, %d)
""" % self.data( 1 ) ):
raise Exception( "No se pudo preparar la consulta"\
+ " para insertar la categoria" )
query.bindValue( ":nombre", "tmp" )
if not query.exec_():
raise Exception( "No se pudo insertar la categoria" )
data = ["tmp", query.lastInsertId().toInt()[0]]
except Exception as inst:
logging.error( unicode( inst ) )
return False
elif data[0] == 0:
query = QSqlQuery()
try:
if type( self.itemData[0] ) == int:
if not query.prepare( """
INSERT INTO categorias (padre, nombre)
VALUES (%d, :nombre)
""" % self.itemData[0] ):
raise Exception( "No se pudo preparar la consulta"\
+ " para insertar la categoria" )
else:
if not query.prepare( """
INSERT INTO categorias (nombre)
VALUES ( :nombre)
""" ):
raise Exception( "No se pudo preparar la consulta"\
+ " para insertar la categoria" )
query.bindValue( ":nombre", data[1].strip() )
if not query.exec_():
raise Exception( "No se pudo insertar la categoria" )
except Exception as inst:
logging.error( unicode( inst ) )
return False
item = CategoryItem( data, self )
self.childItems.insert( position, item )
return True
def save( self ):
"""
Este metodo guarda el documento actual en la base de datos
@return: Si se pudo o no guardar el documento
@rtype: bool
"""
if not self.valid:
raise Exception( "El documento a salvar no es valido" )
query = QSqlQuery()
try:
if not QSqlDatabase.database().transaction():
raise Exception( u"No se pudo comenzar la transacción" )
if not query.prepare( """
INSERT INTO documentos (ndocimpreso,fechacreacion,idtipodoc, observacion,total, idbodega, idtipocambio, escontado)
VALUES ( :ndocimpreso,:fechacreacion,:idtipodoc,:observacion,:total,:idbodega, :idtc, :escontado)
""" ):
raise Exception( "No se pudo preparar la consulta para ingresar el documento" )
query.bindValue( ":ndocimpreso", self.printedDocumentNumber )
query.bindValue( ":fechacreacion", self.datetime.toString( 'yyyyMMddhhmmss' ) )
query.bindValue( ":idtipodoc", self.__documentType )
query.bindValue( ":observacion", self.observations )
query.bindValue( ":total", self.totalD.to_eng_string() )
query.bindValue( ":idbodega", 1 )
query.bindValue( ":idtc", self.exchangeRateId )
query.bindValue( ":escontado", self.paytipe )
if not query.exec_():
raise Exception( "No se pudo insertar el documento" )
insertedId = query.lastInsertId().toInt()[0]
#insertar el usuario
if not query.prepare( """
INSERT INTO personasxdocumento (idpersona, iddocumento,idaccion)
VALUE (:idusuario, :iddocumento,:idaccion)
""" ):
raise Exception( "No se pudo preparar la consulta para ingresar el usuario" )
query.bindValue( ":idusuario", self.uid )
query.bindValue( ":iddocumento", insertedId )
query.bindValue( ":idaccion", constantes.AUTOR )
if not query.exec_():
raise Exception( "No se pudo insertar el usuario" )
#insertar el proveedor
if not query.prepare( """
INSERT INTO personasxdocumento (idpersona, iddocumento,idaccion)
VALUE (:idproveedor, :iddocumento,:idaccion)
""" ):
raise Exception( "No se pudo preparar la consulta para ingresar proveedor" )
query.bindValue( ":idproveedor", self.providerId )
query.bindValue( ":iddocumento", insertedId )
query.bindValue( ":idaccion", constantes.PROVEEDOR )
if not query.exec_():
raise Exception( "No se pudo insertar el proveedor" )
if self.isCheck:
raise UserWarning( "Todavia no es posible guardar entradas de compras pagadas con cheques" )
for nline, line in enumerate( self.lines ):
if line.valid:
line.save( insertedId, nline )
if not query.prepare( """
INSERT INTO costosxdocumento (iddocumento, idcostoagregado) VALUES( :iddocumento, :idcostoagregado )
""" ):
raise Exception( "No se pudo preparar la consulta para insertar el costo del documento" )
query.bindValue( ":iddocumento", insertedId )
query.bindValue( ":idcostoagregado", self.idIVA )
if not query.exec_():
raise Exception( "No se pudo insertar el costo para el documento" )
#manejar las cuentas contables
movEntradaCompra( insertedId, self.totalC, self.IVAC )
if not QSqlDatabase.database().commit():
raise Exception( "No se pudo hacer commit" )
except Exception as inst:
logging.critical( query.lastError().text() )
logging.critical( unicode( inst ) )
QSqlDatabase.database().rollback()
return False
return True
def save( self ):
"""
Verdadero si el documento fue guardado
@rtype: bool
"""
query = QSqlQuery()
# try:
if not QSqlDatabase.database() .isOpen():
raise Exception( "La conexion esta cerrada, no se pueden guardar los datos del documento" )
if not QSqlDatabase.database().transaction():
raise Exception( u"No se pudo comenzar la transacción" )
query.prepare( """
SELECT fnConsecutivo(:tipodoc,:cuenta);
""")
query.bindValue( ":tipodoc", self.tipoDoc )
query.bindValue( ":cuenta", self.cuentaBancaria )
if not query.exec_():
raise Exception("No se pudo obtener el numero de deposito")
query.first()
self.numeroDoc = query.value( 0 ).toString()
if not query.prepare( """
INSERT INTO documentos (ndocimpreso,total, fechacreacion, idconcepto, idtipodoc,observacion,delbanco)
VALUES (:ndocimpreso,:total, :fechacreacion, :idconcepto,:idtipodoc,:observacion,:externo)
""" ):
raise Exception( "No se pudo preparar la consulta para guardar el documento" )
query.bindValue( ":ndocimpreso", self.numeroDoc )
query.bindValue( ":total", self.totalDoc.to_eng_string() )
query.bindValue( ":fechacreacion", self.fechaDoc.toString("yyyyMMddhhmmss"))
query.bindValue( ":idconcepto", self.conceptoId)
query.bindValue( ":idtipodoc",self.tipoDoc)
query.bindValue( ":observacion",self.observacionesDoc)
query.bindValue( ":externo",self.bancoDoc)
if not query.exec_():
raise Exception( "No se pudo ejecutar la consulta para guardar el documento" )
self.idDoc = query.lastInsertId().toString()
if not query.prepare( """
INSERT INTO personasxdocumento (idpersona, iddocumento,idaccion)
VALUES (:usuario, :documento,:accion)
""" ):
raise Exception( "No se pudo preparar la consulta para insertar el usuario" )
query.bindValue( ":usuario", self.autorId )
query.bindValue( ":documento", self.idDoc )
query.bindValue( ":accion", constantes.AUTOR )
if not query.exec_():
raise Exception( u"No se pudo guardar la relacion con el usuario" )
for nLinea, linea in enumerate( self.lineasDoc ):
if linea.valid:
linea.save( self.idDoc, nLinea + 1 )
else:
raise Exception ("Linea Invalida")
if not QSqlDatabase.database().commit():
raise Exception( "No se pudo hacer commit" )
return True
# except Exception as inst:
# logging.critical( query.lastError().text() )
# logging.critical( unicode( inst ) )
# QSqlDatabase.database().rollback()
#
# finally:
# if QSqlDatabase.database().isOpen():
# QSqlDatabase.database().close()
#
return False
def anular(self):
"""
@var: El elemento actual en el navmodel
@type: QSqlRecord
"""
record = self.navmodel.record(self.mapper.currentIndex())
doc = record.value("iddocumento").toInt()[0]
total = Decimal(record.value("TotalCheque").toString())
try:
if not self.database.isOpen():
if not self.database.open():
raise Exception("No se pudo abrir la Base de datos")
if (
QMessageBox.question(
self,
qApp.organizationName(),
u"¿Esta seguro que desea anular el cheque?",
QMessageBox.Yes | QMessageBox.No,
)
== QMessageBox.Yes
):
anulardialog = Anular(self.navmodel.record(self.mapper.currentIndex()).value("No. Cheque").toString())
if anulardialog.conceptosmodel.rowCount() == 0:
QMessageBox.warning(self, qApp.organizationName(), u"No existen conceptos para la anulación")
else:
if anulardialog.exec_() == QDialog.Accepted:
if (
anulardialog.cboConceptos.currentIndex() == -1
and anulardialog.txtObservaciones.toPlainText() == ""
):
QMessageBox.critical(self, qApp.organizationName(), "Por favor rellene todos los campos")
else:
query = QSqlQuery()
if not self.database.transaction():
raise Exception(u"No se pudo comenzar la transacción")
#
query = QSqlQuery(
"""
SELECT fnConsecutivo(%d,NULL);
"""
% constantes.IDANULACION
)
if not query.exec_():
raise Exception("No se pudo obtener el numero de la factura")
query.first()
n = query.value(0).toString()
# Insertar documento anulacion
if not query.prepare(
"""
INSERT INTO documentos(ndocimpreso,total,fechacreacion,idtipodoc,observacion,idestado)
VALUES(:ndocimpreso,:total,:fechacreacion,:idtipodoc,:observacion,:idestado)"""
):
raise Exception(query.lastError().text())
query.bindValue(":ndocimpreso", n)
query.bindValue(":total", total.to_eng_string())
query.bindValue(":fechacreacion", QDate.currentDate())
query.bindValue(":idtipodoc", constantes.IDANULACION)
query.bindValue(":observacion", anulardialog.txtObservaciones.toPlainText())
query.bindValue(":idestado", constantes.CONFIRMADO)
if not query.exec_():
raise Exception("No se pudo insertar el documento Anulacion")
idanulacion = query.lastInsertId().toString()
query.prepare("CALL spEliminarCheque(:doc,:anulado,:idcheque,:idretencion)")
query.bindValue(":doc", idanulacion)
query.bindValue(":idcheque", doc)
query.bindValue(":anulado", constantes.ANULADO)
query.bindValue(":idretencion", constantes.IDRETENCION)
if not query.exec_():
raise UserWarning("No se pudo Anular el Cheque")
if not query.prepare(
"INSERT INTO docpadrehijos (idpadre,idhijo) VALUES" + "(:idcheque," + idanulacion + ")"
):
# "(:usuario," + insertedId + ",0),"
# "(:supervisor," + insertedId + ",1)"):
raise Exception(
query.lastError().text() + "No se preparo la relacion de la anulacion con el Cheque"
)
query.bindValue(":idcheque", doc)
if not query.exec_():
raise Exception("No se pudo insertar la relacion de la Anulacion con el Cheque")
if not query.prepare(
"INSERT INTO personasxdocumento (idpersona,iddocumento,idaccion) VALUES"
+ "(:usuario,"
+ idanulacion
+ ",:accion)"
):
raise Exception(query.lastError().text() + "No se inserto el usuario y autoriza")
query.bindValue(":usuario", self.user.uid)
query.bindValue(":accion", constantes.AUTOR)
if not query.exec_():
raise Exception("No se pudo Insertar la relacion de la anulacion con el usuario")
if not self.database.commit():
raise Exception("NO se hizo el commit para la Anulacion")
QMessageBox.information(
self, qApp.organizationName(), "Cheque anulado Correctamente", QMessageBox.Ok
)
self.updateModels()
except UserWarning as inst:
logging.error(unicode(inst))
logging.error(query.lastError().text())
self.database.rollback()
QMessageBox.critical(self, qApp.organizationName(), unicode(inst))
except Exception as inst:
logging.critical(unicode(inst))
logging.critical(query.lastError().text())
self.database.rollback()
finally:
if self.database.isOpen():
self.database.close()
def giveEntry( self ):
"""
Dar entrada a un kardex
"""
if QMessageBox.question( self, qApp.organizationName(),
u"¿Realmente desea dar entrada a este documento?",
QMessageBox.Yes | QMessageBox.No ) == QMessageBox.Yes:
iddoc = self.navmodel.record( self.mapper.currentIndex() ).value( IDDOCUMENTO ).toInt()[0]
query = QSqlQuery()
try:
if not self.database.isOpen():
if not self.database.open():
raise UserWarning( u"No se pudo conectar con la"\
+ " base de datos" )
if not self.database.transaction():
raise Exception( u"No se pudo iniciar la transacción "\
+ "para confirmar el kardex" )
q = """
UPDATE documentos d SET idestado = %d
WHERE d.iddocumento = %d LIMIT 1
""" % ( constantes.CONFIRMADO, iddoc )
if not query.exec_( q ):
raise Exception( u"No se pudo actualizar el estado "\
+ "del documento" )
if not query.exec_( """
INSERT INTO documentos (ndocimpreso, fechacreacion,
idtipodoc, total, idtipocambio, idbodega)
SELECT fnConsecutivo(%d,NULL), NOW(), %d, total,
idtipocambio, idbodega FROM documentos
WHERE iddocumento = %d;
""" % ( constantes.IDKARDEX,
constantes.IDKARDEX,
iddoc ) ):
raise Exception( u"No se pudo insertar el documento kardex" )
insertedId = query.lastInsertId().toInt()[0]
if not query.exec_( """
INSERT INTO docpadrehijos (idpadre, idhijo) VALUES (%d, %d)
""" % ( iddoc, insertedId ) ):
raise Exception( u"No se pudo crear la relación entre el"\
+ " documento ajuste de bodega y su kardex" )
if not self.database.commit():
raise Exception( u"No se pudo hacer commit" )
QMessageBox.information( self, qApp.organizationName(),
"El documento se ha guardado con exito" )
self.updateModels()
except UserWarning as inst:
logging.error( unicode( inst ) )
self.database.rollback()
QMessageBox.critical( self, qApp.organizationName(), unicode( inst ) )
except Exception as inst:
logging.critical( unicode( inst ) )
self.database.rollback()
QMessageBox.critical( self, qApp.organizationName(),
u"No se pudo confirmar la entrada"\
+ " de este documento" )
def save( self ):
try:
if not QSqlDatabase.database().transaction():
raise Exception( u"No se pudo comenzar la transacción" )
query = QSqlQuery()
if not query.prepare( """
INSERT INTO documentos (ndocimpreso,fechacreacion,idtipodoc,observacion,total,idtipocambio,idcaja,idconcepto)
VALUES ( :ndocimpreso,:fechacreacion,:idtipodoc,:observacion,:total,:idtc,:caja,:con)
""" ):
raise Exception( "No se pudo guardar el documento" )
query.bindValue( ":ndocimpreso", self.docImpreso )
query.bindValue( ":fechacreacion", self.datosSesion.fecha.toString( 'yyyyMMdd' ) + QDateTime.currentDateTime().toString( "hhmmss" ) )
query.bindValue( ":idtipodoc", self.__documentType )
query.bindValue( ":observacion", self.observaciones )
total = self.totalDolar #- ( self.retencionCordoba / self.datosSesion.tipoCambioBanco )
query.bindValue( ":total", str( total ) )
# query.bindValue( ":escontado", self.escontado )
query.bindValue( ":idtc", self.datosSesion.tipoCambioId )
query.bindValue( ":caja", self.datosSesion.cajaId )
query.bindValue( ":con", self.conceptoId )
# query.bindValue( ":estado", constantes.INCOMPLETO)
if not query.exec_():
raise Exception( "No se pudo insertar el PAGO" )
insertedId = query.lastInsertId().toString()
#INSERTAR LA RELACION CON LA SESION DE CAJA
query.prepare( """
INSERT INTO docpadrehijos (idpadre,idhijo)
VALUES (:idsesion,:idpago)
""" )
query.bindValue( ":idsesion", self.datosSesion.sesionId )
query.bindValue( ":idpago", insertedId )
if not query.exec_():
raise Exception( "No se Inserto la relacion entre la sesion de caja y el pago" )
#INSERTAR LA RELACION CON El USUARIO , EL CLIENTE Y EL PROVEEDOR
query.prepare(
"INSERT INTO personasxdocumento (iddocumento,idpersona,idaccion) VALUES" +
"(" + insertedId + ",:iduser,:autor),"
"(" + insertedId + ",:idbeneficiario,:beneficiario)"
)
query.bindValue( ":iduser", self.datosSesion.usuarioId )
query.bindValue( ":autor", constantes.AUTOR )
query.bindValue( ":idbeneficiario", self.beneficiarioId )
query.bindValue( ":beneficiario", constantes.PROVEEDOR )
if not query.exec_():
raise Exception( "No se Inserto la relacion entre el documento"
+ " y las personas" )
if self.totalC != 0:
if not query.prepare( "INSERT INTO movimientoscaja(iddocumento,idtipomovimiento,idtipomoneda,monto) VALUES " +
"(" + insertedId + ",1,1,-:totalCordoba)" ):
raise Exception( query.lastError().text() )
query.bindValue( ":totalCordoba", str( self.totalC ) )
if not query.exec_():
raise Exception( "No se Inserto el movimiento caja en dolares" )
if self.totalD != 0:
if not query.prepare( "INSERT INTO movimientoscaja(iddocumento,idtipomovimiento,idtipomoneda,monto) VALUES " +
"(" + insertedId + ",1,2,-:totalDolar)" ):
raise Exception( query.lastError().text() )
query.bindValue ( ":totalDolar", str( self.totalD ) )
if not query.exec_():
raise Exception( "No se Inserto el movimiento "\
+ "caja en dolares" )
#VERIFICO SI el id del iva es cero. NO SERA CERO CUANDO LA BODEGA=1 PORQUE ESTA NO ES exonerada
if self.aplicarIva:
query.prepare( """
INSERT INTO costosxdocumento (iddocumento, idcostoagregado)
VALUES( :iddocumento, :idcostoagregado )
""" )
query.bindValue( ":iddocumento", insertedId )
query.bindValue( ":idcostoagregado", self.ivaId )
if not query.exec_():
raise Exception( "El iva NO SE INSERTO" )
if self.aplicarRet:
query.prepare( """
INSERT INTO costosxdocumento (iddocumento, idcostoagregado)
VALUES( :iddocumento, :idcostoagregado )
""" )
query.bindValue( ":iddocumento", insertedId )
query.bindValue( ":idcostoagregado", self.retencionId )
if not query.exec_():
raise Exception( "La retencion NO SE INSERTO" )
if not QSqlDatabase.database().commit():
raise Exception( "No se pudo guardar el pago" )
except Exception as inst:
logging.error( query.lastError().text() )
logging.error( unicode( inst ) )
QSqlDatabase.database().rollback()
return False
return True
def save( self , otrosDatosModel ):
"""
Este metodo guarda la factura en la base de datos
"""
if not self.valid:
raise Exception( u"Se intento guardar una factura no valida " )
query = QSqlQuery()
try:
if not self.database.transaction():
raise Exception( u"No se pudo comenzar la transacción" )
if not query.prepare( """
INSERT INTO documentos (ndocimpreso,fechacreacion,idtipodoc,
observacion,total,idbodega,escontado,idtipocambio,idcaja,idestado)
VALUES ( :ndocimpreso,:fechacreacion,:idtipodoc,:observacion,
:total,:bodega,:escontado,:idtc,:caja,:estado)
""" ):
raise Exception( "No se pudo guardar el documento" )
query.bindValue( ":ndocimpreso", self.printedDocumentNumber )
query.bindValue( ":fechacreacion",
self.datosSesion.fecha.toString( 'yyyyMMdd' )\
+ QDateTime.currentDateTime().toString( "hhmmss" ) )
query.bindValue( ":idtipodoc", self.__documentType )
query.bindValue( ":observacion", self.observaciones )
query.bindValue( ":total", self.total.to_eng_string() )
query.bindValue( ":bodega", self.bodegaId )
query.bindValue( ":escontado", self.escontado )
query.bindValue( ":idtc", self.datosSesion.tipoCambioId )
query.bindValue( ":caja", self.datosSesion.cajaId )
query.bindValue( ":estado", constantes.CONFIRMADO if self.escontado else constantes.PENDIENTE )
if not query.exec_():
raise Exception( "No se pudo insertar el documento" )
inserted_id = query.lastInsertId().toString()
#INSERTAR LA RELACION CON LA SESION DE CAJA
query.prepare( """
INSERT INTO docpadrehijos (idpadre,idhijo)
VALUES (:idsesion,:idfac)
""" )
query.bindValue( ":idsesion", self.datosSesion.sesionId )
query.bindValue( ":idfac", inserted_id )
if not query.exec_():
raise Exception( "No se Inserto la relacion entre la sesion"\
+ " de caja y la factura" )
#INSERTAR LA RELACION CON El USUARIO , EL CLIENTE Y EL PROVEEDOR
query.prepare(
"INSERT INTO personasxdocumento (iddocumento,idpersona,idaccion) VALUES" +
"(" + inserted_id + ",:iduser,:autor),"
"(" + inserted_id + ",:idcliente,:cliente),"
"(" + inserted_id + ",:idvendedor,:vendedor)"
)
query.bindValue( ":iduser", self.datosSesion.usuarioId )
query.bindValue( ":idcliente", self.clienteId )
query.bindValue( ":idvendedor", self.vendedorId )
query.bindValue( ":autor", constantes.AUTOR )
query.bindValue( ":cliente", constantes.CLIENTE )
query.bindValue( ":vendedor", constantes.VENDEDOR )
if not query.exec_():
raise Exception( "No se Inserto la relacion entre "\
+ "el documento y las personas" )
for i, linea in enumerate( [line for line in self.lines if line.valid] ):
linea.save( inserted_id, i, self.datosSesion.tipoCambioId )
#VERIFICO SI el id del iva es cero. NO SERA CERO CUANDO LA BODEGA=1 PORQUE ESTA NO ES exonerada
if self.applyIva:
query.prepare( """
INSERT INTO costosxdocumento (iddocumento, idcostoagregado)
VALUES( :iddocumento, :idcostoagregado )
""" )
query.bindValue( ":iddocumento", inserted_id )
query.bindValue( ":idcostoagregado", self.ivaId )
if not query.exec_():
raise Exception( "El iva NO SE INSERTO" )
#manejar las cuentas contables en Cordobas
# el costo no se multiplica porque ya esta en cordobas
if self.escontado:
movFacturaCredito( inserted_id,
self.subtotal * self.datosSesion.tipoCambioOficial ,
self.IVA * self.datosSesion.tipoCambioOficial,
self.costototal )
# Como es al contado el modelo otrosDatosModel guarda datos del recibo
otrosDatosModel.lineasAbonos[0].idFac = inserted_id
if not otrosDatosModel.save( False ):
raise Exception( "No se pudo guardar el modelo de "\
+ "otros datos" )
else:
query.prepare( """
INSERT INTO creditos (iddocumento, fechatope,tasamulta)
VALUES( :iddocumento, :fechatope, :multa )
""" )
query.bindValue( ":iddocumento", inserted_id )
query.bindValue( ":fechatope", self.fechaTope )
query.bindValue( ":multa", self.multa )
if not query.exec_():
raise Exception( "No se pudo insertar el credito" )
if not self.database.commit():
raise Exception( "No se pudo guardar la factura" )
except Exception as inst:
logging.critical( query.lastError().text() )
logging.critical( unicode( inst ) )
self.database.rollback()
return False
return True
def save( self, sinFactura = True ):
"""
Este metodo guarda el documento actual en la base de datos
"""
if not self.valid:
raise Exception( "El documento a salvar no es valido" )
query = QSqlQuery()
try:
if sinFactura:
if not QSqlDatabase.database().transaction():
raise Exception( u"No se pudo comenzar la transacción" )
fechaCreacion = self.datosSesion.fecha.toString( 'yyyyMMdd' ) + QDateTime.currentDateTime().toString( "hhmmss" )
#INSERTAR RECIBO
query.prepare( """
INSERT INTO documentos (ndocimpreso,fechacreacion,idtipodoc, observacion,total,idtipocambio,idconcepto,idcaja)
VALUES ( :ndocimpreso,:fechacreacion,:idtipodoc,:observacion,:total,:idtc,:concepto,:caja)
""" )
query.bindValue( ":ndocimpreso", self.printedDocumentNumber )
query.bindValue( ":fechacreacion", fechaCreacion )
query.bindValue( ":idtipodoc", self.__documentType )
query.bindValue( ":observacion", self.observaciones )
totalPagado = self.totalPagado
query.bindValue( ":total", totalPagado.to_eng_string() )
query.bindValue( ":idtc", self.datosSesion.tipoCambioId )
query.bindValue( ":concepto", self.conceptoId )
query.bindValue( ":caja", self.datosSesion.cajaId )
if not query.exec_():
raise Exception( "No se pudo insertar el recibo" )
insertedId = query.lastInsertId().toString()
#INSERTAR LA RELACION CON LA SESION DE CAJA
query.prepare( """
INSERT INTO docpadrehijos (idpadre,idhijo)
VALUES (:idsesion,:idrecibo)
""" )
query.bindValue( ":idsesion", self.datosSesion.sesionId )
query.bindValue( ":idrecibo", insertedId )
if not query.exec_():
raise Exception( "No se Inserto la relacion entre la sesion de caja y el recibo" )
#INSERTAR LA RELACION CON El USUARIO y EL CLIENTE
query.prepare(
"INSERT INTO personasxdocumento (iddocumento,idpersona,idaccion) VALUES" +
"(" + insertedId + ",:iduser,:autor),"
"(" + insertedId + ",:idcliente,:cliente)"
)
query.bindValue( ":iduser", self.datosSesion.usuarioId )
query.bindValue( ":autor", constantes.AUTOR )
query.bindValue( ":idcliente", self.clienteId )
query.bindValue( ":usuario", constantes.CLIENTE )
if not query.exec_():
raise Exception( "No se Inserto la relacion entre el recibo y las personas" )
#INSERTAR LOS TIPOS DE PAGO
if len( self.lineas ) == 0:
raise Exception( "Deben existir pagos" )
i = 1
for linea in self.lineas:
# print insertedId + "-" + str(linea.pagoId) + "-" + str(linea.monedaId)
linea.save( insertedId, i )
i = i + 1
#INSERTAR los abonos
i = 0
if len( self.lineasAbonos ) == 0:
raise Exception( "Deben existir abonos" )
for l in self.lineasAbonos:
l.save( insertedId, i )
i = i + 1
#VERIFICO SI se aplicara la retencion
if self.aplicarRet :
#INSERTAR EL DOCUMENTO RETENCION CON EL TOTAL EN NEGATIVO, PORQUE ESTA SALIENDO DE CAJA
query.prepare( """
INSERT INTO documentos (ndocimpreso,fechacreacion,idtipodoc,total,idtipocambio,idconcepto)
VALUES ( :ndocimpreso,:fechacreacion,:idtipodoc,:total,:idtc,:concepto)
""" )
query.bindValue( ":ndocimpreso", self.retencionNumeroImpreso )
query.bindValue( ":fechacreacion", fechaCreacion )
query.bindValue( ":idtipodoc", constantes.IDRETENCION )
query.bindValue( ":total", self.obtenerRetencion.to_eng_string() )
query.bindValue( ":idtc", self.datosSesion.tipoCambioId )
query.bindValue( ":concepto", self.conceptoId )
if not query.exec_():
raise Exception( "No se Inserto la retencion" )
idret = query.lastInsertId().toString()
query.prepare( "INSERT INTO docpadrehijos (idpadre,idhijo) VALUES" +
"(:idsesion," + idret + ")," +
"(:idrecibo," + idret + ")" )
query.bindValue( ":idsesion", self.datosSesion.sesionId )
query.bindValue( ":idrecibo", insertedId )
if not query.exec_():
raise Exception( "No se Inserto la relacion entre la retencion y el recibo" )
# INSERTAR EL ID DEL COSTO RETENCION
query.prepare( """
INSERT INTO costosxdocumento (iddocumento, idcostoagregado) VALUES( :iddocumento, :idcostoagregado )
""" )
query.bindValue( ":iddocumento", insertedId )
query.bindValue( ":idcostoagregado", self.retencionId )
if not query.exec_():
raise Exception( "el costo Retencion NO SE INSERTO" )
#manejar las cuentas contables
tasa = self.datosSesion.tipoCambioOficial
movAbonoDeCliente( insertedId, self.total * tasa, self.obtenerRetencion * tasa, self.obtenerGanancia )
if sinFactura:
if not QSqlDatabase.database().commit():
raise Exception( "No se pudo hacer commit" )
except Exception as inst:
QSqlDatabase.database().rollback()
return False
return True
def save( self ):
query = QSqlQuery()
resultado = False
try:
if not QSqlDatabase.database().isOpen():
if not QSqlDatabase.database().open():
raise UserWarning( u"No se pudo conectar con la base de datos" )
if not QSqlDatabase.database().transaction():
raise Exception( u"No se pudo comenzar la transacción" )
fecha = self.datosSesion.fecha.toString( "yyyyMMdd" )
#extraer el tipo de cambio de acuerdo a la fecha junto con su id
query.prepare( "SELECT idtc,tasa,IFNULL(tasabanco,tasa) as tasabanco FROM tiposcambio t where fecha=DATE('" + fecha + "')" )
if not query.exec_():
raise Exception( "No existe una tasa de cambio para la fecha " + fecha )
if query.size() == 0:
self.error = u"La sesión de caja no fue abierta porque no existe un tipo de cambio para la fecha actual"
return False
query.first()
self.datosSesion.tipoCambioId = query.value( 0 ).toInt()[0]
self.datosSesion.tipoCambioOficial = Decimal( query.value( 1 ).toString() )
self.datosSesion.tipoCambioBanco = Decimal( query.value( 2 ).toString() )
query = QSqlQuery( "CALL spConsecutivo(%d,NULL);" % constantes.IDAPERTURA )
if not query.exec_():
raise Exception( "No pudo ser cargado el consecutivo del documento" )
query.first()
ndocimpreso = query.value( 0 ).toString()
query.prepare( """INSERT INTO documentos(ndocimpreso,total,fechacreacion,idtipodoc,idcaja,idtipocambio)
VALUES (:ndocimpreso,:total,:fecha,:tipodoc,:caja,:tipocambio)""" )
total = self.total
query.bindValue( ":ndocimpreso", ndocimpreso )
query.bindValue( ":total", total.to_eng_string() )
query.bindValue( ":fecha", fecha + QDateTime.currentDateTime().toString( "hhmmss" ) )
query.bindValue( ":tipodoc", constantes.IDAPERTURA )
query.bindValue( ":caja", self.datosSesion.cajaId )
query.bindValue( ":tipocambio", self.datosSesion.tipoCambioId )
if not query.exec_():
raise Exception( query.lastError().text() )
self.datosSesion.sesionId = query.lastInsertId().toInt()[0]
insertedId = str( self.datosSesion.sesionId )
if not query.prepare( "INSERT INTO personasxdocumento (idpersona,iddocumento,idaccion) VALUES" +
"(:usuario," + insertedId + ", " + str( constantes.ACCCREA ) + " ), "
"(:supervisor," + insertedId + "," + str( constantes.ACCAUTORIZA ) + " )" ):
raise Exception( query.lastError().text() )
query.bindValue( ":usuario", self.datosSesion.usuarioId )
query.bindValue ( ":supervisor", self.supervisorId )
if not query.exec_():
raise Exception( query.lastError().text() )
if not query.prepare( "INSERT INTO movimientoscaja(iddocumento,idtipomovimiento,idtipomoneda,monto) VALUES " +
"(" + insertedId + ",1,1,:totalCordoba), "
"(" + insertedId + ",1,2,:totalDolar)" ):
raise Exception( query.lastError().text() )
query.bindValue( ":totalCordoba", str( self.saldoCordoba ) )
query.bindValue ( ":totalDolar", str( self.saldoDolar ) )
if not query.exec_():
raise Exception( query.lastError().text() )
if not QSqlDatabase.database().commit():
raise Exception( "No se pudo hacer commit" )
resultado = True
except Exception as inst:
logging.critical( unicode( inst ) )
logging.critical( query.lastError().text() )
QSqlDatabase.database().rollback()
self.error = u"Hubo un error al guardar la sesión de caja en "\
+ "la base de datos"
finally:
if QSqlDatabase.database().isOpen():
QSqlDatabase.database().close()
return resultado
def save(self):
query = QSqlQuery()
try:
if not self.editModel.valid:
raise UserWarning("El documento no es valido, no se puede guardar")
if not self.database.isOpen():
if not self.database.open():
raise UserWarning("No se pudo conectar con la base de datos")
if not self.database.transaction():
raise Exception(u"No se pudo comenzar la transacción")
# Cargar el numero del asiento actual
query.prepare(
"""
SELECT
MAX(CAST(ndocimpreso AS SIGNED))+1
FROM documentos d
WHERE idtipodoc=24
;
"""
)
query.exec_()
query.first()
n = query.value(0).toString()
if n == "0":
n = "1"
if not query.prepare(
"""
INSERT INTO documentos (ndocimpreso, fechacreacion, idconcepto, idtipodoc)
VALUES (:ndocimpreso, :fechacreacion, :idconcepto, %d)
"""
% constantes.IDAJUSTECONTABLE
):
raise Exception("No se pudo preparar la consulta para guardar el documento")
query.bindValue(":ndocimpreso", n)
query.bindValue(":fechacreacion", self.dtPicker.dateTime().toString("yyyyMMddhhmmss"))
query.bindValue(
":idconcepto", self.conceptsmodel.record(self.cbConcepts.currentIndex()).value("idconcepto").toInt()[0]
)
if not query.exec_():
raise Exception("No se pudo ejecutar la consulta para guardar el asiento")
insertedId = query.lastInsertId().toInt()[0]
if not query.prepare(
"""
INSERT INTO personasxdocumento (idpersona, iddocumento, idaccion)
VALUES (:usuario, :documento, :idaccion)
"""
):
raise Exception("No se pudo preparar la consulta para insertar el usuario")
query.bindValue(":usuario", self.user.uid)
query.bindValue(":documento", insertedId)
query.bindValue(":idaccion", constantes.ACCCREA)
if not query.exec_():
raise Exception(u"No se pudo guardar la relación con el usuario")
for lineid, line in enumerate(self.editModel.lines):
if line.valid:
line.save(insertedId, lineid + 1)
if not self.database.commit():
raise Exception("No se pudo ejecutar la transaccion")
self.tableDetails.setModel(self.detailsproxymodel)
self.updateModels()
self.status = False
except UserWarning as inst:
QMessageBox.critical(self, qApp.organizationName(), unicode(inst))
logging.error(inst)
except Exception as inst:
QMessageBox.critical(self, qApp.organizationName(), "Hubo un error al tratar de guardar su ajuste")
self.database.rollback()
logging.critical(inst)
logging.critical(query.lastError().text())
finally:
if self.database.isOpen():
self.database.close()
def on_actionAnular_activated( self ):
if self.anulable == 2:
QMessageBox.warning( self, qApp.organizationName(),
u"La factura no puede anularse. Solo las"\
+ " facturas confirmadas o en proceso de "\
+ "autorización pueden anularse" )
elif self.anulable == 3:
QMessageBox.warning( self, qApp.organizationName(),
u"La factura no puede anularse porque no "\
+ "es del día de hoy" )
elif self.anulable == 4:
QMessageBox.warning( self, qApp.organizationName(),
u"La factura no puede anularse porque tiene"\
+ " abonos" )
elif self.anulable == 5:
QMessageBox.warning( self, qApp.organizationName(),
u"La factura no puede anularse porque tiene"\
+ " devoluciones" )
elif self.anulable == 1:
currentIndex = self.mapper.currentIndex()
record = self.navmodel.record( currentIndex )
doc = record.value( "iddocumento" ).toInt()[0]
estado = record.value( "idestado" ).toInt()[0]
total = record.value( "totalfac" ).toString()
bodega = record.value( IDBODEGA ).toInt()[0]
if total != "":
total = Decimal( total )
query = QSqlQuery()
try:
if not self.database.isOpen():
if not self.database.open():
raise Exception( "NO se pudo abrir la Base de datos" )
if estado == 3:
if QMessageBox.question( self, qApp.organizationName(),
u"Esta factura no fue confirmada,"\
+ " ¿Desea eliminarla?",
QMessageBox.Yes | QMessageBox.No ) == QMessageBox.Yes:
query = QSqlQuery()
query.prepare( "CALL spEliminarFactura(:doc)" )
query.bindValue( ":doc", doc )
if not query.exec_():
raise Exception( "No se pudo eliminar el la factura" )
QMessageBox.information( self, qApp.organizationName(),
"La factura fue eliminada correctamente" )
self.updateModels()
else:
if QMessageBox.question( self, qApp.organizationName(),
u"¿Esta seguro que desea anular la factura?",
QMessageBox.Yes | QMessageBox.No ) == QMessageBox.Yes:
nfac = self.navmodel.record( self.mapper.currentIndex() ).value( "No. Factura" ).toString()
anulardialog = DlgAnular( nfac )
if anulardialog.conceptosmodel.rowCount() == 0:
QMessageBox.warning( self, qApp.organizationName(),
u"No existen conceptos para la anulación" )
else:
if anulardialog.exec_() == QDialog.Accepted:
if anulardialog.cboConceptos.currentIndex() == -1 and anulardialog.txtObservaciones.toPlainText() == "":
QMessageBox.critical( self, qApp.organizationName(), "No ingreso los datos correctos", QMessageBox.Ok )
else:
if not self.database.transaction():
raise Exception( "No se pudo comenzar la transacción" )
#Cambiar estado Anulado=1 para documento
query.prepare( "UPDATE documentos d SET idestado=%d where iddocumento=%d LIMIT 1" % ( constantes.ANULACIONPENDIENTE, doc ) )
if not query.exec_():
raise Exception( "No se logro cambiar el estado a el documento" )
#Insertar documento anulacion
if not query.prepare( """
INSERT INTO documentos(ndocimpreso,total,fechacreacion,idtipodoc,observacion,idestado, idbodega)
VALUES(:ndocimpreso,:total,NOW(),:idtipodoc,:observacion,:idestado, :idbodega)""" ):
raise Exception( query.lastError().text() )
query.bindValue( ":ndocimpreso", nfac )
query.bindValue( ":total", str( total ) )
# query.bindValue( ":fechacreacion", QDateTime.currentDateTime().toString('yyyyMMddhhmmss') )
query.bindValue( ":idtipodoc", constantes.IDANULACION )
query.bindValue( ":observacion", anulardialog.txtObservaciones.toPlainText() )
query.bindValue( ":idestado", constantes.PENDIENTE )
query.bindValue( ":idbodega", bodega )
if not query.exec_():
raise Exception( "No se pudo insertar el documento Anulacion" )
insertedId = query.lastInsertId().toString()
if not query.prepare( "INSERT INTO docpadrehijos (idpadre,idhijo) VALUES" +
"(:idfac," + insertedId + ")" ):
# "(:usuario," + insertedId + ",0),"
# "(:supervisor," + insertedId + ",1)"):
raise Exception( query.lastError().text() + "No se preparo la relacion de la anulacion con la factura" )
query.bindValue( ":idfac", doc )
if not query.exec_():
raise Exception( "No se pudo insertar la relacion de la Anulacion con la factura" )
if not query.prepare( "INSERT INTO personasxdocumento (idpersona,iddocumento,idaccion) VALUES" \
+ "(:usuario," + insertedId + ",:accion)" ):
raise Exception( "No se inserto el usuario y autoriza" )
query.bindValue( ":usuario", self.parentWindow.datosSesion.usuarioId )
query.bindValue ( ":accion", constantes.AUTOR )
if not query.exec_():
raise Exception( "No se pudo Insertar la relacion de la anulacion con el usuario" )
if not self.database.commit():
raise Exception( "No se hizo el commit para la Anulacion" )
QMessageBox.information( self,
qApp.organizationName(),
"Factura anulada Correctamente",
QMessageBox.Ok )
self.updateModels()
except Exception as inst:
logging.error( unicode( inst ) )
logging.error( query.lastError().text() )
QMessageBox.critical( self, qApp.organizationName(),
unicode( inst ) )
self.database.rollback()
except Exception as inst:
logging.critical( unicode( inst ) )
logging.critical( query.lastError().text() )
QMessageBox.critical( self,
qApp.organizationName(),
"Hubo un error al intentar anular "\
+ "la factura" )
self.database.rollback()
finally:
if self.database.isOpen():
self.database.close()
class FrmCierreCaja ( QDialog, Ui_dlgApertura ):
def __init__( self, user, user2, sesion, parent = None ):
super( FrmCierreCaja, self ).__init__( parent )
self.setupUi( self )
self.user = user
self.user2 = user2
self.db = QSqlDatabase.database()
self.query = QSqlQuery( """
SELECT
d.fechacreacion,
c.idcaja,
c.descripcion
FROM documentos d
LEFT JOIN docpadrehijos dp ON dp.idpadre=d.iddocumento
LEFT JOIN documentos hijo ON dp.idhijo=hijo.iddocumento AND hijo.idtipodoc=%d
JOIN cajas c on d.idcaja=c.idcaja
WHERE d.idtipodoc=%d and d.idusuario= %d
AND hijo.iddocumento IS NULL
ORDER BY d.iddocumento DESC
LIMIT 1;""" % ( constantes.IDAPERTURA, constantes.IDAPERTURA, user.uid ) )
if not self.query.exec_():
raise Exception( "No se pudo preparar la Query" )
self.query.first()
self.dtFechaTime.setDate( self.query.value( 0 ).toDate() )
self.cboCaja.addItem( self.query.value( 2 ).toString() )
self.txtUsuario.setText( self.user.user )
self.txtUsuario.setReadOnly( True )
self.dtFechaTime.setReadOnly( True )
self.dtFechaTime.dateTime().toString( "yyyyMMddhhmmss" )
self.sesion = sesion
@pyqtSlot()
def on_buttonBox_accepted( self ):
"""
Agrega una apertura de caja
"""
try:
query = QSqlQuery()
query = QSqlQuery( """
SELECT
MAX(CAST(ndocimpreso AS SIGNED))+1
FROM documentos d
WHERE idtipodoc=17
;
""" )
if not query.exec_():
raise Exception( "No se puedo prepara el query del numero de cierre" )
query.first()
ndocimpreso = query.value( 0 ).toString()
if ndocimpreso == "0" :
ndocimpreso = "1"
if not query.prepare( """
INSERT INTO documentos(ndocimpreso,total,fechacreacion,
idtipodoc,idusuario,idcaja,observacion)
VALUES(:ndocimpreso,:total,:fecha,:tipodoc,
:usuario,:caja,:observacion)""" ):
raise Exception( query.lastError().text() )
query.bindValue( ":ndocimpreso", ndocimpreso )
query.bindValue( ":total", self.txtMonto.text() )
query.bindValue( ":fecha", self.dtFechaTime.dateTime().toString( "yyyyMMddhhmmss" ) )
query.bindValue( ":tipodoc", constantes.IDCIERRESESION )
query.bindValue( ":usuario", self.user.uid )
query.bindValue( ":caja", self.query.value( 1 ) )
query.bindValue( ":observacion", self.user2 )
if not query.exec_():
raise Exception( " Insert de cierre " )
idcierre = self.query.lastInsertId().toInt()[0]
if not query.prepare( """
INSERT INTO docpadrehijos(idpadre,idhijo,monto)
VALUES(:idpadre,:idhijo,:monto)""" ):
raise Exception( query.lastError().text() )
query.bindValue( ":idpadre", self.sesion )
query.bindValue( ":idhijo", idcierre )
query.bindValue( ":monto", self.txtMonto.text() )
if not query.exec_():
raise Exception( " Insert de docpadrehijos" )
self.accept()
except Exception as inst:
self.reject()
def on_buttonBox_cancelled( self ):
"""
Cancela la apertura de caja
"""
self.reject()
def save( self ):
if QMessageBox.question(self, "Balance Inicial", u"¿Esta seguro que desea guardar el Balance Inicial?",QMessageBox.Yes | QMessageBox.No )==QMessageBox.Yes:
try:
pos = self.editModel.rowCount()-1
if self.editModel.lines[pos].amount>0:
raise UserWarning("No puede iniciar operaciones con la cuenta de capital sobregirada")
elif self.editModel.lines[pos].amount<0:
self.editModel.lines[pos].itemId = constantes.CAPITAL
query = QSqlQuery()
if not self.editModel.valid:
raise UserWarning( "El documento no es valido, no se puede guardar" )
if not self.database.isOpen():
if not self.database.open():
raise UserWarning( "No se pudo conectar con la base de datos" )
if not self.database.transaction():
raise Exception( u"No se pudo comenzar la transacción" )
# Cargar el numero del asiento actual
query.prepare( """SELECT fnConsecutivo(%d,null);
"""%constantes.IDAJUSTECONTABLE )
query.exec_()
query.first()
n = query.value( 0 ).toString()
if not query.prepare( """
INSERT INTO documentos (ndocimpreso, fechacreacion, idconcepto, idtipodoc)
VALUES (:ndocimpreso, :fechacreacion, :idconcepto, %d)
""" % constantes.IDAJUSTECONTABLE ):
raise Exception( "No se pudo preparar la consulta para guardar el documento" )
query.bindValue( ":ndocimpreso", n )
query.bindValue( ":fechacreacion", self.dtPicker.dateTime().toString( "yyyyMMddhhmmss" ) )
query.bindValue( ":idconcepto",constantes.IDCONCEPTOBALANCEINICIAL)
if not query.exec_():
raise Exception( "No se pudo ejecutar la consulta para guardar el asiento" )
insertedId = query.lastInsertId().toInt()[0]
if not query.prepare( """
INSERT INTO personasxdocumento (idpersona, iddocumento, idaccion)
VALUES (:usuario, :documento, :idaccion)
""" ):
raise Exception( "No se pudo preparar la consulta para insertar el usuario" )
query.bindValue( ":usuario", self.user.uid )
query.bindValue( ":documento", insertedId )
query.bindValue( ":idaccion", constantes.ACCCREA )
if not query.exec_():
raise Exception( u"No se pudo guardar la relación con el usuario" )
for lineid, line in enumerate( self.editModel.lines ):
if line.valid:
line.save( insertedId, lineid + 1 )
if not self.database.commit():
raise Exception( "No se pudo ejecutar la transaccion" )
QMessageBox.information(self, "Balance Inicial","El Balance Inicial se ha guardado con exito")
self.parent().inicial = False
self.parent().btnMovements.setText("Ajustes Contables" )
self.parent().status = True
self.close()
except UserWarning as inst:
QMessageBox.critical( self, qApp.organizationName(), unicode( inst ) )
logging.error( inst )
except Exception as inst:
QMessageBox.critical( self, qApp.organizationName(), "Hubo un error al tratar de guardar Balance Inicial" )
self.database.rollback()
logging.critical( inst )
logging.critical( query.lastError().text() )
finally:
if self.database.isOpen():
self.database.close()
