def load_tags_db():
'''
load user tags data from uploaded db file
Args:
file: io.BufferedRandom -> uploaded db file stream
'''
db_name = get_data_path('uploaded.db')
try:
db_upload = SqliteDatabase(db_name)
db_upload.get_tables()
except DatabaseError:
raise DBError()
db_is_old = False
tag_data = []
missed_fanhaos = []
tag_file_added = 0
sql_old = '''select item_rate.rate_value, item.fanhao
from item_rate inner
join item on item_rate.item_id = item.id
where item_rate.rate_type=1 '''
sql_new = '''select item_rate.rate_value, item.fanhao
from item_rate inner
join item on item_rate.item_id = item.fanhao
where item_rate.rate_type=1 '''
cursor = db_upload.execute_sql(sql_old)
res = cursor.fetchone()
if res:
db_is_old = True
if db_is_old:
cursor = db_upload.execute_sql(sql_old)
else:
cursor = db_upload.execute_sql(sql_new)
for row in cursor.fetchall():
tag_data.append(row)
with db_upload.atomic():
for rate_value, fanhao in tag_data:
item_rate = ItemRate.saveit(RATE_TYPE.USER_RATE, rate_value,
fanhao)
if item_rate:
tag_file_added += 1
if not Item.get_by_fanhao(fanhao):
# add to get from spider
missed_fanhaos.append(fanhao)
logger.debug(tag_data)
logger.info(f'added user tag rate: {tag_file_added}')
logger.info(f'added fanhao to download: {len(missed_fanhaos)}')
return tag_file_added, missed_fanhaos
def KfpMigrate(database: SqliteDatabase):
tables = database.get_tables()
migrator = SqliteMigrator(database)
if "rpgcharacter" in tables:
columns = database.get_columns("rpgcharacter")
if not KfpMigrator.hasColumn("retired", columns):
retiredField = BooleanField(default=False)
migrate(
migrator.add_column("rpgcharacter", "retired", retiredField)
)
if not KfpMigrator.hasColumn("last_attack", columns):
lastAttackField = DateTimeField(default=datetime.now() + timedelta(days=-1))
migrate(
migrator.add_column("rpgcharacter", "last_attack", lastAttackField)
)
if "member" in tables:
columns = database.get_columns("member")
if not KfpMigrator.hasColumn("token", columns):
tokenField = BigIntegerField(default=100)
migrate(
migrator.add_column("member", 'token', tokenField)
)
if "channel" in tables:
columns = database.get_columns("channel")
if not KfpMigrator.hasColumn("channel_id", columns):
guildIdField = IntegerField(default=-1)
migrate(
migrator.add_column('channel', 'channel_guild_id', guildIdField),
migrator.rename_column('channel', 'channel_discord_id', 'channel_id'),
)
if "item" in tables:
columns = database.get_columns("item")
if KfpMigrator.hasColumn("hidden", columns):
migrate(
migrator.drop_column('item', 'hidden'),
)
if KfpMigrator.hasColumn("buff_type", columns):
migrate(
migrator.drop_column('item', 'buff_type'),
)
if KfpMigrator.hasColumn("buff_value", columns):
migrate(
migrator.drop_column('item', 'buff_value'),
)
if not KfpMigrator.hasColumn("type", columns):
typeField = CharField(default=ItemType.NONE)
migrate(
migrator.add_column('item', 'type', typeField),
)
if not KfpMigrator.hasColumn("buff", columns):
buff = BuffField(default=Buff(BuffType.NONE, 0, -1))
migrate(
migrator.add_column('item', 'buff', buff),
)
if not KfpMigrator.hasColumn("description", columns):
description = CharField(default="")
migrate(
migrator.add_column('item', 'description', description),
)
return True
def create_data_base(self):
database = SqliteDatabase(self.db)
# Create the database connection to a db file
database.connect()
tables = database.get_tables()
# If there are no tables in the db then add this base data
if len(tables) == 0:
database.create_tables([Artist, Artwork])
#add_test_data()
database.close()
def OnInit(self):
wx.InitAllImageHandlers()
F = wx.SplashScreen(
wx.Bitmap("../icons/splash.bmp"), wx.SPLASH_TIMEOUT | wx.SPLASH_CENTER_ON_SCREEN, 2000, None, -1
)
frame_EcranPrincipal = MainFrame(None, title=u"Usine à GASE", droits=1)
self.SetTopWindow(frame_EcranPrincipal)
frame_EcranPrincipal.Show()
try:
database = SqliteDatabase("usineagase.sqlite", **{})
tables_base = database.get_tables()
except:
msg = u"Erreur de connection à la base de données"
dlg = wx.MessageDialog(None, msg, "ERREUR", wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return 0
tables_obligatoires = [
u"achats",
u"adherents",
u"adhesion_types",
u"adhesions",
u"cotisations",
u"categories",
u"credits",
u"commandes",
u"exercices",
u"fournisseurs",
u"lignes_achat",
u"lignes_commande",
u"parametres",
u"produits",
u"referents",
u"tvas",
]
if set(tables_obligatoires) - set(tables_base):
msg = u"Erreur : la base de données n'est pas accessible ou n'est pas conforme."
dlg = wx.MessageDialog(None, msg, "ERREUR", wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return 0
else:
# query = session.query(model.Exercice).filter(model.Exercice.DateDebut<datetime.today()).filter(model.Exercice.DateFin>datetime.today())
# Exercice.select().where(date_debut<datetime.today())
# if query.count() == 1:
# EXERCICE_EN_COURS = query.first()
return 1
def OnInit(self):
wx.InitAllImageHandlers()
F = wx.SplashScreen(wx.Bitmap("../icons/splash.bmp"),
wx.SPLASH_TIMEOUT | wx.SPLASH_CENTER_ON_SCREEN,
2000, None, -1)
frame_EcranPrincipal = MainFrame(None,
title=u"Usine à GASE",
droits=1)
self.SetTopWindow(frame_EcranPrincipal)
frame_EcranPrincipal.Show()
try:
database = SqliteDatabase('usineagase.sqlite', **{})
tables_base = database.get_tables()
except:
msg = u"Erreur de connection à la base de données"
dlg = wx.MessageDialog(None, msg, "ERREUR",
wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return 0
tables_obligatoires = [
u"achats", u"adherents", u"adhesion_types", u"adhesions",
u"cotisations", u"categories", u"credits", u"commandes",
u"exercices", u"fournisseurs", u"lignes_achat", u"lignes_commande",
u"parametres", u"produits", u"referents", u"tvas"
]
if set(tables_obligatoires) - set(tables_base):
msg = u"Erreur : la base de données n'est pas accessible ou n'est pas conforme."
dlg = wx.MessageDialog(None, msg, "ERREUR",
wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return 0
else:
#query = session.query(model.Exercice).filter(model.Exercice.DateDebut<datetime.today()).filter(model.Exercice.DateFin>datetime.today())
#Exercice.select().where(date_debut<datetime.today())
#if query.count() == 1:
# EXERCICE_EN_COURS = query.first()
return 1
def test_initialize() -> None:
test_db = SqliteDatabase(":memory:")
with test_db.bind_ctx(MODELS):
initialize(test_db)
assert test_db.get_tables() == [t._meta.table_name for t in MODELS]
# self.cast = cast and self.tag.sub("",str(cast)) or ""
def __str__(self):
# return self.url + " " +self.title
return self.title + " " + self.url + " " + self.number + " " + self.date + " " + self.length + " " + self.director + " " + self.maker + " " + self.label + " " + self.review + " " + str(
self.genres) + " " + str(self.cast)
def __eq__(self, other):
if isinstance(other, Video):
return self.title == other.title
else:
return False
def __ne__(self, other):
return not self.__eq__(other)
def __hash__(self):
return hash(self.title) + hash(self.title)
db.connect()
tables = db.get_tables()
if 'video' not in tables:
db.create_tables([
Video,
])
# Video.create(title = "_title", url = "_url", number = "_number", date = "_date", length = "_len", director = "_director", maker = "_maker", label = "_label", review = "_review", genres = "_genres", cast = "_cast")
if 'url' not in tables:
db.create_tables([
Url,
])
class Meta:
database = db
TABLE_NAMES = {
'qqnews_live': QQNEWS_LIVE,
'qqnews_daily_summary': QQNEWS_DAILY_SUMMARY,
'qqnews_area': QQNEWS_AREA,
'qqnews_news': QQNEWS_NEWS
}
############# Connect to db and create table if doesn't exist ###############
# Connect to DB, if table not exist, create it.
db.connect()
create_table = list(set(TABLE_NAMES.keys()) - set(db.get_tables()))
if create_table:
print('Table not exist.. create it')
tables = map(lambda x: TABLE_NAMES[x], create_table)
db.create_tables(tables)
print('Created table :', create_table)
############ CONNECT TO QQ NEWS TO GET DATA #####################
# http request from qq news
print('Scraping on :', datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
for key, url in URLS.items():
print('requesting: ', url)
resp = requests.get(url)
where(self._meta.columns['email'] == email).execute()
def change_password(self, password: str, email: str):
self.set_password(password)
self.update(password=self.password).\
where(self._meta.columns['email'] == email).execute()
@property
def check_exists_admin_user(self) -> bool:
query = self.select().where(
self._meta.columns['username'] == 'admin',
self._meta.columns['email'] == ADMIN_DEFAULT_EMAIL,
self._meta.columns['active'] == 1,
self._meta.columns['admin'] == 1)
return True if [row for row in query] else False
db.connect()
db.create_tables([
Date, VisitsCountByHour, Cities, RegionsMap, Devices, TrafficSource,
PageViewsByDevices, VisitsCountByTrafficSource
])
cases_of_create_default_models = [HoursInDay, Users]
for default_model in cases_of_create_default_models:
if default_model._meta.table_name not in db.get_tables():
db.create_tables([default_model])
default_model().insert_default_values()
db.close()
APP_DIR = get_app_dir()
if not APP_DIR.exists():
os.mkdir(APP_DIR)
DB = SqliteDatabase(str(APP_DIR / "health.db"))
def current_time():
now = datetime.now().time()
return time(hour=now.hour, minute=now.minute)
def current_date():
return datetime.now().date()
class BaseModel(Model):
class Meta:
database = DB
class Food(BaseModel):
name = CharField(max_length=20)
time = TimeField(default=current_time)
date = DateField(default=current_date)
tables = {table.__name__.lower(): table for table in [Food]}
if not set(DB.get_tables()).issuperset(tables.keys()):
DB.create_tables(tables.values())
