def __setattr__(self, name, value):
sql = util.decode("preferencias.campo=='%s'" % name)
preferencia = session.query(Preferencia).filter(
util.sql_text(sql)).first()
if preferencia != None:
tipo = preferencia.tipo
try:
# Data type: 'bool', 'int', 'float', 'string', 'password' , 'memo', 'select'
if tipo == 'int':
preferencia.valor = int(value)
elif tipo == 'float':
preferencia.valor = float(value)
else: # string | password | memo | select | bool
preferencia.valor = str(value)
session.commit()
except:
session.rollback()
if config.DEBUG:
print "%s ignored" % value
def __getattr__(self, name):
retorno = None
sql = util.decode("preferencias.campo=='%s'" % name)
preferencia = session.query(Preferencia).filter(
util.sql_text(sql)).first()
if preferencia != None:
tipo = preferencia.tipo
valor = preferencia.valor
# Data type: 'bool', 'int', 'float', 'string', 'password', 'memo', 'select'
if tipo == 'bool':
retorno = valor == "True"
elif tipo == 'int':
retorno = int(valor)
elif tipo == 'float':
retorno = float(valor)
elif tipo == 'memo':
retorno = valor.strip().split('\n')
else: # string | password | select | bool
retorno = str(valor)
return retorno
def syncronizarJuegos(self, particion):
comando = "%s -p %s ls" % (config.WBFS_APP, particion.device)
lineas = util.getSTDOUT_NOERROR_iterador(comando)
salida = []
for linea in lineas:
cachos = linea.strip().split(config.SEPARADOR)
idgame = util.decode(cachos[0])
sql = util.decode("idgame=='%s' and idParticion='%s'" %
(idgame, particion.idParticion))
juego = session.query(Juego).filter(util.sql_text(sql)).first()
if juego is not None:
# el juego ya existe, se borra
session.delete(juego)
# guardan cambios
session.commit()
try:
juego = Juego(cachos)
juego.particion = particion
# for compatibility with sqlalchemy
try:
session.add(juego)
except:
session.save(juego)
salida.append(juego)
session.commit()
except SintaxisInvalida:
continue
return salida
def getJuego(self, DEVICE, IDGAME):
sql = util.decode("particion.device='%s' and juego.idgame=='%s'" %
(DEVICE, IDGAME))
for juego, particion in session.query(Juego, Particion).filter(
util.sql_text(sql)):
return juego
return None
def iniciarPreferencia(self,
tipo,
name,
defecto='',
mostrar=False,
vbox=None,
label='',
datos_lista=None):
sql = util.decode("preferencias.campo=='%s'" % name)
preferencia = session.query(Preferencia).filter(
util.sql_text(sql)).first()
if preferencia == None:
preferencia = Preferencia(tipo, name, defecto)
# for compatibility with sqlalchemy
try:
session.add(preferencia)
except:
session.save(preferencia)
session.commit()
if mostrar:
h1 = gtk.HBox(homogeneous=False, spacing=0)
etiqueta = gtk.Label()
etiqueta.set_text("%s : " % label)
etiqueta.set_use_markup(True)
# 1 line
etiqueta.set_alignment(0.0, 0.5)
etiqueta.set_padding(5, -1)
# > 1 linea
#etiqueta.set_justify(gtk.JUSTIFY_LEFT)
etiqueta.show()
# renderizar preferencia
if tipo == 'memo':
h2 = gtk.HBox(homogeneous=False, spacing=0)
v1 = gtk.VBox(homogeneous=False, spacing=5)
textview = TextViewRelacionado(name, defecto)
buffer = gtk.TextBuffer()
buffer.set_text(preferencia.valor)
buffer.connect("changed", self.memoModificado, textview)
textview.set_buffer(buffer)
textview.show()
sw1 = gtk.ScrolledWindow()
sw1.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw1.set_size_request(-1, 120)
sw1.set_shadow_type(gtk.SHADOW_IN)
sw1.add(textview)
sw1.show()
boton = gtk.Button(_('Por defecto'))
boton.connect('clicked', self.click_por_defecto_textview,
buffer, textview)
boton.show()
etiqueta.set_alignment(0.0, 1.0)
h2.show()
v1.show()
h2.pack_start(etiqueta, expand=True, fill=True, padding=0)
h2.pack_start(boton, expand=False, fill=False, padding=0)
v1.pack_start(h2, expand=True, fill=True, padding=0)
v1.pack_start(sw1, expand=True, fill=True, padding=0)
h1.pack_start(v1, expand=True, fill=True, padding=0)
elif tipo == 'select':
if config.DEBUG:
print "creando combobox"
# ponemos la etiqueta en la izquierda
h1.pack_start(etiqueta, expand=False, fill=False, padding=0)
liststore = gtk.ListStore(str)
combobox = ComboBoxRelacionado(liststore, name, defecto)
cell = gtk.CellRendererText()
combobox.pack_start(cell, True)
combobox.add_attribute(cell, 'text', 0)
for code, language in datos_lista:
combobox.append_text("%s" % (language))
combobox.set_active(
util.get_index_by_code(datos_lista, preferencia.valor))
combobox.connect('changed', self.comboModificado, datos_lista)
combobox.show()
h1.pack_start(combobox, expand=False, fill=False, padding=0)
boton = gtk.Button(_('Por defecto'))
boton.connect('clicked', self.click_por_defecto_combo,
combobox, datos_lista)
boton.show()
h1.pack_start(boton, expand=False, fill=False, padding=0)
elif tipo == 'bool':
if config.DEBUG:
print "creando check"
check_button = CheckRelacionado(name, defecto, label)
check_button.set_active(preferencia.valor == "True")
check_button.connect("toggled", self.checkModificado)
check_button.show()
# ponemos la etiqueta en la izquierda
h1.pack_start(check_button,
expand=False,
fill=False,
padding=0)
boton = gtk.Button(_('Por defecto'))
boton.connect('clicked', self.click_por_defecto_check,
check_button)
boton.show()
h1.pack_start(boton, expand=False, fill=False, padding=0)
else:
# ponemos la etiqueta en la izquierda
h1.pack_start(etiqueta, expand=False, fill=False, padding=0)
entry = EntryRelacionado(name, defecto)
entry.set_text(preferencia.valor)
entry.set_max_length(255)
entry.set_editable(True)
entry.set_size_request(250, -1)
if tipo == 'password':
entry.set_visibility(False)
entry.connect('changed', self.entryModificado)
entry.show()
h1.pack_start(entry, expand=True, fill=True, padding=0)
boton = gtk.Button(_('Por defecto'))
boton.connect('clicked', self.click_por_defecto_entry, entry)
boton.show()
h1.pack_start(boton, expand=False, fill=False, padding=0)
h1.show()
vbox.pack_start(h1, expand=False, fill=False, padding=0)
def getJuegoWIITDB(self):
sql = util.decode("juego_wiitdb.idgame=='%s'" % (self.idgame))
return session.query(JuegoWIITDB).filter(util.sql_text(sql)).first()
def run(self):
self.limpiarTemporales()
descargado_y_ok = False
try:
self.descargarZIP()
self.descomprimirZIP()
descargado_y_ok = True
except ErrorDescargando:
self.error_importando(
_("Error descargando la informacion WiiTDB desde %s") %
self.url)
if os.path.exists(self.fichXML) and descargado_y_ok:
xmldoc = libxml2.parseFile(self.fichXML)
ctxt = xmldoc.xpathNewContext()
nodo = ctxt.xpathEval("//*[name() = 'datafile']")[0]
if self.callback_empieza_importar:
self.callback_empieza_importar(self.fichXML)
cont = 0
while not self.salir and nodo != None:
if nodo.type == "element":
if nodo.name == "datafile":
nodo = nodo.children
elif nodo.name == "WiiTDB":
self.version = int(self.leerAtributo(nodo, 'version'))
self.games = int(
self.leerAtributo(nodo, 'games').split("/")[0])
elif nodo.name == "game":
if nodo.type == "element":
iniciado = False
juego = None
name = self.leerAtributo(nodo, 'name')
if nodo.children is not None:
nodo = nodo.children
saltado = False
while not saltado and nodo.next is not None:
if nodo.type == "element":
# id, region, locale, developer, publisher, date, genre, rating, wi-fi, input, rom
if not iniciado:
if nodo.name == "id":
idgame = nodo.content
sql = util.decode(
'idgame == "%s"' % idgame)
juego_wbfs = session.query(
Juego).filter(
util.sql_text(
sql)).first()
# si no los tienes y estas descargando en masivo -> se lo salta
saltado = juego_wbfs is None and self.todos
if not saltado:
sql = util.decode(
"idgame=='%s'" %
(idgame))
try:
juego = session.query(
JuegoWIITDB
).filter(
util.sql_text(
sql)).first()
except:
self.error_importando(
_("XML invalido"))
if juego == None:
juego = JuegoWIITDB(
nodo.content, name)
iniciado = True
# ya se ha iniciado
else:
if nodo.name == "region":
juego.region = nodo.content
elif nodo.name == "locale":
lang = self.leerAtributo(
nodo, 'lang')
sql = util.decode(
"lang=='%s' and idJuegoWIITDB='%s'"
% (lang,
juego.idJuegoWIITDB))
descripcion = session.query(
JuegoDescripcion).filter(
util.sql_text(
sql)).first()
if descripcion == None:
descripcion = JuegoDescripcion(
lang)
if self.callback_nuevo_descripcion:
self.callback_nuevo_descripcion(
descripcion)
if nodo.children is not None:
nodo = nodo.children
while nodo.next is not None:
if nodo.type == "element":
if nodo.name == "title":
descripcion.title = nodo.content
elif nodo.name == "synopsis":
descripcion.synopsis = nodo.content
nodo = nodo.next
nodo = nodo.parent
# añadimos la descripcion al juego
juego.descripciones.append(
descripcion)
elif nodo.name == "developer":
juego.developer = nodo.content
elif nodo.name == "publisher":
juego.publisher = nodo.content
elif nodo.name == "date":
try:
year = int(
self.leerAtributo(
nodo, 'year'))
month = int(
self.leerAtributo(
nodo, 'month'))
day = int(
self.leerAtributo(
nodo, 'day'))
fecha = date(
year, month, day)
juego.fecha_lanzamiento = fecha
except ValueError:
pass
elif nodo.name == "genre":
valores = nodo.content
for valor in valores.split(
","):
valor = valor.strip(
).replace("'", "`")
sql = util.decode(
"nombre=='%s'" %
(valor))
genero = session.query(
Genero).filter(
util.sql_text(
sql)).first()
if genero == None:
genero = Genero(valor)
if self.callback_nuevo_genero:
self.callback_nuevo_genero(
genero)
juego.genero.append(genero)
elif nodo.name == "rating":
# crear un tipo de rating si es nuevo
tipo = self.leerAtributo(
nodo, 'type')
sql = util.decode(
"tipo=='%s'" % (tipo))
rating_type = session.query(
RatingType).filter(
util.sql_text(
sql)).first()
if rating_type == None:
rating_type = RatingType(
tipo)
juego.rating_type = rating_type
# crea una relacion si es un nuevo valor del tipo
valor = self.leerAtributo(
nodo, 'value')
sql = util.decode(
"idRatingType=='%s' and valor=='%s'"
%
(rating_type.idRatingType,
valor))
rating_value = session.query(
RatingValue).filter(
util.sql_text(
sql)).first()
if rating_value == None:
rating_value = RatingValue(
valor)
rating_type.valores.append(
rating_value)
juego.rating_value = rating_value
if nodo.children is not None:
nodo = nodo.children
while nodo.next is not None:
if nodo.type == "element":
if nodo.name == "descriptor":
valores = nodo.content
for valor in valores.split(
","):
valor = valor.strip(
)
sql = util.decode(
"idRatingType=='%s' and valor=='%s'"
%
(rating_type
.
idRatingType,
valor)
)
rating_content = session.query(
RatingContent
).filter(
util.
sql_text(
sql
)
).first()
if rating_content == None:
rating_content = RatingContent(
valor
)
rating_type.contenidos.append(
rating_content
)
juego.rating_contents.append(
rating_content
)
nodo = nodo.next
nodo = nodo.parent
elif nodo.name == "wi-fi":
juego.wifi_players = self.leerAtributo(
nodo, 'players')
try:
int(juego.wifi_players)
except:
juego.wifi_players = 0
if nodo.children is not None:
nodo = nodo.children
while nodo.next is not None:
if nodo.type == "element":
if nodo.name == "feature":
valores = nodo.content
for valor in valores.split(
","):
valor = valor.strip(
)
sql = util.decode(
"valor=='%s'"
%
(valor)
)
online_feature = session.query(
OnlineFeatures
).filter(
util.
sql_text(
sql
)
).first()
if online_feature == None:
online_feature = OnlineFeatures(
valor
)
if self.callback_nuevo_online_feature:
self.callback_nuevo_online_feature(
online_feature
)
juego.features.append(
online_feature
)
nodo = nodo.next
nodo = nodo.parent
elif nodo.name == "input":
juego.input_players = self.leerAtributo(
nodo, 'players')
if nodo.children is not None:
nodo = nodo.children
while nodo.next is not None:
if nodo.type == "element":
if nodo.name == "control":
nombres = self.leerAtributo(
nodo,
'type'
).split(",")
obligatorio = self.leerAtributo(
nodo,
'required')
'''
wiimotenunchuk, wiimote:nunchuk
'''
if nombres[
0] == "wiimotenunchuk" or nombres[
0] == "wiimote:nunchuk":
nombres = [
'wiimote',
'nunchuck'
]
for nombre in nombres:
nombre = nombre.strip(
)
'''
wiimote = wimmote
nunchuk = nunchuck
gamecube = gamegube, gamecube controller
classiccontroller = calssiccontroller, classccontroller, classic controller, classic
balanceboard = wii balance board, balance board
motionplus = motion.plus, wii motionplus
wheel = steering wheel
zapper = wii zapper
microphone = mic
'''
if nombre == "wimmote":
nombre = "wiimote"
elif nombre == "nunchuck":
nombre = "nunchuk"
elif nombre == "gamegube" or nombre == "gamecube controller":
nombre = "gamecube"
elif nombre == "calssiccontroller" or nombre == "classccontroller" or nombre == "classic controller" or nombre == "classic":
nombre = "classiccontroller"
elif nombre == "wii balance board" or nombre == "balance board":
nombre = "balanceboard"
elif nombre == "motion.plus" or nombre == "wii motionplus":
nombre = "motionplus"
elif nombre == "steering wheel":
nombre = "wheel"
elif nombre == "wii zapper":
nombre = "zapper"
elif nombre == "mic":
nombre = "microphone"
sql = util.decode(
"nombre=='%s'"
%
(nombre
))
accesorio = session.query(
Accesorio
).filter(
util.
sql_text(
sql
)
).first()
if accesorio == None:
accesorio = Accesorio(
nombre
)
if self.callback_nuevo_accesorio:
self.callback_nuevo_accesorio(
accesorio,
obligatorio
==
'true'
)
if obligatorio == 'true':
juego.obligatorio.append(
accesorio
)
else:
juego.opcional.append(
accesorio
)
# siguiente control
nodo = nodo.next
# volvemos a input
nodo = nodo.parent
elif nodo.name == "rom":
version = self.leerAtributo(
nodo, 'version')
name = self.leerAtributo(
nodo, 'name')
size = self.leerAtributo(
nodo, 'size')
crc = self.leerAtributo(
nodo, 'crc')
md5 = self.leerAtributo(
nodo, 'md5')
sha1 = self.leerAtributo(
nodo, 'sha1')
rom = Rom(
version, name, size, crc,
md5, sha1)
juego.roms.append(rom)
# siguiente hijo de game
nodo = nodo.next
#volver a game
nodo = nodo.parent
if not saltado:
if iniciado:
# for compatibility with sqlalchemy
try:
session.add(juego)
except:
session.save(juego)
if self.callback_nuevo_juego:
self.callback_nuevo_juego(juego)
else:
self.error_importando(
_("XML invalido"))
else:
self.error_importando(_("XML invalido"))
cont += 1
# callback cada 1%
try:
llamarCallback = (cont % (self.games / 100) == 0)
except ZeroDivisionError:
llamarCallback = True
if llamarCallback and self.callback_spinner:
self.callback_spinner(cont, self.games)
nodo = nodo.next
elif nodo.name == "companies":
if nodo.children is not None:
nodo = nodo.children
while nodo.next is not None:
if nodo.type == "element":
if nodo.name == "company":
code = self.leerAtributo(nodo, 'code')
name = self.leerAtributo(nodo, 'name')
sql = util.decode("code=='%s'" %
(code))
companie = session.query(
Companie).filter(
util.sql_text(sql)).first()
if companie == None:
companie = Companie(code, name)
# for compatibility with sqlalchemy
try:
session.add(companie)
except:
session.save(companie)
if self.callback_nuevo_companie:
self.callback_nuevo_companie(
companie)
nodo = nodo.next
nodo = nodo.parent
else:
self.error_importando(_("XML invalido"))
nodo = nodo.next
# libera el xml
ctxt.xpathFreeContext()
xmldoc.freeDoc()
# hacemos efectivas las transacciones
session.commit()
self.limpiarTemporales()
if self.callback_termina_importar:
self.callback_termina_importar(self.fichXML, self.todos)
else:
self.error_importando(_("No existe el XML"))
def sincronizarParticiones(self, detector=config.DETECTOR_WBFS):
salida = util.getSTDOUT_NOERROR_iterador(detector)
listaParticiones = []
for linea in salida:
if linea.find("/dev/") != -1:
cachos = linea.strip().split(config.SEPARADOR)
device = util.decode(cachos[0])
particion = self.getParticion(device)
if particion is not None:
# borrar TODOS los juegos de esta particion
query = session.query(Juego)
query = query.filter(
util.sql_text("idParticion = %d" %
particion.idParticion))
for juego in query:
session.delete(juego)
# ya borro la particion
session.delete(particion)
# guardar cambios
session.commit()
try:
particion = Particion(cachos)
# for compatibility with sqlalchemy
try:
session.add(particion)
except:
session.save(particion)
listaParticiones.append(particion)
session.commit()
except SintaxisInvalida:
continue
if len(listaParticiones) > 0:
# borrar TODOS los juegos que no sean de las particiones encontradas
query = session.query(Juego)
for particion in listaParticiones:
query = query.filter(
util.sql_text("idParticion <> %d" % particion.idParticion))
for juego in query:
session.delete(juego)
# borrar TODAS las particiones que no sean de las particiones encontradas
query = session.query(Particion)
for particion in listaParticiones:
query = query.filter(
util.sql_text("idParticion <> %d" % particion.idParticion))
for particion in query:
session.delete(particion)
# subimos cambios
session.commit()
return listaParticiones
def getParticion(self, DEVICE):
sql = util.decode("device=='%s'" % (DEVICE))
particion = session.query(Particion).filter(util.sql_text(sql)).first()
return particion