def createModel(self):
self.model = QtSql.QSqlRelationalTableModel()
self.model.setTable("Books")
self.model.setHeaderData(0, QtCore.Qt.Horizontal, "BookId")
self.model.setHeaderData(1, QtCore.Qt.Horizontal, "Title")
self.model.setHeaderData(2, QtCore.Qt.Horizontal, "Author")
self.model.setRelation(
2, QtSql.QSqlRelation("Authors", "AuthorId", "Name"))
self.model.select()
def initializeModel(model):
model.setTable("employee")
model.setEditStrategy(QtSql.QSqlTableModel.OnManualSubmit)
model.setRelation(2, QtSql.QSqlRelation('city', 'id', 'name'))
model.setRelation(3, QtSql.QSqlRelation('country', 'id', 'name'))
model.setHeaderData(0, QtCore.Qt.Horizontal, "ID")
model.setHeaderData(1, QtCore.Qt.Horizontal, "Name")
model.setHeaderData(2, QtCore.Qt.Horizontal, "City")
model.setHeaderData(3, QtCore.Qt.Horizontal, "Country")
model.select()
def __init__(self, controller, parent=None):
# QtGui.QDialog.__init__(self, parent)
super(BookmarkManagerDialog, self).__init__(parent=parent)
self.ui = Ui_Bookmark_Dialog()
self.ui.setupUi(self)
self.controller = controller
path = Utility.get_dir_name(
controller.model.settings_manager.settings.fileName())
self.db = QtSql.QSqlDatabase().addDatabase("QSQLITE")
self.db.setDatabaseName(path + u'/bookmark.db')
if self.db.open():
self.model = QtSql.QSqlTableModel(self, self.db)
self.model.setTable('Bookmark')
self.model.setEditStrategy(QtSql.QSqlTableModel.OnManualSubmit)
self.model.select()
self.model.setHeaderData(2, QtCore.Qt.Horizontal, "Name")
self.model.setHeaderData(3, QtCore.Qt.Horizontal, "Page")
self.ui.bookmark_table.setModel(self.model)
self.ui.bookmark_table.hideColumn(0)
self.ui.bookmark_table.hideColumn(1)
self.ui.bookmark_table.hideColumn(4)
self.ui.bookmark_table.horizontalHeader().setResizeMode(
2, QtGui.QHeaderView.Stretch)
self.ui.bookmark_table.horizontalHeader().setResizeMode(
3, QtGui.QHeaderView.ResizeToContents)
self.ui.button_remove.clicked.connect(self._remove_table_item)
self.ui.button_load.clicked.connect(self._get_comic_to_open)
selection = self.ui.bookmark_table.selectionModel()
selection.selectionChanged.connect(self.selection_changed)
self.no_cover_label = self.ui.page_image_label.pixmap(
).scaledToWidth(self.width() * self.SCALE_RATIO,
QtCore.Qt.SmoothTransformation)
self.ui.page_image_label.setPixmap(self.no_cover_label)
print '[INFO] Database load!'
else:
print "[ERROR] Unable to create db file!"
def __init__(self, parent=None):
super(AccountShareModel, self).__init__(parent=parent)
self.setTable('users')
self.setFilter('userid != %s' % db.userId)
self.setSort(enum.kUsers_UserName, QtCore.Qt.AscendingOrder)
self.select()
model = QtSql.QSqlRelationalTableModel(self)
model.setTable('accountshare')
model.setRelation(enum.kAccountShare_UserId,
QtSql.QSqlRelation('users', 'userid', 'username'))
model.setEditStrategy(QtSql.QSqlTableModel.OnManualSubmit)
model.select()
self.shareModel = model
self.accountId = None
def __init__(self, parent=None):
model = QtSql.QSqlRelationalTableModel()
model.setTable(u'PURCHASE')
model.setRelation(4, QtSql.QSqlRelation(u"GC", u"код", u"название"))
model.setHeaderData(4, QtCore.Qt.Horizontal, u"видеокарта",
QtCore.Qt.DisplayRole)
model.setRelation(5, QtSql.QSqlRelation(u"BUYER", u"код", u"адрес"))
model.setHeaderData(5, QtCore.Qt.Horizontal, u"адрес покупателя",
QtCore.Qt.DisplayRole)
model.setEditStrategy(QtSql.QSqlRelationalTableModel.OnManualSubmit)
model.select()
super(TablePURCHASE, self).__init__(model, parent)
self.view.setItemDelegateForColumn(1, DateDelegate(self.view))
self.view.setItemDelegateForColumn(3, BoolDelegate(self.view))
def __init__(self, parent=None):
model = QtSql.QSqlRelationalTableModel()
model.setTable(u'GC')
model.setRelation(2, QtSql.QSqlRelation(u"GPU", u"код", u"название"))
model.setHeaderData(2, QtCore.Qt.Horizontal, u"граф. проц",
QtCore.Qt.DisplayRole)
model.setRelation(3, QtSql.QSqlRelation(u"MRER", u"код", u"название"))
model.setHeaderData(3, QtCore.Qt.Horizontal, u"производитель",
QtCore.Qt.DisplayRole)
model.setRelation(4, QtSql.QSqlRelation(u"MMR", u"код", u"объём"))
model.setHeaderData(4, QtCore.Qt.Horizontal, u"объём памяти",
QtCore.Qt.DisplayRole)
model.setEditStrategy(QtSql.QSqlRelationalTableModel.OnManualSubmit)
model.select()
super(TableGC, self).__init__(model, parent)
def __init__(self, parent=None):
model = QtSql.QSqlTableModel()
model.setTable(u'BUYER')
model.setEditStrategy(QtSql.QSqlTableModel.OnManualSubmit)
model.select()
super(TableBUYER, self).__init__(model, parent)
def createTourney(self, name, player, minPlayers, maxPlayers):
print "we do this"
query = QtSql.QSqlQuery(self.db)
queryStr = ("INSERT INTO hopin_tournament (`host`) VALUE ( %i )" %
player.getId())
query.exec_(queryStr)
uuid = query.lastInsertId()
uuid = 1
tourney = tournament(uuid, name, player, minPlayers, maxPlayers, self)
self.tourney.append(tourney)
jsonToSend = {}
jsonToSend["command"] = "social"
jsonToSend["autojoin"] = re.sub(r'\W+', '_', name)
player.getLobbyThread().sendJSON(jsonToSend)
for p in self.parent.players.getAllPlayers():
print p
jsonToSend = {}
jsonToSend["command"] = "tournament_info"
jsonToSend["state"] = tourney.getState()
jsonToSend["uid"] = tourney.getid()
jsonToSend["title"] = tourney.getName()
jsonToSend["host"] = player.getLogin()
jsonToSend["min_players"] = tourney.minPlayers
jsonToSend["max_players"] = tourney.maxPlayers
print jsonToSend
p.getLobbyThread().sendJSON(jsonToSend)
def show_shit_list(self):
query = self.db.getShitListQuery()
model = QtSql.QSqlQueryModel()
model.setQuery(query)
model.setHeaderData(0, QtCore.Qt.Horizontal, 'Member First Name')
model.setHeaderData(1, QtCore.Qt.Horizontal, 'Member Last Name')
model.setHeaderData(2, QtCore.Qt.Horizontal, 'Gear Name')
model.setHeaderData(3, QtCore.Qt.Horizontal, 'Gear ID')
model.setHeaderData(4, QtCore.Qt.Horizontal, 'Check Out Date/Time')
model.setHeaderData(5, QtCore.Qt.Horizontal, 'Due Date')
self.viewShitList.setWindowTitle('Shit List')
self.viewShitList.setWindowIcon(self.parent.icon)
self.viewShitList.resize(600, 500)
self.viewShitList.setModel(model)
self.viewShitList.setEditTriggers(
QtGui.QAbstractItemView.NoEditTriggers)
self.viewShitList.setSelectionMode(
QtGui.QAbstractItemView.SingleSelection)
self.viewShitList.setSelectionBehavior(
QtGui.QAbstractItemView.SelectRows)
self.viewShitList.resizeColumnsToContents()
self.viewShitList.show()
def __init__(self, in_fileName, in_connectionName="default"):
self.fileName = in_fileName
self.connectionName = in_connectionName
self.SQL_connection = QtSql.QSqlDatabase.addDatabase(
"QSQLITE", self.connectionName)
self.SQL_connection.setDatabaseName(self.fileName)
if self.SQL_connection.open():
self.query_create = QtSql.QSqlQuery(self.SQL_connection)
self.query_select = QtSql.QSqlQuery(self.SQL_connection)
self.query_insert = QtSql.QSqlQuery(self.SQL_connection)
self.query_delete = QtSql.QSqlQuery(self.SQL_connection)
self.query_temp = QtSql.QSqlQuery(self.SQL_connection)
else:
self.error = self.SQL_connection.lastError()
def populateDatabase():
'''Create 'favorites' table of favorite food'''
query = QtSql.QSqlQuery()
if not query.exec_("""CREATE TABLE favorites (
id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE NOT NULL,
category VARCHAR(40) NOT NULL,
number INTEGER NOT NULL,
shortdesc VARCHAR(20) NOT NULL,
longdesc VARCHAR(80))"""):
print "Failed to create table"
return False
print "Populating table..."
categories = ("Apples", "Chocolate chip cookies", "Favra beans")
numbers = (1, 2, 3)
shortDescs = ("Crispy", "Yummy", "Clarice?")
longDescs = ("Healthy and tasty", "Never not good...", "")
query.prepare(
"""INSERT INTO favorites (category, number, shortdesc, longdesc)
VALUES (:category, :number, :shortdesc, :longdesc)""")
for category, number, shortDesc, longDesc in zip(categories, numbers,
shortDescs, longDescs):
print category, number, shortDesc, longDesc
query.bindValue(":category", category)
query.bindValue(":number", number)
query.bindValue(":shortdesc", shortDesc)
query.bindValue(":longdesc", longDesc)
if not query.exec_():
print "Failed to populate table"
return False
QtGui.QApplication.processEvents() #is this needed?
return True
def getColumns(db, varDict, usrVars, queryString):
columns = []
for v in usrVars:
# make an empty list in 'columns' that will become this variable's numpy array
columns.append([])
q = QtSql.QSqlQuery(db)
q.setForwardOnly(True)
q.exec_(queryString)
while q.next():
for i, v in enumerate(usrVars):
if varDict[v][0] == "<type 'int'>":
columns[i].append(int(q.value(i)))
elif varDict[v][0] == "<type 'float'>":
columns[i].append(float(q.value(i)))
elif varDict[v][0] == "<type 'unicode'>":
columns[i].append(str(q.value(i)))
# convert columns to numpy arrays, paying attention to type
for i, v in enumerate(usrVars):
if varDict[v][0] == "<type 'int'>":
columns[i] = np.array(columns[i], dtype=np.int32)
elif varDict[v][0] == "<type 'float'>":
columns[i] = np.array(columns[i], dtype=np.float64)
elif varDict[v][0] == "<type 'unicode'>":
columns[i] = np.array(columns[i], dtype=np.object)
return columns
def getRecordCount(db, table):
q = QtSql.QSqlQuery(db)
q.exec_(str('select COUNT(*) from ' + table))
if q.next():
return str(q.value(0))
else:
return '0'
def __init__(self, parent=None):
try:
super(start, self).__init__(parent)
self.logger = logging.getLogger()
self.logger.info("Update server starting")
self.db = QtSql.QSqlDatabase("QMYSQL")
self.db.setHostName(DB_SERVER)
self.db.setPort(DB_PORT)
self.db.setDatabaseName(DB_NAME)
self.db.setUserName(DB_LOGIN)
self.db.setPassword(DB_PASSWORD)
self.db.setConnectOptions("MYSQL_OPT_RECONNECT=1")
if not self.db.open():
self.logger.error(self.db.lastError().text())
else:
self.logger.info("DB opened.")
self.updater = updateServer(self)
if not self.updater.listen(QtNetwork.QHostAddress.Any, 9001):
self.logger.error("Unable to start the server")
return
else:
self.logger.info("Starting the update server on %s:%i" %
(self.updater.serverAddress().toString(),
self.updater.serverPort()))
except Exception as e:
self.logger.exception("Error: %r" % e)
def __init__(self):
super(Dictionary, self).__init__()
self.__set_of_words__ = set()
self.__used_words__ = set()
self.db = QtSql.QSqlDatabase()
self.random = Random()
def showMembsPayments():
cmd = 'SELECT M.FirstName, M.LastName, Amount, Date, Type, Comment FROM FinancialTrans F, Member M WHERE M.ID={0} AND F.MID=M.ID ORDER BY DATE ASC'.format(
self.parent.currentMember.ID)
query = self.db.execQuery(
cmd,
'TabTransMan.py -> showMembsPayments -> showPaymentWindow')
model = QtSql.QSqlQueryModel()
model.setQuery(query)
model.setHeaderData(0, QtCore.Qt.Horizontal, 'First Name')
model.setHeaderData(1, QtCore.Qt.Horizontal, 'Last Name')
model.setHeaderData(2, QtCore.Qt.Horizontal, 'Ammount')
model.setHeaderData(3, QtCore.Qt.Horizontal, 'Date')
model.setHeaderData(4, QtCore.Qt.Horizontal, 'Type')
model.setHeaderData(5, QtCore.Qt.Horizontal, 'Comment')
self.viewMembers = QtGui.QTableView(None)
self.viewMembers.setWindowTitle('Member Transactions')
self.viewMembers.setWindowIcon(self.parent.icon)
self.viewMembers.resize(600, 500)
self.viewMembers.setModel(model)
self.viewMembers.setEditTriggers(
QtGui.QAbstractItemView.NoEditTriggers)
self.viewMembers.setSelectionMode(
QtGui.QAbstractItemView.SingleSelection)
self.viewMembers.setSelectionBehavior(
QtGui.QAbstractItemView.SelectRows)
self.viewMembers.resizeColumnsToContents()
self.viewMembers.show()
def __init__(self, files, parent=None):
super(ImportModel, self).__init__(parent=parent)
self._headers = []
self._root = TreeItem()
self._checksums = []
self._checksumsSaved = None
self.__currentTimestamp = None
# Import all record checksums
query = QtSql.QSqlQuery("""
SELECT checksum
FROM records r
INNER JOIN accounts a
ON a.id=r.accountid
AND a.userid=%d
""" % db.userId)
if query.lastError().isValid():
raise Exception(query.lastError().text())
while query.next():
self._checksums.append(query.value(0))
self._checksumsSaved = self._checksums[:]
for item in self.readFiles(files):
self._root.appendChild(item)
self._root.setRecordsImported(self._checksums)
self._root.setDuplicateRecords()
self._numColumns = self._root.maxColumns()
self._headers = range(self._numColumns)
def switchAccount(self, index):
""" Account changed by user, populate all fields
"""
if index == -1:
return
model = self.accountCombo.model()
self.sortCode.setText(
model.index(index, enum.kAccounts_SortCode).data())
self.accountNo.setText(
model.index(index, enum.kAccounts_AccountNo).data())
realAccountName = model.index(index,
enum.kAccounts_AccountTypeId).data()
self.accountType.setCurrentIndex(
self.accountType.findText(realAccountName))
# Set the filter on accountshare table
accountId = model.index(index, enum.kAccounts_Id).data()
self.accountShareView.model().changedAccount(accountId)
self._allowAccountShareEdit = True
query = QtSql.QSqlQuery(
'SELECT count(*) FROM records WHERE accountid=%s' % accountId)
query.next()
self._accountRecordCount = query.value(0)
self.setButtonsEnabled()
def main():
db = QtSql.QSqlDatabase.addDatabase("QSQLITE")
db.setDatabaseName("test.db")
if not db.open():
print "cannot establish a database connection"
sys.exit(1)
db.transaction()
q = QtSql.QSqlQuery()
q.exec_("DROP TABLE IF EXISTS Cars")
check_error(q, db)
q.exec_("CREATE TABLE Cars(Id INT," "Name TEXT, Price INT)")
check_error(q, db)
q.exec_("INSERT INTO Cars VALUES(1,'Audi',52642)")
check_error(q, db)
q.exec_("INSERT INTO Cars VALUES(2,'Mercedes',57127)")
check_error(q, db)
q.exec_("INSERT INTO Cars VALUES(3,'Skoda',9000)")
check_error(q, db)
q.exec_("INSERT INTO Cars VALUES(4,'Volvo',29000)")
check_error(q, db)
q.exec_("INSERT INTO Cars VALUES(5,'Bentley',350000)")
check_error(q, db)
q.exec_("INSERT INTO Cars VALUES(6,'Citroen',21000)")
check_error(q, db)
q.exec_("INSERT INTO Cars VALUES(7,'Hummer',41400)")
check_error(q, db)
q.exec_("INSERT INTO Cars VALUES(8,'Volkswagen',21600)")
check_error(q, db)
db.commit()
db.close()
def populateDates(self):
""" Set date fields to min and max values
"""
query = QtSql.QSqlQuery("""
SELECT MIN(r.date), MAX(r.date), MAX(r.insertdate)
FROM records r
LEFT JOIN accounts a
ON a.id=r.accountid
LEFT JOIN accountshare acs
ON acs.accountid = r.accountid
WHERE (a.userid=%(userid)s
OR acs.userid=%(userid)s)
""" % {'userid': db.userId})
if query.lastError().isValid():
QtGui.QMessageBox.critical(self, 'Database Error',
query.lastError().text(),
QtGui.QMessageBox.Ok)
return
if query.next():
startDate = query.value(0)
endDate = query.value(1)
maxInsertDateTime = query.value(2)
self.startDateEdit.setDateRange(startDate, endDate)
self.endDateEdit.setDateRange(startDate, endDate)
self.maxInsertDate = maxInsertDateTime
def deleteAccount(self):
for index in self.view.selectionModel().selectedRows():
accountTypeId = self.model.index(
index.row(), enum.kAccountType__AccountTypeId).data()
query = QtSql.QSqlQuery(
'SELECT COUNT(*) FROM records WHERE accounttypeid=%s' %
accountTypeId)
query.next()
recordCount = query.value(0)
if recordCount:
QtGui.QMessageBox.critical(
self, 'Account Delete ',
'Cannot delete account, %d records exist for this account'
% recordCount)
return
if index.isValid():
self.model.removeRows(index.row(), 1, QtCore.QModelIndex())
self.view.clearSelection()
self.enableCommit(True)
def __init__(self, tableName, parent=None):
super(TableEditor, self).__init__(parent)
self.model = QtSql.QSqlTableModel(self)
self.model.setTable(tableName)
self.model.setEditStrategy(QtSql.QSqlTableModel.OnManualSubmit)
self.model.select()
self.model.setHeaderData(0, QtCore.Qt.Horizontal, "ID")
self.model.setHeaderData(1, QtCore.Qt.Horizontal, "First name")
self.model.setHeaderData(2, QtCore.Qt.Horizontal, "Last name")
view = QtGui.QTableView()
view.setModel(self.model)
submitButton = QtGui.QPushButton("Submit")
submitButton.setDefault(True)
revertButton = QtGui.QPushButton("&Revert")
quitButton = QtGui.QPushButton("Quit")
buttonBox = QtGui.QDialogButtonBox(QtCore.Qt.Vertical)
buttonBox.addButton(submitButton, QtGui.QDialogButtonBox.ActionRole)
buttonBox.addButton(revertButton, QtGui.QDialogButtonBox.ActionRole)
buttonBox.addButton(quitButton, QtGui.QDialogButtonBox.RejectRole)
submitButton.clicked.connect(self.submit)
revertButton.clicked.connect(self.model.revertAll)
quitButton.clicked.connect(self.close)
mainLayout = QtGui.QHBoxLayout()
mainLayout.addWidget(view)
mainLayout.addWidget(buttonBox)
self.setLayout(mainLayout)
self.setWindowTitle("Cached Table")
def remRow(self):
index = self.view.currentIndex() #how to upull row from index?
if not index.isValid():
return
rowNum = index.row()
#print "Trying to remove row ", rowNum
QtSql.QSqlDatabase.database().transaction() #begin transaction
record = self.model.record(index.row())
rowID = int(record.value(ID))
#dialog to ask user if they are sure
msg = "<font color=red>Delete</font> <b>row {}</b><br>from {}?".format(
rowNum, self.tableName)
if (QtGui.QMessageBox.question(
self, "Delete row", msg, QtGui.QMessageBox.Yes
| QtGui.QMessageBox.No) == QtGui.QMessageBox.No):
QtSql.QSqlDatabase.database().rollback()
return
#If user has verified they want row deleted, do it
query = QtSql.QSqlQuery()
query.exec_("DELETE FROM {} WHERE id = {}".format(
self.tableName, rowID))
self.model.removeRow(index.row())
self.model.submitAll() #commits change to database
QtSql.QSqlDatabase.database().commit() #commit transaction
def __init__(self, table):
super(BrowseProducts, self).__init__()
self.setupUi(self)
#site_pack_path = site.getsitepackages()[1]
#QtGui.QApplication.addLibraryPath('{0}\\PySide\\plugins'.format(site_pack_path))
#QApplication.addLibraryPath("c:\\Python27\\Lib\\site-packages\\PySide\\plugins\\")
# Connect to database
__database__ = QtSql.QSqlDatabase.addDatabase('QSQLITE')
__database__.setDatabaseName('spos.db')
__database__.open()
# Create table model
self.__tableModel__ = QtSql.QSqlTableModel(self, __database__)
self.__tableGrid__.setModel(self.__tableModel__)
self.__tableModel__.setTable(table)
self.__tableModel__.select()
print(self.__tableModel__.selectStatement())
# Connect combobox signal to update model
"""
def printTable(tableName):
'''Print out all contents of a table (header names, and each row)'''
#print "Printing contents of table '{}'".format(tableName)
query = QtSql.QSqlQuery()
if not query.exec_("""SELECT * FROM {}""".format(tableName)):
print "Failure to execute SELECT in displayTable"
return False
record = query.record()
#display fields
numFields = record.count(
) #; print "There are {} fields".format(numFields);
fieldNames = ()
print "\nFields:"
for fieldNum in range(numFields):
fieldNames = fieldNames + (record.fieldName(fieldNum), )
print fieldNames
#display values
print "Values:"
while query.next():
values = []
for field in range(numFields):
values.append(query.value(field))
print values
QtGui.QApplication.processEvents()
return True
def delete_btn_clicked(self):
query = QtSql.QSqlQuery()
inds = self.tableView.selectionModel().selectedRows()
print(inds)
if inds:
num_records = len(inds)
ret = QMessageBox.critical(self.mem_win, "Confirm Delete", "Are you sure you want to delete " + str(num_records) + " records? Please note all related lifts performed by this member will also be deleted. This action cannot be undone.", QMessageBox.Ok|QMessageBox.Cancel)
if ret == QMessageBox.Cancel:
return
elif ret == QMessageBox.Ok:
progress = QProgressDialog("Deleting Records...", "Abort Delete", 0, num_records, self.mem_win)
counter = 0
for ind in inds:
progress.setValue(counter)
if progress.wasCanceled():
QMessageBox.information(self.mem_win, "Operation Cancelled", str(counter) + " records imported!", QMessageBox.Ok)
return
index = ind.row()
db_id = self.data[index][0]
print(db_id)
tmp_mem = self.session.query(Member).filter(Member.id == db_id).first()
print(tmp_mem)
try:
self.session.delete(tmp_mem)
self.session.commit()
except:
self.session.rollback()
counter += 1
progress.setValue(num_records)
self.refresh_table()
else:
QMessageBox.critical(self.mem_win, "No selection", "Please make a select at least one row to delete!", QMessageBox.Ok)
def createUuid(self, playerId):
query = QtSql.QSqlQuery(self.db)
queryStr = ("INSERT INTO game_stats (`host`) VALUE ( %i )" % playerId)
query.exec_(queryStr)
uuid = query.lastInsertId()
return uuid
def createView(title, model):
view = QtGui.QTableView()
view.setModel(model)
view.setItemDelegate(QtSql.QSqlRelationalDelegate(view))
view.setWindowTitle(title)
return view
def main():
db = QtSql.QSqlDatabase.addDatabase("QSQLITE")
db.setDatabaseName("allsortsDB.db")
if not db.open():
print "Cannot establish a databse connection"
sys.exit(1)
db.transaction()
q = QtSql.QSqlQuery()
q.exec_("drop table if exists Cars")
check_error(q, db)
q.exec_("create table Cars(Id Int, Name text, Price int)")
check_error(q, db)
q.exec_("INSERT INTO Cars VALUES(1,'Audi ',52642)")
check_error(q, db)
q.exec_("INSERT INTO Cars VALUES(2,'Mercedes ',57127)")
check_error(q, db)
q.exec_("INSERT INTO Cars VALUES(3,'Skoda ',9000)")
check_error(q, db)
q.exec_("INSERT INTO Cars VALUES(4,'Volvo ',29000)")
check_error(q, db)
q.exec_("INSERT INTO Cars VALUES(5,'Bentley ' ,350000)")
check_error(q, db)
q.exec_("INSERT INTO Cars VALUES(6,'Citroen ',21000)")
check_error(q, db)
q.exec_("INSERT INTO Cars VALUES(7,'Hummer ',41400)")
check_error(q, db)
q.exec_("INSERT INTO Cars VALUES(8,'Volkswagen ',21600)")
check_error(q, db)
db.commit()
db.close()
def _on_join(self, c, e):
try:
ch = e.target
nick = e.source.nick
if nick == c.get_nickname():
self.channels[ch] = Channel()
self.connection.send_raw("NAMES" + (ch))
#self.connection.send_raw("PRIVMSG %s :%s" % ("#aeolus", "yo!"))
elif "aeolus" in ch :
#print nick,"has joined", ch
query = QtSql.QSqlQuery(self.db)
query.prepare("SELECT faction, IFNULL(dominant,-1) FROM galacticwar.accounts LEFT join galacticwar.domination on galacticwar.accounts.faction = galacticwar.domination.slave WHERE galacticwar.accounts.uid = (SELECT id FROM faf_lobby.login WHERE login = ? )")
query.addBindValue(nick)
query.exec_()
if query.size() > 0:
query.first()
if int(query.value(1)) != -1:
faction = int(query.value(1))
else:
faction = int(query.value(0))
if faction == 0 :
channel = "#UEF"
elif faction == 1 :
channel = "#Aeon"
elif faction == 2 :
channel = "#Cybran"
elif faction == 3 :
channel = "#Seraphim"
self.connection.privmsg('chanserv', 'INVITE %s %s' % (channel, nick))
self.channels[ch].add_user(nick)
except:
pass
