def getAuditEventsDataFrame(startTime, endTime):
wave_match = {}
timestampquery = {}
timestampquery['$gte'] = datetime.fromtimestamp(startTime, None)
timestampquery['lt'] = datetime.fromtimestamp(endTime, None)
wave_match['timestamp'] = timestampquery
group = {
"$group": {
"_id": {
"source_customer_id": "$source_customer_id"
},
"authcount": {
"$sum": {
'$cond': [{'$eq': ['$audit_type', 'USER_AUTH']}, 1, 0]
}
},
"workcount": {
"$sum": {
'$cond': [{'$eq': ['$audit_type', 'LOOKING_FOR_WORK']}, 1, 0]
}
}
}
}
project = {}
project['authcount'] = "$authcount",
project['workcount'] = "$workcount",
project['customer_id'] = "$_id.source_customer_id",
df = pd.DataFrame(list(dbc.getMonogClient().data_items.aggregate(
dbc.create_mongo_aggreagate_pipeline(match=wave_match, project=project, group=group))))
print(df.to_string())
return df
def accept(self):
# Datos
# Limitar a numeros o alfanumerico
self.datos["Numero Documento"] = unicode(self.ui.labelNDocumento.text())
self.datos["RS Emisor"] = unicode(self.ui.labelEmisor.text())
self.datos["RS Receptor"] = unicode(self.ui.labelReceptor.text())
self.datos["Fecha"] = unicode(self.ui.fechaDateEdit.text())
self.datos["Sucursal"] =unicode( self.ui.sucursalLineEdit.text())
self.datos["Glosa"] = unicode(self.ui.glosaLineEdit.text())
self.datos["Monto Exento"] = unicode(self.ui.montoExcentoSpinBox.value())
self.datos["Cuenta"] = unicode(self.ui.cuentaProveedoresClienteLineEdit.text())
self.datos["Contracuenta"] = unicode(self.ui.contracuentaLineEdit.text())
self.datos["Correlativo"] = unicode(self.ui.correlativoLineEdit.text())
if(self.ui.activoFijoCheckBox.checkState () == QtCore.Qt.Checked):
self.datos["Activo Fijo"] = 1
else:
self.datos["Activo Fijo"] = 0
# Si uno de los datos esta vacio
# TODO: Cambiar color al encontrar error
fallas = []
for key, value in self.datos.items():
if(not ("%s"%value)):
fallas.append(key)
error = ""
for i in fallas:
error = error+"%s\n"%i
if(len(fallas)!=0):
QtGui.QMessageBox.about(self, "Datos incompletos", "Faltan datos a ingresar en los siguientes campos:\n%s"%error)
else:
# Guardando
DBController.guardarFactura(self.datos, self.tipo)
self.resultado = True
self.close()
def encontrado(self, datos):
#Codigo encontrado, mostrar nuevo escanearDialog
#self.thread.parar = True
if(DBController.existeFactura(self.tipo, datos)):
qm = QtGui.QMessageBox(self)
qm.setWindowTitle('Advertencia')
qm.setText('''Esta factura ya ha sido ingresada.''')
qm.addButton(QtGui.QMessageBox.Yes).setText("Aceptar")
qm.setIcon(QtGui.QMessageBox.Warning)
reply = qm.exec_()
self.ser.open()
self.ui.estadoLabel.setText("Estado: Listo")
#if reply == QtGui.QMessageBox.Yes:
# Eliminar de la base de datos
# print "Editar Dilog!!!"
else:
agregar = AgregarDocumentoModal(self.tipo, datos)
if(agregar.resultado):
self.empresaObj = DBController.empresaPorRut(datos[("Rut Receptor","Rut Emisor")[self.tipo]])
self.codigos = DBController.obtenerCodigos(self.empresaObj)
if(self.codigos._esNuevo):
my_dialog = ConfigModal([datos[("Rut Receptor","Rut Emisor")[self.tipo]], ""])
#la wea y la wehiaguñouoihe´rghioerabrir la wea
self.window.updateTablas()
else:
pass
self.ui.estadoLabel.setText("Estado: Listo")
self.ser.open()
def backup(self):
path = QtGui.QFileDialog.getSaveFileName(self, directory=(os.path.expanduser("~/Documents/")+"dump.sql"), filter="Sql Script (*.sql)")
if(path!=""):
try:
DBController.backup(path)
#raise Exception("OIADIOASIOHDS")
except Exception as e:
traceback.print_exc()
self.mensaje("Base de datos respaldada en %s"%path)
def getDistinctData(organiztionSubscriptionId):
getWavesForProjectQuery = 'select wave_id,start_date,end_date from organization_subscription_wave_stats where organization_subscription_id = %(orgid)s '
resultSet = pd.read_sql_query(getWavesForProjectQuery, dbc.getPostgresSession(),
params={'orgid': organiztionSubscriptionId})
timezoneQuery = 'select a.id,b.tzid from tickets a, locations b where a.organization_subscription_id = %(orgid)s and a.location_id = b.id'
timezone_df = pd.read_sql_query(timezoneQuery, dbc.getPostgresSession(),
params={'orgid': organiztionSubscriptionId})
timeDataframe = createTimeDataframe(resultSet['wave_id'])
analyzeTimeData(timeDataframe, timezone_df)
def getTimeDataFrameForWave(waveId):
wave_match = {}
project_match = {}
wave_match['organization_subscription_waves.wave_id'] = ObjectId(waveId)
project_match['ticket_id'] = "$ticket_id",
project_match['data_item_timestamp'] = "$data_item_timestamp",
df = pd.DataFrame(list(dbc.getMonogClient().data_items.aggregate(
dbc.create_mongo_aggreagate_pipeline(match=wave_match, project=project_match))))
return df
def getDistanceDataFrameForWave(waveId):
wave_match = {}
project_match = {}
wave_match['organization_subscription_waves.wave_id'] = ObjectId(waveId)
project_match['ticket_id'] = "$ticket_id",
project_match['data_item_latitude'] = "$data_item_latitude",
project_match['data_item_longitude'] = "$data_item_longitude",
project_match['location_latitude'] = "$location.latitude",
project_match['location_longitude'] = "$location.longitude"
df = pd.DataFrame(list(dbc.getMonogClient().data_items.aggregate(
dbc.create_mongo_aggreagate_pipeline(match=wave_match, project=project_match))))
return df
def Firm():
if bottle.request.get_cookie("access"):
State = DBController.CheckCookie(
uuid.UUID(hex=bottle.request.get_cookie("access")))
if State:
bottle.response.headers["Content-Type"] = "application/json"
Name = Wildify(bottle.request.forms.get("Name"))
PostCode = Wildify(bottle.request.forms.get("PostCode"))
Language = bottle.request.forms.get("Language")
return (DBController.QueryFirm(Name, PostCode, Language, State))
return ({
"error":
"Sorry you are not authorised to access this data. Please try a page refresh"
})
def restaurarDB(self):
path = QtGui.QFileDialog.getOpenFileName(self, directory=(os.path.expanduser("~/Documents/")+"dump.sql"), filter="Sql Script (*.sql)")
if(path!=""):
if(DBController.verificar(path)):
# Mensaje
qm = QtGui.QMessageBox(self)
qm.setWindowTitle('Advertencia')
qm.setText(QtCore.QString(u"Al restaurar la base de datos se perderán todos los datos ingresados posterior al respaldo.\nEstá seguro de que desea realizar esta operación?"))
qm.addButton(QtGui.QMessageBox.Yes).setText("Aceptar")
qm.addButton(QtGui.QMessageBox.No).setText("Cancelar")
qm.setIcon(QtGui.QMessageBox.Warning)
reply = qm.exec_()
if reply == QtGui.QMessageBox.Yes:
DBController.restaurar(path)
self.updateTablas()
self.mensaje("Base de datos restaurada desde %s"%path)
def __init__(self, tipo, datos):
super(EditarDocumentoModal, self).__init__()
self.setWindowFlags(QtCore.Qt.WindowSystemMenuHint | QtCore.Qt.WindowTitleHint)
self.ui=Ui_Dialog_editarDocumento()
self.ui.setupUi(self)
# Tipo de documento
self.tipo = tipo
titulo = ""
if(tipo==0):
titulo = "Editar Documento Compra"
self.ui.cuentaProveedoresClienteLabel.setText("Cuenta Proveedor")
elif(tipo==1):
titulo = "Editar Documento Venta"
self.ui.cuentaProveedoresClienteLabel.setText("Cuenta Cliente")
self.setWindowTitle(titulo)
#Fecha actual
self.f = fac = DBController.getFactura(datos, tipo)
rx = QtCore.QRegExp("[0-9]*")
qr = QtGui.QRegExpValidator(rx)
self.ui.nDocumentoLineEdit.setValidator( qr )
self.ui.sucursalLineEdit.setValidator( qr)
self.ui.correlativoLineEdit.setValidator( qr )
self.ui.cuentaProveedoresClienteLineEdit.setValidator( qr )
self.ui.contracuentaLineEdit.setValidator( qr )
self.datos = datos
self.llenarDatos()
self.resultado = False
self.exec_()
def getDistinctDeviceData(organiztionSubscriptionId):
getWavesForProjectQuery = 'select wave_id,start_date,end_date from organization_subscription_wave_stats where organization_subscription_id = %(orgid)s '
resultSet = pd.read_sql_query(getWavesForProjectQuery,
dbc.getPostgresSession(),
params={'orgid': organiztionSubscriptionId})
deviceDataframe = createDeviceDataframe(resultSet['wave_id'])
processDataFrame(deviceDataframe)
def cargarDatos(self):
self.empresaObj = DBController.empresaPorRut(self.empresa[0])
self.codigos = DBController.obtenerCodigos(self.empresaObj)
if(not self.codigos._esNuevo):
self.ui.labelInfo.setVisible(False)
#TODO: Cargar datos con la cosa de la bd
# self.empresa = arreglo con empresa[0] = rut, empresa[1] = nombre,
self.ui.facturaElectronicaLineEdit.setText(self.codigos.c33)
self.ui.facturaParcialElectronicaLineEdit.setText(self.codigos.c33p)
self.ui.facturaExcentaElectronicaLineEdit.setText(self.codigos.c34)
self.ui.facturaDeCompraElectronicaLineEdit.setText(self.codigos.c46)
self.ui.facturaDeCompraParcialElectronicaLineEdit.setText(self.codigos.c46p)
self.ui.notaDebitoElectronicaLineEdit.setText(self.codigos.c56)
self.ui.notaDebitoParcialElectronicaLineEdit.setText(self.codigos.c56p)
self.ui.notaCreditoElectronicaLineEdit.setText(self.codigos.c61)
self.ui.notaCreditoParcialElectronicaLineEdit.setText(self.codigos.c61p)
def updateEmpresas(self):
self.ui.filtrarEmpresaComboBox.clear()
self.ui.filtrarEmpresaComboBox.addItem("Todas")
self.empresas = []
self.empresas.append(["Todas", ""])
for e in DBController.getEmpresas():
self.empresas.append(e)
self.ui.filtrarEmpresaComboBox.addItem(e[0]+" | "+e[1])
def hello():
try:
GUID = uuid.uuid4()
DBController.AddCookie(GUID, unicode("NSW"))
bottle.response.set_cookie("access", str(GUID), max_age=28800) #Domain
return (stopgap.a)
except Exception as e:
return (e)
def getDistinctData(organiztionSubscriptionId):
getWavesForProjectQuery = 'select wave_id,start_date,end_date from organization_subscription_wave_stats where organization_subscription_id = %(orgid)s '
resultSet = pd.read_sql_query(getWavesForProjectQuery, dbc.getPostgresSession(),
params={'orgid': organiztionSubscriptionId})
print(resultSet.to_string())
waveIdList = resultSet['wave_id']
distanceDataFrame = createDistanceDataframe(waveIdList)
def getTestConfigs():
connections = int(request.form['connections'])
time = int(request.form['time'])
operations = int(request.form['operation_number'])
conection = DBController.DBController('centralDB', 'postgres', 'aniram',
'localhost')
ob = Objects.Configs(connections, time, operations)
conection.connection(ob)
return render_template('test_result.html',
results=conection.connection(ob))
def inicializarDatos(self, tabla):
self.updateFechas()
documentos = DBController.obtenerLista(tabla.objectName(), None, None, None)
tabla.setRowCount(len(documentos))
for i in range(len(documentos)):
for j in range(len(documentos[i])):
item = QtGui.QTableWidgetItem()
item.setText(documentos[i][j])
item.setTextAlignment(QtCore.Qt.AlignHCenter|QtCore.Qt.AlignVCenter|QtCore.Qt.AlignCenter)
tabla.setItem(i, j, item) # QtGui.QTableWidgetItem(documentos[i][j])
for i in range(tabla.verticalHeader().count()):
tabla.verticalHeader().setResizeMode(i, QtGui.QHeaderView.Fixed)
tabla.setColumnHidden(tabla.horizontalHeader().count()-1, True)
def llenarUltima(self):
fact = DBController.ultimaFactura(self.datos["Rut Emisor"])
if(fact):
self.datos["Sucursal"] = unicode(fact.sucursal)
self.datos["Cuenta"] = unicode(fact.cuentaProveedores)
self.datos["Glosa"] = unicode(fact.Glosa)
self.datos["Contracuenta"] = unicode(fact.contracuenta)
self.datos["Activo Fijo"] = fact.activoFijo
self.datos["RS Emisor"] = fact.empresaEmisor.rS
self.datos["RS Receptor"] = fact.empresaReceptor.rS
self.ui.sucursalLineEdit.setText(self.datos["Sucursal"])
self.ui.glosaLineEdit.setText(self.datos["Glosa"])
self.ui.contracuentaLineEdit.setText(self.datos["Contracuenta"])
self.ui.cuentaProveedoresClienteLineEdit.setText(self.datos["Cuenta"])
def filtrar(self, data):
if(self.ui.filtrarEmpresaComboBox.currentIndex() == 0):
self.ui.editarEmpresaToolButton.setEnabled(False)
else:
self.ui.editarEmpresaToolButton.setEnabled(True)
tablas = [self.ui.tableWidget_Compras, self.ui.tableWidget_Ventas]
f = self.fechas[self.ui.fechaComboBox.currentIndex()]
if data != "":
for tabla in tablas:
documentos = DBController.obtenerLista(tabla.objectName(), unicode(self.empresas[data][0]), f[1], f[2])
tabla.clearContents()
tabla.setRowCount(len(documentos))
for i in range(len(documentos)):
for j in range(len(documentos[i])):
item = QtGui.QTableWidgetItem()
item.setText(documentos[i][j])
item.setTextAlignment(QtCore.Qt.AlignHCenter|QtCore.Qt.AlignVCenter|QtCore.Qt.AlignCenter)
tabla.setItem(i, j, item) # QtGui.QTableWidgetItem(documentos[i][j])
tabla.verticalHeader().setVisible(True)
tabla.resizeColumnsToContents()
def AddCookie():
cookie = bottle.request.query["cookie"]
state = bottle.request.query["state"]
print(cookie)
DBController.AddCookie(cookie, state)
def Test():
stime = datetime.datetime.now()
res = DBController.QueryFirm('g%', '%', "hindi", 'NSW')
ftime = datetime.datetime.now()
print(ftime - stime)
return (res)
def BuildTest():
DBController.Build(0)
def main():
dbc.configureDatabase()
dataFrame = getDistinctData(sys.argv[1])
def main():
dbc.configureDatabase()
timestampDataframe = getDistinctData(sys.argv[1])
def updateLanguageTranslation(user, language):
boolInsert = dbController.insertNewUser(user, "en", language)
if not boolInsert:
dbController.updateUser(user, language, True)
import sys
from PyQt5 import QtWidgets, uic
from PyQt5.QtWidgets import QAbstractItemView
import DBController
import ErrorMessage
from DBController import SQLExecutor
tabledata = DBController.SQLExecutor(host="159.203.59.83",
username="******",
password="******",
database="gamestop")
start = True
rowid = 0
class Ui(QtWidgets.QMainWindow):
def __init__(self):
super(Ui, self).__init__()
uic.loadUi('a.ui', self)
# GameTable
self.button = self.findChild(QtWidgets.QPushButton,
'search1') # Find the button
self.button.clicked.connect(self.searchGame)
self.input = self.findChild(QtWidgets.QLineEdit, 'searchBox1')
self.pss = self.findChild(QtWidgets.QTableWidget, 'tableGame')
self.pss.setSelectionBehavior(QAbstractItemView.SelectRows)
from flask import request, url_for, jsonify, abort
from flask_api import FlaskAPI, status, exceptions
from flask_cors import CORS
import json
from DBController import *
from Teacher import *
from Student import *
app = FlaskAPI(__name__)
dbc = DBController()
student = Student(dbc)
teacher = Teacher(dbc, student)
CORS(app)
@app.route('/lolo/api/v1.0/user/register', methods=['POST'])
def register_user():
if not request.json:
abort(400)
email = request.json["data"]["user"]["email"]
language_to_learn = request.json["data"]["user"]["language_to_learn"]
userid = dbc.insertUser(email, language_to_learn)
if userid:
return jsonify(
{
"data": {
"message": "Successfully registered",
"id": userid
def test_insert_comments:
params = { "user" : "nisreen", "host" : '127.0.0.1', "port" : "5432", "database" : 'youtube_comments'}
db = DBController(params)
comment = Comment(video_id = '_VB39Jo8mAQ', comment_id= 'test_test_test', comment=text)
db.insert_comments(comment)
def updateLanguageInputDefault(user, language):
boolInsert = dbController.insertNewUser(user, language, "es")
if not boolInsert:
dbController.updateUser(user, language, False)
def test():
conection = DBController.DBController('centralDB', 'postgres', 'aniram',
'localhost')
conection.servisiosMasCaros()
def clicked(self, position):
if(self.sender().rowCount()==0): # Ninguna fila en la tabla
return
tabla = self.sender()
menu = QtGui.QMenu()
editarAction = menu.addAction("Editar")
eliminarAction = menu.addAction("Eliminar")
contabilizar = 0
for idx in reversed(tabla.selectionModel().selectedRows()):
if(tabla.item(idx.row(),0).text()=="No"):
contabilizar = 1
break
contabilizarAction = None
if(contabilizar):
contabilizarAction = menu.addAction("Contabilizar")
else:
contabilizarAction = menu.addAction("Descontabilizar")
action = menu.exec_(tabla.viewport().mapToGlobal(position))
row = tabla.rowAt(position.y())
allRows = tabla.columnCount()
if action == contabilizarAction:
lista = []
for idx in reversed(tabla.selectionModel().selectedRows()):
datos = {}
for i in range(tabla.horizontalHeader().count()):
datos[ unicode(tabla.horizontalHeaderItem(i).text())] = unicode(tabla.item(idx.row(),i).text())
lista.append(datos)
if(self.sender().objectName()=="tableWidget_Ventas"):
DBController.contabilizar(self, 1,contabilizar, lista)
else:
DBController.contabilizar(self, 0,contabilizar, lista)
elif action == editarAction:
datos = {}
for i in range(tabla.horizontalHeader().count()):
datos[ unicode(tabla.horizontalHeaderItem(i).text())] = unicode(tabla.item(row,i).text())
tipo = 0
if(self.sender().objectName()=="tableWidget_Ventas"):
tipo = 1
fac = DBController.getFactura(datos, tipo)
datos["Cuenta"] = fac.cuentaProveedores
datos["Correlativo"] = unicode(fac.correlativo)
my_dialog = EditarDocumentoModal(tipo, datos )
if(my_dialog.resultado):
self.updateTablas()
elif action == eliminarAction:
# TODO: lanzar evento al oprimir suprimir,
qm = QtGui.QMessageBox(self)
qm.setWindowTitle('Eliminar documento')
if( len(tabla.selectionModel().selectedRows()) == 1):
qm.setText("Esta seguro de que desea eliminar el documento ?")
else:
qm.setText("Esta seguro de que desea eliminar los %d documentos ?"%len(tabla.selectionModel().selectedRows()))
qm.addButton(QtGui.QMessageBox.Yes).setText("Si")
qm.addButton(QtGui.QMessageBox.No).setText("No")
qm.setIcon(QtGui.QMessageBox.Question)
reply = qm.exec_()
if reply == QtGui.QMessageBox.Yes:
for idx in reversed(tabla.selectionModel().selectedRows()):
DBController.eliminarFactura(tabla.item(idx.row(),16).text())
tabla.removeRow(idx.row())
def deshacer(self):
DBController.contabilizarFacturas(self.contabilizados, self.cambiarContabilizados)
self.ui.deshacerToolButton.setEnabled(False)
self.ui.rehacerToolButton.setEnabled(True)
self.updateTablas()
def exportar(self):
# Opciones
if(self.ui.filtrarEmpresaComboBox.currentIndex() == 0):
qm = QtGui.QMessageBox(self)
qm.setWindowTitle('Advertencia')
qm.setText(u'¿Esta seguro de que desea exportar todas las facturas?')
qm.addButton(QtGui.QMessageBox.Yes).setText("Si")
qm.addButton(QtGui.QMessageBox.No).setText("No")
qm.setIcon(QtGui.QMessageBox.Warning)
reply = qm.exec_()
if reply == QtGui.QMessageBox.No:
return
contabilizar = self.ui.contabilizarCheckBox.isChecked()
guardar = self.ui.guardarCheckBox.isChecked()
centro = self.ui.centroLineEdit.text()
especial = self.ui.codigoLineEdit.text()
archivo = None
correlativo = self.ui.correlativoDoubleSpinBox.value()
if(self.sender().objectName() == "toolButtonPlano"):
archivo = QtGui.QFileDialog.getSaveFileName(self, directory=(os.path.expanduser("~/Documents/")+"Facturas.tcv"), filter="Texto tcv (*.tcv)")
else:
archivo = QtGui.QFileDialog.getSaveFileName(self, directory=(os.path.expanduser("~/Documents/")+"Facturas.xls"), filter="Microsoft Excel (*.xls)")
if(archivo != ""):
self.ui.deshacerToolButton.setEnabled(False)
self.ui.rehacerToolButton.setEnabled(False)
#TODO: try permiso de escritura
if(self.sender().objectName() != "toolButtonPlano"):
month = self.fechas[self.ui.fechaComboBox.currentIndex()][1]
year = self.fechas[self.ui.fechaComboBox.currentIndex()][2]
print "YEYYEYE",year
print "MJSAASD",month
try:
if(contabilizar):
tablas = [self.ui.tableWidget_Compras, self.ui.tableWidget_Ventas]
self.contabilizados = []
self.cambiarContabilizados = False
for tabla in tablas:
allRows = tabla.rowCount()
for row in xrange(0,allRows):
c = unicode(tabla.item(row,0).text())
Id = unicode(tabla.item(row,tabla.horizontalHeader().count()-1).text())
if(c == "No"):
self.contabilizados.append(int(Id))
DBController.exportarExcel(unicode(self.empresas[self.ui.filtrarEmpresaComboBox.currentIndex()][0]), archivo, contabilizar, guardar, month, year, correlativo, centro, especial)
print "WEWEWE"
if(len(self.contabilizados)!=0):
#DBController.contabilizarFacturas(self.contabilizados, 1)
self.ui.deshacerToolButton.setEnabled(True)
self.updateTablas()
self.mensaje("Archivo exportado en: " + unicode(archivo))
qm = QtGui.QMessageBox(self)
qm.setWindowTitle('Abrir archivo')
qm.setText("Exportado existosamente. Desea abrir el archivo?")
qm.addButton(QtGui.QMessageBox.Yes).setText("Si")
qm.addButton(QtGui.QMessageBox.No).setText("No")
qm.setIcon(QtGui.QMessageBox.Information)
reply = qm.exec_()
if reply == QtGui.QMessageBox.Yes:
os.startfile(unicode(archivo))
except:
traceback.print_exc()
qm = QtGui.QMessageBox(self)
qm.setWindowTitle('Error de escritura')
qm.setText("Se produjo un error al exportar el archivo, verifique que no tiene el archivo de salida abierto")
qm.addButton(QtGui.QMessageBox.Yes).setText("Aceptar")
qm.setIcon(QtGui.QMessageBox.Warning)
reply = qm.exec_()
DBController.contabilizarFacturas(self.contabilizados, False)
"$unwind":
"$testedWords"
}, {
"$match": {
"testedWords.lang": lang,
'testedWords.nbOfSuccess': {
'$eq': 0
}
}
}, {
"$project": {
"testedWords.wordID": 1,
"_id": 0
}
}])
#to only have distinct wordIds in res
res = list(res)
seen = set()
res_ok = [
elem for elem in res
if [(elem["testedWords"]["wordID"]) not in seen,
seen.add(elem["testedWords"]["wordID"])][0]
]
return list(res_ok)
if __name__ == '__main__':
db = DBController()
sd = Student(db)
print(sd.getPercentageOfWordsPassed("5c9d3e6b2344ef4d810419e9"))
def __init__(self):
self.dbController = DBController.DBController()
self.dataAnalysis = DataAnalysis.DataAnalysis()
def updateFechas(self):
self.ui.fechaComboBox.clear()
self.fechas = DBController.obtenerFechas()
for f in self.fechas:
self.ui.fechaComboBox.addItem(f[0])
