Max/AttackVector_AVNetwork
1
0
Fork 0
mirror of https://gitea.tendokyu.moe/AttackVector/AVNetwork.git synced 2026-09-22 22:27:58 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
main
AttackVector_AVNetwork/database.py
T
ATKV 317686f89b ATKVNetwork initial Release
2026-01-26 18:48:28 -05:00

2476 lines
91 KiB
Python
Raw Permalink Blame History

import re
from sqlalchemy import (
create_engine,
Column,
Integer,
String,
Sequence,
BLOB,
create_engine,
text,
func,
desc,
asc,
)
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from kbinxml import KBinXML
import xmltodict
import json
import random
# Define the base class for our models
Base = declarative_base()
db_type = "sqlite" # Change to 'mysql' to use MySQL
# Declare Databases
class eacNetProfile(Base):
__tablename__ = "eacNetProfile"
id = Column(Integer, Sequence("user_id_seq"), primary_key=True)
token = Column(String(16), unique=True)
refid = Column(String(16), unique=True)
snsid = Column(String(8), unique=True)
ddrTicket = Column(Integer, default=0)
livelyTicket = Column(Integer, default=0)
def __repr__(self):
return (
f"eacNetProfile(id={self.id}, token='{self.token}',",
f"refid='{self.refid}',"
f"snsid='{self.snsid}',"
f"ddrTicket='{self.ddrTicket}',"
f"livelyTicket='{self.livelyTicket}')",
)
class infProfile(Base):
__tablename__ = "infinitasProfile"
id = Column(Integer, Sequence("user_id_seq"), primary_key=True)
infinitasID = Column(String(13), unique=True)
name = Column(String(6))
version = Column(String(20))
prefID = Column(Integer)
playSP = Column(Integer, default=0)
playDP = Column(Integer, default=0)
achieveSP = Column(Integer, default=0)
achieveDP = Column(Integer, default=0)
danSP = Column(Integer, default=-1)
danDP = Column(Integer, default=-1)
totalPlays = Column(Integer, default=0)
totalClears = Column(Integer, default=0)
saveLength = Column(Integer)
saveData = Column(BLOB)
saveCheck = Column(String)
saveDataBackup = Column(BLOB)
saveLengthBackup = Column(Integer)
saveCheckBackup = Column(String)
bits = Column(Integer, default=0)
def __repr__(self):
return (
f"infProfile(id={self.id}, infinitasID='{self.infinitasID}', name='{self.name}', "
f"version='{self.version}', prefID={self.prefID}, bits={self.bits}, playSP={self.playSP}, "
f"playDP={self.playDP}, achieveSP={self.achieveSP}, achieveDP={self.achieveDP}, "
f"danSP={self.danSP}, danDP={self.danDP}, totalPlays={self.totalPlays}, totalClears={self.totalClears}, saveLength={self.saveLength}, saveData={self.saveData}, saveCheck={self.saveCheck}, saveLengthBackup={self.saveLength}, saveDataBackup={self.saveData}, saveCheckBackup={self.saveCheck})"
)
class infToken(Base):
__tablename__ = "infinitasToken"
id = Column(Integer, Sequence("user_id_seq"), primary_key=True)
infinitasID = Column(String(13), unique=True)
token = Column(String(20), unique=True)
def __repr__(self):
return f"infToken(infinitasID='{self.infinitasID}', token='{self.token}')"
class InfinitasPlayData(Base):
__tablename__ = "infinitasPlayData"
id = Column(Integer, primary_key=True)
infinitasID = Column(String(13), nullable=False)
musicID = Column(Integer, nullable=False)
missCount = Column(String, nullable=True) # Store as JSON string
playCount = Column(String, nullable=True) # Store as JSON string
clearAmount = Column(String, nullable=True) # Store as JSON string
clearFlag = Column(String, nullable=True) # Store as JSON string
score = Column(String, nullable=True) # Store as JSON string
def __repr__(self):
return (
f"InfinitasPlayData(id={self.id}, "
f"infinitasID='{self.infinitasID}', "
f"musicID={self.musicID}, "
f"missCount={self.missCount}, "
f"playCount={self.playCount}, "
f"clearAmount={self.clearAmount}, "
f"clearFlag={self.clearFlag}, "
f"score={self.score})"
)
class infPlayDataExt(Base):
__tablename__ = "infinitasPlayDataExt"
id = Column(Integer, Sequence("user_id_seq"), primary_key=True)
infinitasID = Column(String(13))
clock = Column(Integer)
musicID = Column(Integer)
noteID = Column(Integer)
score = Column(Integer)
pgreat = Column(Integer)
great = Column(Integer)
miss = Column(Integer)
clearType = Column(Integer)
def __repr__(self):
return f"infinitasPlayDataExt(infinitasID='{self.infinitasID}', token='{self.token}')"
class infRivalData(Base):
__tablename__ = "infinitasRivalData"
id = Column(Integer, Sequence("user_id_seq"), primary_key=True)
infinitasID = Column(String(13), unique=True)
spRivals = Column(String(), default="[]")
dpRivals = Column(String(), default="[]")
def __repr__(self):
return f"infinitasRivalData(infinitasID='{self.infinitasID}', spRivals='{self.spRivals}, dpRivals='{self.dpRivals}')"
class infGhostData(Base):
__tablename__ = "infinitasGhostData"
id = Column(Integer, Sequence("user_id_seq"), primary_key=True)
infinitasID = Column(String(13))
name = Column(String)
score = Column(Integer)
danRank = Column(Integer)
prefecture = Column(Integer)
musicID = Column(Integer)
noteID = Column(Integer)
ghost = Column(BLOB)
ghostCheck = Column(String)
ghostSize = Column(Integer)
flip = Column(Integer)
assist = Column(Integer)
arrange1 = Column(Integer)
arrange0 = Column(Integer)
def __repr__(self):
return (
f"infGhostData(id={self.id}, "
f"infinitasID='{self.infinitasID}', "
f"name='{self.name}', "
f"score={self.score}, "
f"danRank={self.danRank}, "
f"prefecture={self.prefecture}, "
f"musicID={self.musicID}, "
f"noteID={self.noteID}, "
f"ghost={self.ghost}, "
f"ghostCheck='{self.ghostCheck}', "
f"ghostSize={self.ghostSize}, "
f"flip={self.flip}, "
f"assist={self.assist}, "
f"arrange1={self.arrange1}, "
f"arrange0={self.arrange0})"
)
class infItems(Base):
__tablename__ = "infinitasItems"
id = Column(Integer, Sequence("user_id_seq"), primary_key=True)
infinitasID = Column(String(13), unique=True)
TicketsPaid = Column(Integer, default=0)
TicketsFree = Column(Integer, default=0)
lDiscs = Column(Integer, default=0)
musicPacks = Column(String, default="[]")
customizations = Column(
String,
default='["","I1100000","I1200000","I1300000","I1400000","I1500000","I1600000","I1700000","","I1900000","I1300000","I2100000"]',
)
otherCustomizations = Column(
String, default='["C1000000","C1100000","C1200000","C1300000","C1400000"]'
)
def __repr__(self):
return f"infinitasItems(infinitasID='{self.infinitasID}', TicketsPaid='{self.TicketsPaid}', TicketsFree='{self.TicketsFree}', lDiscs='{self.lDiscs}', musicPacks='{self.musicPacks}', customizations='{self.customizations}', otherCustomizations='{self.otherCustomizations}'"
class infUnlocks(Base):
__tablename__ = "infinitasUnlocks"
id = Column(Integer, Sequence("user_id_seq"), primary_key=True)
infinitasID = Column(String(13))
musicID = Column(Integer, default=0)
type = Column(Integer, default=0)
note_bit = Column(Integer, default=0)
def __repr__(self):
return f"infinitasItems(infinitasID='{self.infinitasID}', musicID='{self.musicID}', type='{self.type}', note_bit='{self.note_bit}', "
class DMGFProfile(Base):
__tablename__ = "gitadoraProfile"
id = Column(Integer, Sequence("user_id_seq"), primary_key=True)
token = Column(String(16), unique=True)
refid = Column(String(16), unique=True)
did = Column(String(8), unique=True)
usercode = Column(String(10), unique=True)
DMskill = Column(Integer(), default=0)
DMallSkill = Column(Integer(), default=0)
DMoldSkill = Column(Integer(), default=-1)
DMoldAllSkill = Column(Integer(), default=-1)
GFskill = Column(Integer(), default=0)
GFallSkill = Column(Integer(), default=0)
GFoldSkill = Column(Integer(), default=-1)
GFoldAllSkill = Column(Integer(), default=-1)
def __repr__(self):
return (
f"DMGFProfile(id={self.id}, token='{self.token}',",
f"refid='{self.refid}',",
f"did='{self.did}',",
f"usercode='{self.usercode}',",
f"DMskill='{self.DMskill}',",
f"DMallSkill='{self.DMallSkill}',"
f"DMoldSkill='{self.DMoldSkill}',",
f"DMoldAllSkill='{self.DMoldAllSkill}',",
f"GFoldAllSkill='{self.GFoldAllSkill}',",
f"GFskill='{self.GFskill}',",
f"GFlastMusic='{self.GFoldSkill}')",
)
class DMGFProfileExt(Base):
__tablename__ = "gitadoraProfileExt"
musicFavorites = '"-1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1"'
playStyleCustom = "0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 20 0 0 0 0 0 0 0 0 0 0 20 0"
id = Column(Integer, Sequence("user_id_seq"), primary_key=True)
token = Column(String(16), unique=True)
refid = Column(String(16), unique=True)
did = Column(String(8), unique=True)
DMplaystyle = Column(String(), default=playStyleCustom)
DMcustom = Column(String(), default=playStyleCustom)
DMmusicFavorites1 = Column(String(), default=musicFavorites)
DMmusicFavorites2 = Column(String(), default=musicFavorites)
DMmusicFavorites3 = Column(String(), default=musicFavorites)
DMlastCategory = Column(Integer(), default=0)
DMlastMusic = Column(Integer(), default=-1)
DMlastSeq = Column(Integer(), default=0)
DMdisplayLevel = Column(Integer(), default=0)
GFplaystyle = Column(String(), default=playStyleCustom)
GFcustom = Column(String(), default=playStyleCustom)
GFmusicFavorites1 = Column(String(), default=musicFavorites)
GFmusicFavorites2 = Column(String(), default=musicFavorites)
GFmusicFavorites3 = Column(String(), default=musicFavorites)
GFlastCategory = Column(Integer(), default=0)
GFlastMusic = Column(Integer(), default=-1)
GFlastSeq = Column(Integer(), default=0)
GFdisplayLevel = Column(Integer(), default=0)
def __repr__(self):
return (
f"DMGFProfileExt(id={self.id}, token='{self.token}', "
f"refid='{self.refid}', did='{self.did}', "
f"DMplaystyle='{self.DMplaystyle}', DMcustom='{self.DMcustom}', "
f"DMmusicFavorites1='{self.DMmusicFavorites1}', DMmusicFavorites2='{self.DMmusicFavorites2}', "
f"DMmusicFavorites3='{self.DMmusicFavorites3}', "
f"DMlastCategory='{self.DMlastCategory}',"
f"DMlastMusic='{self.DMlastMusic}',"
f"DMlastSeq='{self.DMlastSeq}',"
f"DMdisplayLevel='{self.DMdisplayLevel}',"
f"GFplaystyle='{self.GFplaystyle}', GFcustom='{self.GFcustom}', "
f"GFmusicFavorites1='{self.GFmusicFavorites1}', GFmusicFavorites2='{self.GFmusicFavorites2}', "
f"GFmusicFavorites3='{self.GFmusicFavorites3}',"
f"GFlastCategory='{self.GFlastCategory}',"
f"GFlastMusic='{self.GFlastMusic}',"
f"GFlastSeq='{self.GFlastSeq}"
f"GFdisplayLevel='{self.GFdisplayLevel}')"
)
class DMGFProfileDetails(Base):
__tablename__ = "gitadoraProfileDetails"
id = Column(Integer, Sequence("user_id_seq"), primary_key=True)
token = Column(String(16), unique=True)
refid = Column(String(16), unique=True)
did = Column(String(8), unique=True)
# Drum Mania fields
DMcabid = Column(Integer, default=0)
DMplay = Column(Integer, default=0)
DMplaytime = Column(Integer, default=0)
DMplayterm = Column(Integer, default=0)
DMsession_cnt = Column(Integer, default=0)
DMmatching_num = Column(Integer, default=0)
DMextra_stage = Column(Integer, default=0)
DMextra_play = Column(Integer, default=0)
DMextra_clear = Column(Integer, default=0)
DMencore_play = Column(Integer, default=0)
DMencore_clear = Column(Integer, default=0)
DMpencore_play = Column(Integer, default=0)
DMpencore_clear = Column(Integer, default=0)
DMmax_clear_diff = Column(Integer, default=0)
DMmax_full_diff = Column(Integer, default=0)
DMmax_exce_diff = Column(Integer, default=0)
DMclear_num = Column(Integer, default=0)
DMfull_num = Column(Integer, default=0)
DMexce_num = Column(Integer, default=0)
DMno_num = Column(Integer, default=0)
DMe_num = Column(Integer, default=0)
DMd_num = Column(Integer, default=0)
DMc_num = Column(Integer, default=0)
DMb_num = Column(Integer, default=0)
DMa_num = Column(Integer, default=0)
DMs_num = Column(Integer, default=0)
DMss_num = Column(Integer, default=0)
# Guitar Freaks fields
GFcabid = Column(Integer, default=0)
GFplay = Column(Integer, default=0)
GFplaytime = Column(Integer, default=0)
GFplayterm = Column(Integer, default=0)
GFsession_cnt = Column(Integer, default=0)
GFmatching_num = Column(Integer, default=0)
GFextra_stage = Column(Integer, default=0)
GFextra_play = Column(Integer, default=0)
GFextra_clear = Column(Integer, default=0)
GFencore_play = Column(Integer, default=0)
GFencore_clear = Column(Integer, default=0)
GFpencore_play = Column(Integer, default=0)
GFpencore_clear = Column(Integer, default=0)
GFmax_clear_diff = Column(Integer, default=0)
GFmax_full_diff = Column(Integer, default=0)
GFmax_exce_diff = Column(Integer, default=0)
GFclear_num = Column(Integer, default=0)
GFfull_num = Column(Integer, default=0)
GFexce_num = Column(Integer, default=0)
GFno_num = Column(Integer, default=0)
GFe_num = Column(Integer, default=0)
GFd_num = Column(Integer, default=0)
GFc_num = Column(Integer, default=0)
GFb_num = Column(Integer, default=0)
GFa_num = Column(Integer, default=0)
GFs_num = Column(Integer, default=0)
GFss_num = Column(Integer, default=0)
def __repr__(self):
return (
f"DMGFProfileDetails(id={self.id}, token='{self.token}', "
f"refid='{self.refid}', did='{self.did}', "
# Drum Mania fields
f"DMcabid={self.DMcabid}, "
f"DMplay={self.DMplay}, "
f"DMplaytime={self.DMplaytime}, "
f"DMplayterm={self.DMplayterm}, "
f"DMsession_cnt={self.DMsession_cnt}, "
f"DMmatching_num={self.DMmatching_num}, "
f"DMextra_stage={self.DMextra_stage}, "
f"DMextra_play={self.DMextra_play}, "
f"DMextra_clear={self.DMextra_clear}, "
f"DMencore_play={self.DMencore_play}, "
f"DMencore_clear={self.DMencore_clear}, "
f"DMpencore_play={self.DMpencore_play}, "
f"DMpencore_clear={self.DMpencore_clear}, "
f"DMmax_clear_diff={self.DMmax_clear_diff}, "
f"DMmax_full_diff={self.DMmax_full_diff}, "
f"DMmax_exce_diff={self.DMmax_exce_diff}, "
f"DMclear_num={self.DMclear_num}, "
f"DMfull_num={self.DMfull_num}, "
f"DMexce_num={self.DMexce_num}, "
f"DMno_num={self.DMno_num}, "
f"DMe_num={self.DMe_num}, "
f"DMd_num={self.DMd_num}, "
f"DMc_num={self.DMc_num}, "
f"DMb_num={self.DMb_num}, "
f"DMa_num={self.DMa_num}, "
f"DMs_num={self.DMs_num}, "
f"DMss_num={self.DMss_num}, "
# Guitar Freaks fields
f"GFcabid={self.GFcabid}, "
f"GFplay={self.GFplay}, "
f"GFplaytime={self.GFplaytime}, "
f"GFplayterm={self.GFplayterm}, "
f"GFsession_cnt={self.GFsession_cnt}, "
f"GFmatching_num={self.GFmatching_num}, "
f"GFextra_stage={self.GFextra_stage}, "
f"GFextra_play={self.GFextra_play}, "
f"GFextra_clear={self.GFextra_clear}, "
f"GFencore_play={self.GFencore_play}, "
f"GFencore_clear={self.GFencore_clear}, "
f"GFpencore_play={self.GFpencore_play}, "
f"GFpencore_clear={self.GFpencore_clear}, "
f"GFmax_clear_diff={self.GFmax_clear_diff}, "
f"GFmax_full_diff={self.GFmax_full_diff}, "
f"GFmax_exce_diff={self.GFmax_exce_diff}, "
f"GFclear_num={self.GFclear_num}, "
f"GFfull_num={self.GFfull_num}, "
f"GFexce_num={self.GFexce_num}, "
f"GFno_num={self.GFno_num}, "
f"GFe_num={self.GFe_num}, "
f"GFd_num={self.GFd_num}, "
f"GFc_num={self.GFc_num}, "
f"GFb_num={self.GFb_num}, "
f"GFa_num={self.GFa_num}, "
f"GFs_num={self.GFs_num}, "
f"GFss_num={self.GFss_num})"
)
# Define DMGF Playlog here please
class DMGFPlaylog(Base):
__tablename__ = "gitadoraPlaylog"
id = Column(Integer, primary_key=True)
refid = Column(String(16))
token = Column(String())
game = Column(String(2)) # "DM" or "GF"
# Stage data
date_ms = Column(String())
stage_no = Column(Integer)
musicid = Column(Integer)
seq = Column(Integer)
skill = Column(Integer)
new_skill = Column(Integer)
clear = Column(Integer)
auto_clear = Column(Integer)
fullcombo = Column(Integer)
excellent = Column(Integer)
medal = Column(Integer)
perc = Column(Integer)
new_perc = Column(Integer)
rank = Column(Integer)
score = Column(Integer)
combo = Column(Integer)
max_combo_perc = Column(Integer)
flags = Column(Integer)
phrase_combo_perc = Column(Integer)
# Note counts
perfect = Column(Integer)
great = Column(Integer)
good = Column(Integer)
ok = Column(Integer)
miss = Column(Integer)
# Note percentages
perfect_perc = Column(Integer)
great_perc = Column(Integer)
good_perc = Column(Integer)
ok_perc = Column(Integer)
miss_perc = Column(Integer)
# Meter data
meter = Column(String())
meter_prog = Column(Integer)
before_meter = Column(String())
before_meter_prog = Column(Integer)
is_new_meter = Column(Integer)
# Phrase data
phrase_data_num = Column(Integer)
phrase_addr = Column(String()) # Store as JSON string
phrase_type = Column(String()) # Store as JSON string
phrase_status = Column(String()) # Store as JSON string
phrase_end_addr = Column(Integer)
def __repr__(self):
return (
f"DMGFPlaylog("
f"id={self.id}, "
f"refid='{self.refid}', "
f"token='{self.token}', "
f"game='{self.game}', "
f"date_ms={self.date_ms}, "
f"stage_no={self.stage_no}, "
f"musicid={self.musicid}, "
f"seq={self.seq}, "
f"skill={self.skill}, "
f"new_skill={self.new_skill}, "
f"clear={self.clear}, "
f"auto_clear={self.auto_clear}, "
f"fullcombo={self.fullcombo}, "
f"excellent={self.excellent}, "
f"medal={self.medal}, "
f"perc={self.perc}, "
f"new_perc={self.new_perc}, "
f"rank={self.rank}, "
f"score={self.score}, "
f"combo={self.combo}, "
f"max_combo_perc={self.max_combo_perc}, "
f"flags={self.flags}, "
f"phrase_combo_perc={self.phrase_combo_perc}, "
f"perfect={self.perfect}, "
f"great={self.great}, "
f"good={self.good}, "
f"ok={self.ok}, "
f"miss={self.miss}, "
f"perfect_perc={self.perfect_perc}, "
f"great_perc={self.great_perc}, "
f"good_perc={self.good_perc}, "
f"ok_perc={self.ok_perc}, "
f"miss_perc={self.miss_perc}, "
f"meter={self.meter}, "
f"meter_prog={self.meter_prog}, "
f"before_meter={self.before_meter}, "
f"before_meter_prog={self.before_meter_prog}, "
f"is_new_meter={self.is_new_meter}, "
f"phrase_data_num={self.phrase_data_num}, "
f"phrase_addr='{self.phrase_addr}', "
f"phrase_type='{self.phrase_type}', "
f"phrase_status='{self.phrase_status}', "
f"phrase_end_addr={self.phrase_end_addr})"
)
class nosProfile(Base):
__tablename__ = "nostalgiaProfile"
musicListFlgDefault = (
"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0"
)
id = Column(Integer, Sequence("user_id_seq"), primary_key=True)
token = Column(String(), unique=True)
refid = Column(String(16), unique=True)
name = Column(String(8), default="")
playCount = Column(Integer, default=0)
todayPlayCount = Column(Integer, default=0)
oldPlayCount = Column(Integer, default=0)
oldTodayPlayCount = Column(Integer, default=0)
oldRecitalCount = Column(Integer, default=0)
musicListFlg0 = Column(String(), default=musicListFlgDefault)
musicListFlg1 = Column(String(), default=musicListFlgDefault)
musicListFlg2 = Column(String(), default=musicListFlgDefault)
musicListFlg3 = Column(String(), default=musicListFlgDefault)
permittedlist0 = Column(String(), default=musicListFlgDefault)
permittedlist1 = Column(String(), default=musicListFlgDefault)
permittedlist2 = Column(String(), default=musicListFlgDefault)
permittedlist3 = Column(String(), default=musicListFlgDefault)
musicIndex = Column(Integer, default=0)
sheetType = Column(Integer, default=0)
playTime = Column(Integer, default=0)
musicGroup = Column(Integer, default=0)
bingoIndex = Column(Integer, default=0)
performType = Column(Integer, default=0)
filterFlag = Column(Integer, default=0)
def __repr__(self):
return (
f"nosProfile(id={self.id}, token='{self.token}', "
f"refid='{self.refid}', name='{self.name}', "
f"playCount={self.playCount}, todayPlayCount={self.todayPlayCount}, "
f"oldPlayCount={self.oldPlayCount}, oldTodayPlayCount={self.oldTodayPlayCount}, oldRecitalCount={self.oldRecitalCount}, "
f"musicListFlg0='{self.musicListFlg0}', musicListFlg1='{self.musicListFlg1}', "
f"musicListFlg2='{self.musicListFlg2}', musicListFlg3='{self.musicListFlg3}', "
f"musicIndex={self.musicIndex}, musicGroup={self.musicGroup}, sheetType={self.sheetType}, "
f"playTime={self.playTime}, bingoIndex={self.bingoIndex}, "
f"performType={self.performType}, filterFlag={self.filterFlag})"
)
class nosPlaylog(Base):
__tablename__ = "nostalgiaPlaylog"
id = Column(Integer, Sequence("user_id_seq"), primary_key=True)
token = Column(String(16), unique=True)
refid = Column(String(16), unique=True)
musicIndex = Column(Integer, default=0)
sheetType = Column(Integer, default=0)
score = Column(Integer, default=0)
playCount = Column(Integer, default=0)
clearCount = Column(Integer, default=0)
clearFlag = Column(Integer, default=0)
multiCount = Column(Integer, default=0)
handsMode = Column(Integer, default=0)
grade = Column(Integer, default=0)
recScore = Column(Integer, default=0)
recPlayCount = Column(Integer, default=0)
recHands = Column(Integer, default=0)
recGrade = Column(Integer, default=0)
def __repr__(self):
return (
f"nosPlaylog(id={self.id}, "
f"token='{self.token}', "
f"refid='{self.refid}', "
f"musicIndex={self.musicIndex}, "
f"sheetType={self.sheetType}, "
f"score={self.score}, "
f"playCount={self.playCount}, "
f"clearCount={self.clearCount}, "
f"clearFlag={self.clearFlag}, "
f"multiCount={self.multiCount}, "
f"handsMode={self.handsMode}, "
f"grade={self.grade}, "
f"recScore={self.recScore}, "
f"recPlayCount={self.recPlayCount}, "
f"recHands={self.recHands}, "
f"recGrade={self.recGrade})"
)
class ddrGPProfile(Base):
__tablename__ = "GrandPrixProfile"
id = Column(Integer, Sequence("user_id_seq"), primary_key=True)
token = Column(String(), unique=True)
refid = Column(String(16), unique=True)
common = Column(
String(),
default="MSwwLDM3MjkwMGQsMCwwLDAsMCwwLGZmZmZmZmZmZmZmZmZmZmYsMCwwLDAsMCwwLDAs",
)
option = Column(
String(),
default="MCwzLDAsMCwwLDAsMCwzLDAsMCwwLDAsMSwyLDAsMCwwLDEwLjAwMDAwMCwxMC4wMDAwMDAsMTAuMDAwMDAwLDEwLjAwMDAwMCwwLjAwMDAwMCwwLjAwMDAwMCwwLjAwMDAwMCwsLCwsLCwsLCwsLCw=",
)
last = Column(
String(),
default="MSwwLDAsMCwwLDAsMCwwLDAsMCwwLDAsMCwwLDAsMCwwLDAuMDAwMDAwLDAuMDAwMDAwLDAuMDAwMDAwLDAuMDAwMDAwLDAuMDAwMDAwLDAuMDAwMDAwLDAuMDAwMDAwLDAuMDAwMDAwLCwsLCwsLCwsLCwsLA==",
)
rival = Column(
String(),
default="MCwwLDAsMCwwLDAsMCwwLDAsMCwwLDAsMCwwLDAsMCwwLDAuMDAwMDAwLDAuMDAwMDAwLDAuMDAwMDAwLDAuMDAwMDAwLDAuMDAwMDAwLDAuMDAwMDAwLDAuMDAwMDAwLDAuMDAwMDAwLCwsLCwsLCwsLCwsLA==",
)
def __repr__(self):
return (
f"ddrGPProfile(id={self.id}, "
f"token='{self.token}', "
f"refid='{self.refid}', "
f"common={self.common}, "
f"option={self.option}, "
f"rival={self.rival})"
)
class DDRGPPlaylog(Base):
__tablename__ = "GrandPrixPlaylog"
id = Column(Integer, primary_key=True)
refid = Column(String(16))
# Stage data
stage_no = Column(Integer)
musicid = Column(Integer)
notetype = Column(Integer)
rank = Column(Integer)
clearkind = Column(Integer)
score = Column(Integer)
exscore = Column(Integer)
maxcombo = Column(Integer)
life = Column(Integer)
fastcount = Column(Integer)
slowcount = Column(Integer)
# Judge counts
judge_marvelous = Column(Integer)
judge_perfect = Column(Integer)
judge_great = Column(Integer)
judge_good = Column(Integer)
judge_boo = Column(Integer)
judge_miss = Column(Integer)
judge_ok = Column(Integer)
judge_ng = Column(Integer)
# Additional data
calorie = Column(Integer)
ghostsize = Column(Integer)
ghost = Column(String())
timestamp = Column(String())
playstyle = Column(Integer)
def __repr__(self):
return (
f"DDRGPPlaylog("
f"id={self.id}, "
f"refid='{self.refid}', "
f"stage_no={self.stage_no}, "
f"musicid={self.musicid}, "
f"notetype={self.notetype}, "
f"rank={self.rank}, "
f"clearkind={self.clearkind}, "
f"score={self.score}, "
f"exscore={self.exscore}, "
f"maxcombo={self.maxcombo}, "
f"life={self.life}, "
f"fastcount={self.fastcount}, "
f"slowcount={self.slowcount}, "
f"judge_marvelous={self.judge_marvelous}, "
f"judge_perfect={self.judge_perfect}, "
f"judge_great={self.judge_great}, "
f"judge_good={self.judge_good}, "
f"judge_boo={self.judge_boo}, "
f"judge_miss={self.judge_miss}, "
f"judge_ok={self.judge_ok}, "
f"judge_ng={self.judge_ng}, "
f"calorie={self.calorie}, "
f"ghostsize={self.ghostsize}, "
f"ghost='{self.ghost}', "
f"playstyle={self.playstyle})"
)
class gameHashs(Base):
__tablename__ = "gameHashs"
id = Column(Integer, Sequence("user_id_seq"), primary_key=True)
game = Column(String(), unique=True)
known_hash = Column(String(), unique=True)
known_resource_hash = Column(String(), unique=True)
known_resource_url = Column(String(), unique=True)
latest_hash = Column(String(), unique=True)
latest_resource_hash = Column(String(), unique=True)
latest_resource_url = Column(String(), unique=True)
def __repr__(self):
return (
f"gameHashs(id={self.id}, game='{self.game}',",
f"knownHash='{self.known_hash}',"
f"knownResourceHash='{self.known_resource_hash}',"
f"knownResourceURL='{self.known_resource_url}',"
f"LatestHash='{self.latest_hash}',"
f"LatesResourceHash='{self.latest_resource_hash}',"
f"LatesResourceURL='{self.latest_resource_url}')",
)
# Function to create a database engine
def create_engine_and_session(db_type="sqlite", db_name="server.db"):
if db_type == "sqlite":
# SQLite connection
engine = create_engine(
f"sqlite:///{db_name}", connect_args={"check_same_thread": False}
)
elif db_type == "mysql":
# MySQL connection (update with your own credentials)
username = "your_username"
password = "your_password"
host = "localhost"
engine = create_engine(
f"mysql+mysqlconnector://{username}:{password}@{host}/{db_name}"
)
else:
raise ValueError("Unsupported database type. Use 'sqlite' or 'mysql'.")
# Create all tables
Base.metadata.create_all(engine)
# Create a configured "Session" class
Session = sessionmaker(bind=engine)
return Session()
def obtainGameHashs(game):
session = create_engine_and_session(db_type)
try:
# Query the database for the token and get the first result
user = (
session.query(gameHashs).filter_by(game=game).first()
) # Use filter_by to find the token
return user # This will return the user object or None if not found
except Exception as e:
print(f"Failed to fetch token: {e}")
return None
finally:
session.close() # Close the session after use
# /user functions/
def add_user(
infinitasID,
name,
version,
prefID,
playSP,
playDP,
achieveSP,
achieveDP,
danSP,
danDP,
):
try:
session = create_engine_and_session(db_type)
new_user = infProfile(
infinitasID=infinitasID,
name=name,
version=version,
prefID=prefID,
playSP=playSP,
playDP=playDP,
achieveSP=achieveSP,
achieveDP=achieveDP,
danSP=danSP,
danDP=danDP,
)
session.add(new_user)
session.commit()
print(f"Added new user: {new_user}")
return True
except Exception as e:
print(f"Failed to Add User: {e}")
return False
finally:
session.close() # Close the session after use
def add_user_eacnet(token):
try:
session = create_engine_and_session(db_type)
new_user = eacNetProfile(
token=token,
refid=int(
str(random.randint(10**233, 10**400))[:16].replace(
"0", str(random.randint(1, 9))
)
),
snsid=int(
str(random.randint(10**233, 10**400))[:8].replace(
"0", str(random.randint(1, 9))
)
),
ddrTicket=0,
livelyTicket=0,
)
session.add(new_user)
session.commit()
print(f"Added new user: {new_user}")
return new_user
except Exception as e:
print(f"Failed to Add User: {e}")
return False
finally:
session.close() # Close the session after use
def add_user_nostalgia(name, refid, token):
try:
session = create_engine_and_session(db_type)
new_user = nosProfile(
name=name,
refid=refid,
token=token,
playCount=0,
todayPlayCount=0,
oldPlayCount=0,
oldTodayPlayCount=0,
oldRecitalCount=0,
musicListFlg0=nosProfile.musicListFlgDefault,
musicListFlg1=nosProfile.musicListFlgDefault,
musicListFlg2=nosProfile.musicListFlgDefault,
musicListFlg3=nosProfile.musicListFlgDefault,
permittedlist0=nosProfile.musicListFlgDefault,
permittedlist1=nosProfile.musicListFlgDefault,
permittedlist2=nosProfile.musicListFlgDefault,
permittedlist3=nosProfile.musicListFlgDefault,
musicIndex=0,
sheetType=0,
playTime=0,
bingoIndex=0,
performType=0,
filterFlag=0,
)
session.add(new_user)
session.commit()
print(f"Added new user: {new_user}")
return new_user
except Exception as e:
print(f"Failed to add user: {e}")
return False
finally:
session.close() # Close the session after use
def add_user_DMGF(refid, token, did, usercode):
try:
session = create_engine_and_session(db_type)
new_user = DMGFProfile(
refid=refid,
token=token,
did=did,
usercode=usercode,
DMskill=0,
DMallSkill=0,
DMoldSkill=-1,
DMoldAllSkill=-1,
GFskill=0,
GFallSkill=0,
GFoldSkill=-1,
GFoldAllSkill=-1,
)
session.add(new_user)
session.commit()
print(f"Added new user: {new_user}")
return new_user
except Exception as e:
print(f"Failed to add user: {e}")
return False
finally:
session.close() # Close the session after use
def manage_user_GP(refid, token, COMMON, OPTION, LAST, RIVAL, save):
try:
session = create_engine_and_session(db_type)
user_profile = (
session.query(ddrGPProfile).filter_by(token=token).first()
or session.query(ddrGPProfile).filter_by(refid=refid).first()
)
if user_profile is None:
if (
COMMON is not None
and OPTION is not None
and LAST is not None
and RIVAL is not None
):
new_user = ddrGPProfile(
token=token,
refid=refid, # You need to add this as well since it's a required field.
common=COMMON,
option=OPTION,
last=LAST,
rival=RIVAL,
)
session.add(new_user)
session.commit()
print(f"Added new user: {new_user}")
return new_user
else:
return None
elif save == 0:
print(f"Returning Profile")
return user_profile
elif save == 1:
if COMMON is not None:
user_profile.common = COMMON
if OPTION is not None:
user_profile.option = OPTION
if LAST is not None:
user_profile.last = LAST
if RIVAL is not None:
user_profile.rival = RIVAL
session.commit()
print(f"Updated GP Profile.")
return user_profile
except Exception as e:
print(f"Failed to Add User: {e}")
return False
finally:
session.close() # Close the session after use
def manage_user_DMGF(refid, token, customData, favoritemusic, playinfo, game):
musicFavorites = "-1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1"
playStyleCustom = "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0"
try:
session = create_engine_and_session(db_type)
# Retrieve the user profile based on token or refid
user_profile = (
session.query(DMGFProfileExt).filter_by(token=token).first()
or session.query(DMGFProfileExt).filter_by(refid=refid).first()
)
if user_profile is None:
print("Creating new Profile")
new_user = DMGFProfileExt(
token=token,
refid=refid,
DMplaystyle=(
customData["playstyle"]["#text"]
if game == "DM"
else playStyleCustom
),
DMcustom=(
customData["custom"]["#text"] if game == "DM" else playStyleCustom
),
GFplaystyle=(
customData["playstyle"]["#text"]
if game == "GF"
else playStyleCustom
),
GFcustom=(
customData["custom"]["#text"] if game == "GF" else playStyleCustom
),
DMmusicFavorites1=(
re.sub(r'"', "", favoritemusic["music_list_1"]["#text"])
if game == "DM"
else musicFavorites
),
DMmusicFavorites2=(
re.sub(r'"', "", favoritemusic["music_list_2"]["#text"])
if game == "DM"
else musicFavorites
),
DMmusicFavorites3=(
re.sub(r'"', "", favoritemusic["music_list_3"]["#text"])
if game == "DM"
else musicFavorites
),
DMlastCategory=(
playinfo["last_category"]["#text"]
if game == "DM" and playinfo
else 0
),
DMlastMusic=(
playinfo["last_musicid"]["#text"]
if game == "DM" and playinfo
else -1
),
DMlastSeq=(
playinfo["last_seq"]["#text"] if game == "DM" and playinfo else 0
),
DMdisplayLevel=(
playinfo["disp_level"]["#text"] if game == "DM" and playinfo else 0
),
GFmusicFavorites1=(
re.sub(r'"', "", favoritemusic["music_list_1"]["#text"])
if game == "GF"
else musicFavorites
),
GFmusicFavorites2=(
re.sub(r'"', "", favoritemusic["music_list_2"]["#text"])
if game == "GF"
else musicFavorites
),
GFmusicFavorites3=(
re.sub(r'"', "", favoritemusic["music_list_3"]["#text"])
if game == "GF"
else musicFavorites
),
GFlastCategory=(
playinfo["last_category"]["#text"]
if game == "GF" and playinfo
else 0
),
GFlastMusic=(
playinfo["last_musicid"]["#text"]
if game == "GF" and playinfo
else -1
),
GFlastSeq=(
playinfo["last_seq"]["#text"] if game == "GF" and playinfo else 0
),
GFdisplayLevel=(
playinfo["disp_level"]["#text"] if game == "GF" and playinfo else 0
),
)
session.add(new_user)
session.commit()
print(f"Added new user: {new_user}")
return new_user
else:
print(game)
if game == "DM":
user_profile.DMplaystyle = customData["playstyle"]["#text"]
user_profile.DMcustom = customData["custom"]["#text"]
user_profile.DMmusicFavorites1 = re.sub(
r'"', "", favoritemusic["music_list_1"]["#text"]
)
user_profile.DMmusicFavorites2 = re.sub(
r'"', "", favoritemusic["music_list_2"]["#text"]
)
user_profile.DMmusicFavorites3 = re.sub(
r'"', "", favoritemusic["music_list_3"]["#text"]
)
user_profile.DMlastCategory = playinfo["last_category"]["#text"]
user_profile.DMlastMusic = playinfo["last_musicid"]["#text"]
user_profile.DMlastSeq = playinfo["last_seq"]["#text"]
user_profile.DMdisplayLevel = playinfo["disp_level"]["#text"]
elif game == "GF":
print(user_profile.GFplaystyle)
print(customData["playstyle"]["#text"])
user_profile.GFplaystyle = customData["playstyle"]["#text"]
user_profile.GFcustom = customData["custom"]["#text"]
user_profile.GFmusicFavorites1 = re.sub(
r'"', "", favoritemusic["music_list_1"]["#text"]
)
user_profile.GFmusicFavorites2 = re.sub(
r'"', "", favoritemusic["music_list_2"]["#text"]
)
user_profile.GFmusicFavorites3 = re.sub(
r'"', "", favoritemusic["music_list_3"]["#text"]
)
user_profile.GFlastCategory = playinfo["last_category"]["#text"]
user_profile.GFlastMusic = playinfo["last_musicid"]["#text"]
user_profile.GFlastSeq = playinfo["last_seq"]["#text"]
user_profile.GFdisplayLevel = playinfo["disp_level"]["#text"]
session.commit()
print(f"Updated {game} Profile.")
return user_profile
except Exception as e:
print(f"Failed to Manage User Profile: {e}")
return False
finally:
session.close() # Close the session after use
def manage_user_DMGF_Details(refid, token, playinfo, game):
try:
session = create_engine_and_session(db_type)
# Retrieve the user profile based on token or refid
user_profile = (
session.query(DMGFProfileDetails).filter_by(token=token).first()
or session.query(DMGFProfileDetails).filter_by(refid=refid).first()
)
print(user_profile)
if user_profile is None:
print("Creating new Profile Details")
new_user = DMGFProfileDetails(
token=token,
refid=refid,
# Set the appropriate fields based on game type
DMcabid=playinfo["cabid"]["#text"] if game == "DM" else 0,
DMplay=playinfo["play"]["#text"] if game == "DM" else 0,
DMplaytime=playinfo["playtime"]["#text"] if game == "DM" else 0,
DMplayterm=playinfo["playterm"]["#text"] if game == "DM" else 0,
DMsession_cnt=playinfo["session_cnt"]["#text"] if game == "DM" else 0,
DMmatching_num=playinfo["matching_num"]["#text"] if game == "DM" else 0,
DMextra_stage=playinfo["extra_stage"]["#text"] if game == "DM" else 0,
DMextra_play=playinfo["extra_play"]["#text"] if game == "DM" else 0,
DMextra_clear=playinfo["extra_clear"]["#text"] if game == "DM" else 0,
DMencore_play=playinfo["encore_play"]["#text"] if game == "DM" else 0,
DMencore_clear=playinfo["encore_clear"]["#text"] if game == "DM" else 0,
DMpencore_play=playinfo["pencore_play"]["#text"] if game == "DM" else 0,
DMpencore_clear=(
playinfo["pencore_clear"]["#text"] if game == "DM" else 0
),
DMmax_clear_diff=(
playinfo["max_clear_diff"]["#text"] if game == "DM" else 0
),
DMmax_full_diff=(
playinfo["max_full_diff"]["#text"] if game == "DM" else 0
),
DMmax_exce_diff=(
playinfo["max_exce_diff"]["#text"] if game == "DM" else 0
),
DMclear_num=playinfo["clear_num"]["#text"] if game == "DM" else 0,
DMfull_num=playinfo["full_num"]["#text"] if game == "DM" else 0,
DMexce_num=playinfo["exce_num"]["#text"] if game == "DM" else 0,
DMno_num=playinfo["no_num"]["#text"] if game == "DM" else 0,
DMe_num=playinfo["e_num"]["#text"] if game == "DM" else 0,
DMd_num=playinfo["d_num"]["#text"] if game == "DM" else 0,
DMc_num=playinfo["c_num"]["#text"] if game == "DM" else 0,
DMb_num=playinfo["b_num"]["#text"] if game == "DM" else 0,
DMa_num=playinfo["a_num"]["#text"] if game == "DM" else 0,
DMs_num=playinfo["s_num"]["#text"] if game == "DM" else 0,
DMss_num=playinfo["ss_num"]["#text"] if game == "DM" else 0,
# Guitar Freaks fields
GFcabid=playinfo["cabid"]["#text"] if game == "GF" else 0,
GFplay=playinfo["play"]["#text"] if game == "GF" else 0,
GFplaytime=playinfo["playtime"]["#text"] if game == "GF" else 0,
GFplayterm=playinfo["playterm"]["#text"] if game == "GF" else 0,
GFsession_cnt=playinfo["session_cnt"]["#text"] if game == "GF" else 0,
GFmatching_num=playinfo["matching_num"]["#text"] if game == "GF" else 0,
GFextra_stage=playinfo["extra_stage"]["#text"] if game == "GF" else 0,
GFextra_play=playinfo["extra_play"]["#text"] if game == "GF" else 0,
GFextra_clear=playinfo["extra_clear"]["#text"] if game == "GF" else 0,
GFencore_play=playinfo["encore_play"]["#text"] if game == "GF" else 0,
GFencore_clear=playinfo["encore_clear"]["#text"] if game == "GF" else 0,
GFpencore_play=playinfo["pencore_play"]["#text"] if game == "GF" else 0,
GFpencore_clear=(
playinfo["pencore_clear"]["#text"] if game == "GF" else 0
),
GFmax_clear_diff=(
playinfo["max_clear_diff"]["#text"] if game == "GF" else 0
),
GFmax_full_diff=(
playinfo["max_full_diff"]["#text"] if game == "GF" else 0
),
GFmax_exce_diff=(
playinfo["max_exce_diff"]["#text"] if game == "GF" else 0
),
GFclear_num=playinfo["clear_num"]["#text"] if game == "GF" else 0,
GFfull_num=playinfo["full_num"]["#text"] if game == "GF" else 0,
GFexce_num=playinfo["exce_num"]["#text"] if game == "GF" else 0,
GFno_num=playinfo["no_num"]["#text"] if game == "GF" else 0,
GFe_num=playinfo["e_num"]["#text"] if game == "GF" else 0,
GFd_num=playinfo["d_num"]["#text"] if game == "GF" else 0,
GFc_num=playinfo["c_num"]["#text"] if game == "GF" else 0,
GFb_num=playinfo["b_num"]["#text"] if game == "GF" else 0,
GFa_num=playinfo["a_num"]["#text"] if game == "GF" else 0,
GFs_num=playinfo["s_num"]["#text"] if game == "GF" else 0,
GFss_num=playinfo["ss_num"]["#text"] if game == "GF" else 0,
)
session.add(new_user)
session.commit()
print(f"Added new user details: {new_user}")
return new_user
else:
# Update existing profile based on game type
if game == "DM":
user_profile.DMcabid = playinfo["cabid"]["#text"]
user_profile.DMplay = playinfo["play"]["#text"]
user_profile.DMplaytime = playinfo["playtime"]["#text"]
user_profile.DMplayterm = playinfo["playterm"]["#text"]
user_profile.DMsession_cnt = playinfo["session_cnt"]["#text"]
user_profile.DMmatching_num = playinfo["matching_num"]["#text"]
user_profile.DMextra_stage = playinfo["extra_stage"]["#text"]
user_profile.DMextra_play = playinfo["extra_play"]["#text"]
user_profile.DMextra_clear = playinfo["extra_clear"]["#text"]
user_profile.DMencore_play = playinfo["encore_play"]["#text"]
user_profile.DMencore_clear = playinfo["encore_clear"]["#text"]
user_profile.DMpencore_play = playinfo["pencore_play"]["#text"]
user_profile.DMpencore_clear = playinfo["pencore_clear"]["#text"]
user_profile.DMmax_clear_diff = playinfo["max_clear_diff"]["#text"]
user_profile.DMmax_full_diff = playinfo["max_full_diff"]["#text"]
user_profile.DMmax_exce_diff = playinfo["max_exce_diff"]["#text"]
user_profile.DMclear_num = playinfo["clear_num"]["#text"]
user_profile.DMfull_num = playinfo["full_num"]["#text"]
user_profile.DMexce_num = playinfo["exce_num"]["#text"]
user_profile.DMno_num = playinfo["no_num"]["#text"]
user_profile.DMe_num = playinfo["e_num"]["#text"]
user_profile.DMd_num = playinfo["d_num"]["#text"]
user_profile.DMc_num = playinfo["c_num"]["#text"]
user_profile.DMb_num = playinfo["b_num"]["#text"]
user_profile.DMa_num = playinfo["a_num"]["#text"]
user_profile.DMs_num = playinfo["s_num"]["#text"]
user_profile.DMss_num = playinfo["ss_num"]["#text"]
elif game == "GF":
user_profile.GFcabid = playinfo["cabid"]["#text"]
user_profile.GFplay = playinfo["play"]["#text"]
user_profile.GFplaytime = playinfo["playtime"]["#text"]
user_profile.GFplayterm = playinfo["playterm"]["#text"]
user_profile.GFsession_cnt = playinfo["session_cnt"]["#text"]
user_profile.GFmatching_num = playinfo["matching_num"]["#text"]
user_profile.GFextra_stage = playinfo["extra_stage"]["#text"]
user_profile.GFextra_play = playinfo["extra_play"]["#text"]
user_profile.GFextra_clear = playinfo["extra_clear"]["#text"]
user_profile.GFencore_play = playinfo["encore_play"]["#text"]
user_profile.GFencore_clear = playinfo["encore_clear"]["#text"]
user_profile.GFpencore_play = playinfo["pencore_play"]["#text"]
user_profile.GFpencore_clear = playinfo["pencore_clear"]["#text"]
user_profile.GFmax_clear_diff = playinfo["max_clear_diff"]["#text"]
user_profile.GFmax_full_diff = playinfo["max_full_diff"]["#text"]
user_profile.GFmax_exce_diff = playinfo["max_exce_diff"]["#text"]
user_profile.GFclear_num = playinfo["clear_num"]["#text"]
user_profile.GFfull_num = playinfo["full_num"]["#text"]
user_profile.GFexce_num = playinfo["exce_num"]["#text"]
user_profile.GFno_num = playinfo["no_num"]["#text"]
user_profile.GFe_num = playinfo["e_num"]["#text"]
user_profile.GFd_num = playinfo["d_num"]["#text"]
user_profile.GFc_num = playinfo["c_num"]["#text"]
user_profile.GFb_num = playinfo["b_num"]["#text"]
user_profile.GFa_num = playinfo["a_num"]["#text"]
user_profile.GFs_num = playinfo["s_num"]["#text"]
user_profile.GFss_num = playinfo["ss_num"]["#text"]
session.commit()
print(f"Updated {game} Profile Details.")
return user_profile
except Exception as e:
print(f"Failed to Manage User Profile Details: {e}")
return False
finally:
session.close() # Close the session after use
def add_token(infinitasID, token):
try:
session = create_engine_and_session(db_type)
# Use raw SQL for the insert with ON CONFLICT DO NOTHING
insert_query = text(
"""
INSERT INTO infinitasToken (infinitasID, token)
VALUES (:infinitasID, :token)
ON CONFLICT (infinitasID) DO NOTHING
"""
)
session.execute(insert_query, {"infinitasID": infinitasID, "token": token})
session.commit()
print(f"Associated Token with {infinitasID}")
return True
except Exception as e:
print(f"Failed to Add User: {e}")
return False
finally:
session.close() # Close the session after use
def fetch_users():
session = create_engine_and_session(db_type)
try:
# Query the database
for user in session.query(infProfile).order_by(infProfile.id):
print(user)
except Exception as e:
print(f"Failed to fetch users: {e}")
finally:
session.close() # Close the session after use
def update_save_data(infinitasID, new_save_data, new_save_length, new_save_check):
try:
kbinxml_data = KBinXML(bytes.fromhex(new_save_data)).to_text()
profileData = xmltodict.parse(kbinxml_data) # Ensure to parse the XML correctly
session = create_engine_and_session(db_type)
# Fetch the existing record
user_profile = (
session.query(infProfile).filter_by(infinitasID=infinitasID).first()
)
if user_profile is None:
print(f"No user found with infinitasID: {infinitasID}")
return False
# Backup the existing saveData and saveLength
user_profile.saveDataBackup = user_profile.saveData
user_profile.saveLengthBackup = user_profile.saveLength
user_profile.saveCheckBackup = user_profile.saveCheck
session.commit()
if user_profile.saveLength is None:
user_profile.saveData = bytes.fromhex(new_save_data)
user_profile.saveLength = new_save_length
user_profile.saveCheck = new_save_check
print(f"Created save data for user: {infinitasID}")
else:
# Update with new values
user_profile.saveData = bytes.fromhex(new_save_data)
user_profile.saveLength = new_save_length
user_profile.saveCheck = new_save_check
print(f"Updated save data for user: {infinitasID}")
user_profile.playSP = int(
profileData["pdata"]["player"]["play_num_sp"]["#text"]
)
user_profile.playDP = int(
profileData["pdata"]["player"]["play_num_dp"]["#text"]
)
user_profile.danSP = int(profileData["pdata"]["player"]["grade_id_sp"]["#text"])
user_profile.danDP = int(profileData["pdata"]["player"]["grade_id_dp"]["#text"])
# Commit the changes
session.commit()
return True
except Exception as e:
print(f"Failed to update save data: {e}")
return False
finally:
session.close() # Close the session after use
def update_save_data_bits(infinitasID, bits):
try:
session = create_engine_and_session(db_type)
# Fetch the existing record
user_profile = (
session.query(infProfile).filter_by(infinitasID=infinitasID).first()
)
if user_profile is None:
print(f"No user found with infinitasID: {infinitasID}")
return False
print(bits)
user_profile.bits = int(bits)
# Commit the changes
session.commit()
return True
except Exception as e:
print(f"Failed to update save data: {e}")
return False
finally:
session.close() # Close the session after use
def manage_ghost_data(
infinitasID,
name,
score,
danRank,
prefecture,
musicID,
noteID,
ghost,
ghostCheck,
ghostSize,
flip,
assist,
arrange1,
arrange0,
clear_flag,
):
try:
session = create_engine_and_session(
db_type
) # Assuming db_type is defined elsewhere
# Fetch existing ghost data based on infinitasID, musicID, and noteID
existing_ghost_data = (
session.query(infGhostData)
.filter_by(infinitasID=infinitasID, musicID=musicID, noteID=noteID)
.first()
)
if existing_ghost_data and existing_ghost_data.score > int(score):
# Update the existing ghost data
existing_ghost_data.name = name
existing_ghost_data.score = score
existing_ghost_data.danRank = danRank
existing_ghost_data.prefecture = prefecture
existing_ghost_data.ghost = ghost
existing_ghost_data.ghostCheck = ghostCheck
existing_ghost_data.ghostSize = ghostSize
existing_ghost_data.flip = flip
existing_ghost_data.assist = assist
existing_ghost_data.arrange1 = arrange1
existing_ghost_data.arrange0 = arrange0
existing_ghost_data.clear_flag = clear_flag
session.commit()
print(
f"Updated existing ghost data for infinitasID: {infinitasID}, musicID: {musicID}, noteID: {noteID}"
)
elif not existing_ghost_data:
# Create new ghost data if it doesn't exist
new_ghost_data = infGhostData(
infinitasID=infinitasID,
name=name,
score=score,
danRank=danRank,
prefecture=prefecture,
musicID=musicID,
noteID=noteID,
ghost=ghost,
ghostCheck=ghostCheck,
ghostSize=ghostSize,
flip=flip,
assist=assist,
arrange1=arrange1,
arrange0=arrange0,
clear_flag=clear_flag,
)
session.add(new_ghost_data)
session.commit()
print(
f"Added new ghost data for infinitasID: {infinitasID}, musicID: {musicID}, noteID: {noteID}"
)
return True
except Exception as e:
print(f"Failed to Add or Update Ghost Data: {e}")
return False
finally:
session.close() # Close the session after use
def manage_music_data(infinitasID, musicID, noteID, score, missCount, ClearFlag):
try:
session = create_engine_and_session(
db_type
) # Assuming db_type is defined elsewhere
scores = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1]
missCounts = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1]
ClearFlags = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1]
clearAmounts = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1]
playCounts = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1]
scores[int(noteID)] = int(score)
missCounts[int(noteID)] = int(missCount)
ClearFlags[int(noteID)] = int(ClearFlag)
playCounts[int(noteID)] = 1
# Fetch existing ghost data based on infinitasID, musicID, and noteID
print("checking for existing data")
existing_music_data = (
session.query(InfinitasPlayData)
.filter_by(infinitasID=infinitasID, musicID=musicID)
.first()
)
userInfinitasProfile = (
session.query(infProfile).filter_by(infinitasID=infinitasID).first()
)
userInfinitasProfile.totalPlays = userInfinitasProfile.totalPlays + 1
if ClearFlags[int(noteID)] > 1: # Change here
print("cleared")
clearAmounts[int(noteID)] = 1
userInfinitasProfile.totalClears = userInfinitasProfile.totalClears + 1
if existing_music_data:
print(existing_music_data)
# Update the existing ghost data
scrs = json.loads(existing_music_data.score)
print("checking for up score")
if scrs[int(noteID)] < int(score): # If the score is higher
scrs[int(noteID)] = int(score) # Correctly update the score
existing_music_data.score = json.dumps(scrs) # Save as JSON string
msCnt = json.loads(existing_music_data.missCount)
print("checking for miss drop")
if msCnt[int(noteID)] > int(missCount):
msCnt[int(noteID)] = int(missCount) # Update the miss count
existing_music_data.missCount = json.dumps(msCnt) # Save as JSON string
print("checking for clear flag")
if int(ClearFlag) > 1: # if clearflag doesn't mean a miss
clrFlg = json.loads(existing_music_data.clearFlag)
clrAmt = json.loads(existing_music_data.clearAmount)
plyCnt = json.loads(existing_music_data.playCount)
if clrFlg[int(noteID)] < int(ClearFlag):
clrFlg[int(noteID)] = int(ClearFlag)
existing_music_data.clearFlag = json.dumps(
clrFlg
) # Save as JSON string
clrAmt[int(noteID)] += 1 # Increment the clear amount
existing_music_data.clearAmount = json.dumps(
clrAmt
) # Save as JSON string
plyCnt[int(noteID)] += 1 # Increment the clear amount
existing_music_data.playCount = json.dumps(
plyCnt
) # Save as JSON string
print(
f"Updated existing Player Music Player Data for infinitasID: {infinitasID}, musicID: {musicID}, noteID: {noteID}"
)
else:
# Create new ghost data if it doesn't exist
newPlayData = InfinitasPlayData(
infinitasID=infinitasID,
musicID=musicID,
missCount=json.dumps(missCounts), # Save as JSON string
playCount=json.dumps(playCounts), # Save as JSON string
clearAmount=json.dumps(clearAmounts), # Save as JSON string
clearFlag=json.dumps(ClearFlags), # Save as JSON string
score=json.dumps(scores), # Save as JSON string
)
session.add(newPlayData)
print(
f"Added new Player Music Player Data for infinitasID: {infinitasID}, musicID: {musicID}, noteID: {noteID}"
)
session.commit()
return True
except Exception as e:
print(f"Failed to Add or Update Player Music Player Data: {e}")
return False
finally:
session.close() # Close the session after use
def update_save_data_consumables(infinitasID, type, amount):
try:
session = create_engine_and_session(db_type)
# Fetch the existing record
user_profile = (
session.query(infProfile).filter_by(infinitasID=infinitasID).first()
)
user_item = session.query(infItems).filter_by(infinitasID=infinitasID).first()
if user_item is None:
user_item = infItems(infinitasID=infinitasID)
session.add(user_item)
if user_profile is None:
print(f"No user found with infinitasID: {infinitasID}")
return False
elif type is None or amount is None or user_item is None:
print("/!\\ Missing Type and or Amount, or failed to find user_item row")
return False
elif type == 0:
if user_profile.bits < int(amount):
return False # User doesn't have enough bits to continue unlocking.
elif type == 1:
if user_item.TicketsPaid > 0:
user_item.TicketsPaid = user_item.TicketsPaid - 1
elif user_item.TicketsFree > 0:
user_item.TicketsFree = user_item.TicketsFree - 1
else:
return False # User doesn't have enough tickets, they need more to continue.
elif type == 2:
if user_item.lDiscs > 0:
user_item.lDiscs = user_item.lDiscs - 1
else:
return False # User doesn't have enough lDiscs, they need more to continue.
elif type == 3:
if user_item.TicketsPaid > 0:
user_item.TicketsPaid = user_item.TicketsPaid - 1
user_item.lDiscs = user_item.lDiscs + 5
elif user_item.TicketsFree > 0:
user_item.TicketsFree = user_item.TicketsFree - 1
user_item.lDiscs = user_item.lDiscs + 5
else:
return False # User doesn't have enough tickets, they need more to continue.
# Commit the changes
session.commit()
return True
except Exception as e:
print(f"Failed to update save data: {e}")
return False
finally:
session.close() # Close the session after use
def update_save_data_consumablesEAC(token, game, goods_id):
try:
session = create_engine_and_session(db_type)
# Fetch the existing record
user_profile = session.query(eacNetProfile).filter_by(token=token).first()
if user_profile is None:
print(f"No user found with token: {token}")
return False
elif game is None or goods_id is None:
print("/!\\ Missing Type and or Amount, or failed to find user_item row")
return False
elif game == "ddr":
match goods_id:
case "G0000001":
print(user_profile.ddrTicket)
print(user_profile.ddrTicket - 6)
print((user_profile.ddrTicket - 6) >= 0)
if (user_profile.ddrTicket - 6) >= 0:
user_profile.ddrTicket += -6
else:
return False
case _:
if (user_profile.ddrTicket - 5) >= 0:
user_profile.ddrTicket += -5
else:
return False
elif game == "popn-music":
match goods_id:
case "G0000001":
if (user_profile.livelyTicket - 6) >= 0:
user_profile.livelyTicket -= 6 # Deduct 6 tickets
else:
return False # Not enough tickets
case (
"G0000002"
| "G0000003"
| "G0000004"
| "G0000005"
| "G0000006"
| "G0000007"
| "G0000008"
| "G0000009"
| "G0000010"
| "G0000011"
):
if (user_profile.livelyTicket - 5) >= 0:
user_profile.livelyTicket -= 5 # Deduct 5 tickets
else:
return False # Not enough tickets
case (
"GS000004"
| "GS000005"
| "GS000006"
| "GS000007"
| "GS000008"
| "GS000009"
| "GS000010"
| "GS000011"
):
if (user_profile.livelyTicket - 2) >= 0:
user_profile.livelyTicket -= 2 # Deduct 2 tickets
else:
return False # Not enough tickets
case _:
return False # Invalid goods_id
# Commit the changes
session.commit()
return True
except Exception as e:
print(f"Failed to update save data: {e}")
return False
finally:
session.close() # Close the session after use
def update_unlock_status(infinitasID, musicID, kind, note_bit):
try:
session = create_engine_and_session(db_type)
# Fetch the existing record
user_profile = (
session.query(infUnlocks)
.filter_by(infinitasID=infinitasID, musicID=musicID)
.first()
)
if user_profile is None:
print(f"Unlocking SongID {musicID} for infinitasID: {infinitasID}")
new_song_unlocked = infUnlocks(
infinitasID=infinitasID, musicID=musicID, type=kind, note_bit=note_bit
)
session.add(new_song_unlocked)
else:
# Update with new values
user_profile.note_bit = int(note_bit) + int(user_profile.note_bit)
print(f"Updated musicID {musicID} unlock data for user: {infinitasID}")
# Commit the changes
session.commit()
return True
except Exception as e:
print(f"Failed to update musicID {musicID} unlock data: {e}")
return False
finally:
session.close() # Close the session after use
def nostalgia_update_musicList(
token, refid, musicListFlg0, musicListFlg1, musicListFlg2, musicListFlg3
):
try:
session = create_engine_and_session(db_type)
# Fetch the existing record
user_profile = (
session.query(nosProfile).filter_by(token=token).first()
or session.query(nosProfile).filter_by(refid=refid).first()
)
if user_profile is None:
return False
else:
# Update with new values
user_profile.musicListFlg0 = musicListFlg0
user_profile.musicListFlg1 = musicListFlg1
user_profile.musicListFlg2 = musicListFlg2
user_profile.musicListFlg3 = musicListFlg3
print(f"Updated musicList Flags.")
# Commit the changes
session.commit()
return True
except Exception as e:
print(f"Failed to update musicList Flags: {e}")
return False
finally:
session.close() # Close the session after use
def nostalgia_update_playlog(
token,
refid,
musicIndex,
sheetType,
score,
clearFlag,
multiCount,
handsMode,
grade,
playStyle,
):
try:
session = create_engine_and_session(db_type)
# Fetch the existing record
user_playlog = (
session.query(nosPlaylog).filter_by(token=token).first()
or session.query(nosPlaylog).filter_by(refid=refid).first()
)
if user_playlog is None:
print(f"Creating new playlog for token: {token}, refid: {refid}")
if playStyle == 1:
new_playlog = nosPlaylog(
token=token,
refid=refid,
musicIndex=musicIndex,
sheetType=sheetType,
clearFlag=clearFlag,
clearCount=clearFlag,
multiCount=multiCount,
recScore=score,
recPlayCount=1,
recHandsMode=handsMode,
recGrade=grade,
)
else:
new_playlog = nosPlaylog(
token=token,
refid=refid,
musicIndex=musicIndex,
sheetType=sheetType,
clearFlag=clearFlag,
clearCount=clearFlag,
multiCount=multiCount,
score=score,
playCount=1,
handsMode=handsMode,
grade=grade,
)
session.add(new_playlog)
else:
# Update with new values
user_playlog.musicIndex = musicIndex
user_playlog.sheetType = sheetType
user_playlog.clearCount += clearFlag
user_playlog.multiCount = multiCount
if user_playlog.clearFlag < clearFlag:
user_playlog.clearFlag = clearFlag
if playStyle == 1:
user_playlog.recScore = score
user_playlog.recPlayCount += user_playlog.recPlayCount
user_playlog.recHandsMode = handsMode
user_playlog.recGrade = grade
else:
user_playlog.score = score
user_playlog.playCount += user_playlog.playCount
user_playlog.handsMode = handsMode
user_playlog.grade = grade
# Optionally, handle playStyle if needed in the model
print(f"Updated playlog for token: {token}, refid: {refid}")
# Commit the changes
session.commit()
return True
except Exception as e:
print(f"Failed to update playlog for token: {token}, refid: {refid}: {e}")
return False
finally:
session.close() # Close the session after use
# DMGF Playlog here please
def update_DMGF_playlog(refid, token, stage_data, game):
try:
session = create_engine_and_session(db_type)
new_playlog = DMGFPlaylog(
refid=refid,
token=token,
game=game,
date_ms=stage_data["date_ms"]["#text"],
stage_no=stage_data["stage_no"]["#text"],
musicid=stage_data["musicid"]["#text"],
seq=stage_data["seq"]["#text"],
skill=stage_data["skill"]["#text"],
new_skill=stage_data["new_skill"]["#text"],
clear=stage_data["clear"]["#text"],
auto_clear=stage_data["auto_clear"]["#text"],
fullcombo=stage_data["fullcombo"]["#text"],
excellent=stage_data["excellent"]["#text"],
medal=stage_data["medal"]["#text"],
perc=stage_data["perc"]["#text"],
new_perc=stage_data["new_perc"]["#text"],
rank=stage_data["rank"]["#text"],
score=stage_data["score"]["#text"],
combo=stage_data["combo"]["#text"],
max_combo_perc=stage_data["max_combo_perc"]["#text"],
flags=stage_data["flags"]["#text"],
phrase_combo_perc=stage_data["phrase_combo_perc"]["#text"],
perfect=stage_data["perfect"]["#text"],
great=stage_data["great"]["#text"],
good=stage_data["good"]["#text"],
ok=stage_data["ok"]["#text"],
miss=stage_data["miss"]["#text"],
perfect_perc=stage_data["perfect_perc"]["#text"],
great_perc=stage_data["great_perc"]["#text"],
good_perc=stage_data["good_perc"]["#text"],
ok_perc=stage_data["ok_perc"]["#text"],
miss_perc=stage_data["miss_perc"]["#text"],
meter=stage_data["meter"]["#text"],
meter_prog=stage_data["meter_prog"]["#text"],
before_meter=stage_data["before_meter"]["#text"],
before_meter_prog=stage_data["before_meter_prog"]["#text"],
is_new_meter=stage_data["is_new_meter"]["#text"],
phrase_data_num=stage_data["phrase_data_num"]["#text"],
phrase_addr=stage_data["phrase_addr"]["#text"],
phrase_type=stage_data["phrase_type"]["#text"],
phrase_status=stage_data["phrase_status"]["#text"],
phrase_end_addr=stage_data["phrase_end_addr"]["#text"],
)
session.add(new_playlog)
session.commit()
return True
except Exception as e:
print(f"Failed to update playlog: {e}")
return False
finally:
session.close()
def ddrgp_insert_playlog(
refid,
stage_no,
musicid,
notetype,
rank,
clearkind,
score,
exscore,
maxcombo,
life,
fastcount,
slowcount,
judge_marvelous,
judge_perfect,
judge_great,
judge_good,
judge_boo,
judge_miss,
judge_ok,
judge_ng,
calorie,
ghostsize,
ghost,
timestamp,
playstyle,
):
try:
session = create_engine_and_session(db_type)
# Check if a playlog entry with the given timestamp already exists for the user
existing_playlog = (
session.query(DDRGPPlaylog)
.filter_by(refid=refid, timestamp=timestamp)
.first()
)
if existing_playlog is None:
print(f"Creating new playlog for refid: {refid}, timestamp: {timestamp}")
new_playlog = DDRGPPlaylog(
refid=refid,
stage_no=stage_no,
musicid=musicid,
notetype=notetype,
rank=rank,
clearkind=clearkind,
score=score,
exscore=exscore,
maxcombo=maxcombo,
life=life,
fastcount=fastcount,
slowcount=slowcount,
judge_marvelous=judge_marvelous,
judge_perfect=judge_perfect,
judge_great=judge_great,
judge_good=judge_good,
judge_boo=judge_boo,
judge_miss=judge_miss,
judge_ok=judge_ok,
judge_ng=judge_ng,
calorie=calorie,
ghostsize=ghostsize,
ghost=ghost,
timestamp=timestamp,
playstyle=playstyle,
)
session.add(new_playlog)
session.commit()
print(
f"New playlog entry created for refid: {refid}, timestamp: {timestamp}"
)
else:
print(
f"Playlog entry for refid: {refid}, timestamp: {timestamp} already exists."
)
return True
except Exception as e:
print(
f"Failed to insert playlog for refid: {refid}, timestamp: {timestamp}: {e}"
)
return False
finally:
session.close() # Close the session after use
# Web UI Stuff
def updateCustomizationsWeb(token, custom, otherCustom):
session = create_engine_and_session(db_type)
try:
# Query the database for the token and get the first result
user = (
session.query(infToken)
.filter_by(token=token)
.first() # Use filter_by to find the token
)
items = session.query(infItems).filter_by(infinitasID=user.infinitasID).first()
items.customizations = custom
items.otherCustomizations = otherCustom
session.commit()
return True
except Exception as e:
print(f"Failed to fetch token: {e}")
return False
finally:
session.close() # Close the session after use
# / database lookup /
def getrIDfromToken(token):
session = create_engine_and_session(db_type)
try:
# Query the database for the token and get the first result
user = (
session.query(eacNetProfile).filter_by(token=token).first()
) # Use filter_by to find the token
return user # This will return the user object or None if not found
except Exception as e:
print(f"Failed to fetch token: {e}")
return None
finally:
session.close() # Close the session after use
def getInfIDByToken(token):
session = create_engine_and_session(db_type)
try:
# Query the database for the token and get the first result
user = (
session.query(infToken).filter_by(token=token).first()
) # Use filter_by to find the token
return user # This will return the user object or None if not found
except Exception as e:
print(f"Failed to fetch token: {e}")
return None
finally:
session.close() # Close the session after use
def getEacnetProfilebyToken(token):
session = create_engine_and_session(db_type)
try:
# Query the database for the token and get the first result
user = (
session.query(eacNetProfile).filter_by(token=token).first()
) # Use filter_by to find the token
return user # This will return the user object or None if not found
except Exception as e:
print(f"Failed to fetch token: {e}")
return None
finally:
session.close() # Close the session after use
def getNostalgiaProfilebyToken(token):
session = create_engine_and_session(db_type)
try:
# Query the database for the token and get the first result
user = (
session.query(nosProfile).filter_by(token=token).first()
) # Use filter_by to find the token
return user # This will return the user object or None if not found
except Exception as e:
print(f"Failed to fetch token: {e}")
return None
finally:
session.close() # Close the session after use
def getDMGFProfilebyToken(token):
session = create_engine_and_session(db_type)
try:
# Query the database for the token and get the first result
user = (
session.query(DMGFProfile).filter_by(token=token).first()
) # Use filter_by to find the token
return user # This will return the user object or None if not found
except Exception as e:
print(f"Failed to fetch token: {e}")
return None
finally:
session.close() # Close the session after use
def getDMGFProfileExtbyToken(token):
session = create_engine_and_session(db_type)
try:
# Query the database for the token and get the first result
user = (
session.query(DMGFProfileExt).filter_by(token=token).first()
) # Use filter_by to find the token
return user # This will return the user object or None if not found
except Exception as e:
print(f"Failed to fetch token: {e}")
return None
finally:
session.close() # Close the session after use
def getDMGFProfileDetailsbyToken(token):
session = create_engine_and_session(db_type)
try:
# Query the database for the token and get the first result
user = (
session.query(DMGFProfileDetails).filter_by(token=token).first()
) # Use filter_by to find the token
return user # This will return the user object or None if not found
except Exception as e:
print(f"Failed to fetch token: {e}")
return None
finally:
session.close() # Close the session after use
def getDMGFPlaylogbyToken(token, game):
"""Get playlog entries for a specific token and game type"""
session = create_engine_and_session(db_type)
if token is None:
print(f"/!\\ ARGUMENT CHECK FAILED, CANNOT SEARCH FOR PLAYLOG\nToken: {token}")
return None
try:
# Query the database for all playlogs matching token and game type
playlogs = (
session.query(DMGFPlaylog)
.filter_by(token=token, game=game)
.order_by(
DMGFPlaylog.musicid,
desc(DMGFPlaylog.excellent), # Prioritize excellent clears first
desc(DMGFPlaylog.fullcombo), # Then full combos
desc(DMGFPlaylog.clear), # Then regular clears
desc(DMGFPlaylog.score), # Finally, highest score
)
.all()
) # Use .all() to get all matching entries
return playlogs # Returns list of playlogs or empty list if none found
except Exception as e:
print(f"Failed to fetch Playlogs: {e}")
return None
finally:
session.close()
def getDDRGPPlaylogbyRefid(refid):
"""Get playlog entries for a specific token and game type"""
session = create_engine_and_session(db_type)
if refid is None:
print(f"/\\ ARGUMENT CHECK FAILED, CANNOT SEARCH FOR PLAYLOG\nrefid: {refid}")
return None
try:
# Query the database for all playlogs matching refid and game type
playlogs = (
session.query(DDRGPPlaylog)
.filter_by(refid=refid)
.order_by(
DDRGPPlaylog.musicid,
asc(DDRGPPlaylog.clearkind),
asc(DDRGPPlaylog.rank),
)
.all()
) # Use .all() to get all matching entries
# Convert the playlogs to dictionaries
playlogs_dict = [playlog.__dict__ for playlog in playlogs]
return playlogs_dict # Returns list of dictionaries or empty list if none found
except Exception as e:
print(f"Failed to fetch Playlogs: {e}")
return None
finally:
session.close()
def getNostalgiaProfilebyRefID(refID):
session = create_engine_and_session(db_type)
try:
# Query the database for the token and get the first result
user = (
session.query(nosProfile).filter_by(refid=refID).first()
) # Use filter_by to find the token
return user # This will return the user object or None if not found
except Exception as e:
print(f"Failed to fetch token: {e}")
return None
finally:
session.close() # Close the session after use
def getNostalgiaMusicData(token):
session = create_engine_and_session(db_type)
try:
# Query the database for the token and get the first result
user = session.query(nosPlaylog).filter_by(
token=token
) # Use filter_by to find the token
return user # This will return the user object or None if not found
except Exception as e:
print(f"Failed to fetch Profile Music Data: {e}")
return None
finally:
session.close() # Close the session after use
def getItemsbyInfID(infID):
session = create_engine_and_session(db_type)
try:
# Query the database for the token and get the first result
user = (
session.query(infItems).filter_by(infinitasID=infID).first()
) # Use filter_by to find the token
if user is None:
print("cant find the user")
user = infItems(infinitasID=infID)
session.add(user)
session.commit()
return user # This will return the user object or None if not found
except Exception as e:
print(f"Failed to fetch token: {e}")
return None
finally:
session.close() # Close the session after use
def getProfileByInfID(infID):
session = create_engine_and_session(db_type)
try:
# Query the database for the token and get the first result
user = (
session.query(infProfile).filter_by(infinitasID=infID).first()
) # Use filter_by to find the token
return user # This will return the user object or None if not found
except Exception as e:
print(f"Failed to fetch Profile: {e}")
return None
finally:
session.close() # Close the session after use
def getInfIDMusicData(infID):
session = create_engine_and_session(db_type)
try:
# Query the database for the token and get the first result
user = session.query(InfinitasPlayData).filter_by(
infinitasID=infID
) # Use filter_by to find the token
return user # This will return the user object or None if not found
except Exception as e:
print(f"Failed to fetch Profile Music Data: {e}")
return None
finally:
session.close() # Close the session after use
def getInfIDMusicDataMusicID(infID, musicID):
session = create_engine_and_session(db_type)
try:
# Query the database for the token and get the first result
user = (
session.query(InfinitasPlayData)
.filter_by(infinitasID=infID, musicID=musicID)
.first()
) # Use filter_by to find the token
print(user)
return user # This will return the user object or None if not found
except Exception as e:
print(f"Failed to fetch Profile Music Data: {e}")
return None
finally:
session.close() # Close the session after use
def getGhostDataFromInfIDandCheckSum(
musicID=None, difficulty=None, infID=None, checksum=None
):
session = create_engine_and_session(db_type)
if musicID is None or difficulty is None or infID is None:
print(
f"/!\\ ARGUMENT CHECK FAILED, CANNOT SEARCH FOR GHOSTS\nMusicID: {musicID}\nDifficulty: {difficulty}\nInfinitasID: {infID}\nGhost Checksum: {checksum}"
)
return None
try:
# Query the database for the token and get the first result
if checksum is None:
ghost = (
session.query(infGhostData)
.filter_by(musicID=musicID, noteID=difficulty, infinitasID=infID)
.first() # Use filter_by to find the token
)
else:
ghost = (
session.query(infGhostData)
.filter_by(
musicID=musicID,
noteID=difficulty,
infinitasID=infID,
ghostCheck=checksum,
)
.first() # Use filter_by to find the token
)
return ghost # This will return the ghost, or `None`` if not found
except Exception as e:
print(f"Failed to fetch Profile: {e}")
return None
finally:
session.close() # Close the session after use
def getAllGhostDataFromInfID(infID=None):
session = create_engine_and_session(db_type)
if infID is None:
print(
f"/!\\ ARGUMENT CHECK FAILED, CANNOT SEARCH FOR GHOSTS\nInfinitasID: {infID}"
)
return None
try:
# Query the database for the token and get the first result
ghost = (
session.query(infGhostData)
.filter_by(infinitasID=infID)
.order_by(infGhostData.score.desc())
) # Use filter_by to find the token
return ghost # This will return the ghost, or `None`` if not found
except Exception as e:
print(f"Failed to fetch Profile: {e}")
return None
finally:
session.close() # Close the session after use
def randomizeGhost(
musicID=None, difficulty=None, infID=None, danRank=None, prefecture=None
):
session = create_engine_and_session(db_type)
if musicID is None or difficulty is None or infID is None:
print(
f"/!\\ ARGUMENT CHECK FAILED, CANNOT SEARCH FOR GHOSTS\nMusicID: {musicID}\nDifficulty: {difficulty}\nInfinitasID: {infID}"
)
return None
try:
ghost = session.query(infGhostData).filter_by(
musicID=musicID, noteID=difficulty
)
# Query the database for the token and get the first result
if prefecture and int(prefecture) != -1:
ghost = ghost.filter_by(prefecture=int(prefecture))
if danRank and int(danRank) != -1:
ghost = ghost.filter_by(danRank=int(danRank))
ghost = ghost.order_by(func.random()).first() # Use filter_by to find the token
return ghost # This will return the ghost, or `None` if not found
except Exception as e:
print(f"Failed to fetch Ghost Data: {e}")
return None
finally:
session.close() # Close the session after use
def getAllUnlockDataFromInfID(infID=None):
session = create_engine_and_session(db_type)
if infID is None:
print(
f"/!\\ ARGUMENT CHECK FAILED, CANNOT SEARCH FOR GHOSTS\nInfinitasID: {infID}"
)
return None
try:
# Query the database for the token and get the first result
unlocks = session.query(infUnlocks).filter_by(
infinitasID=infID
) # Use filter_by to find the token
return unlocks # This will return the ghost, or `None`` if not found
except Exception as e:
print(f"Failed to fetch Profile: {e}")
return None
finally:
session.close() # Close the session after use
def getRivalDataFromInfID(infID=None):
session = create_engine_and_session(db_type)
if infID is None:
print(
f"/!\\ ARGUMENT CHECK FAILED, CANNOT SEARCH FOR RIVAL DATA\nInfinitasID: {infID}"
)
return None
try:
# Query the database for the token and get the first result
rival = (
session.query(infRivalData).filter_by(infinitasID=infID).first()
) # Use first() to get the first result
if rival is None:
print("No Rival Data Found. Generating Default Rival Data for User.")
rival = infRivalData(infinitasID=infID, spRivals="[]", dpRivals="[]")
session.add(rival)
session.commit()
return rival # This will return the rival data or None if not found
except Exception as e:
print(f"Failed to fetch Profile: {e}")
return None
finally:
session.close() # Close the session after use
# Add after line 414 where you marked "Define DMGF Playlog here please"
Reference in New Issue View Git Blame Copy Permalink