def query_withdrawals(start, page_size, start_date, end_date):
connection = None
withdrawals = []
try:
connection = mysql_connection.get_conn()
sql = config.get("sql", "sql_query_withdrawals") % (
start, page_size, start_date, end_date)
with connection.cursor() as cursor:
cursor.execute(sql)
r = cursor.fetchall()
if r is not None:
for result in r:
withdrawal = Withdrawal()
withdrawal.id = result["id"]
withdrawal.time = result["time"]
withdrawal.user_id = result["user_id"]
withdrawal.state = result["state"]
withdrawal.money = result["money"]
withdrawal.type = result["type"]
withdrawals.append(withdrawal)
except:
print traceback.print_exc()
finally:
if connection is not None:
connection.close()
return withdrawals
def create_account(t, connection, loginserver, address):
close = connection is None
try:
if connection is None:
connection = mysql_connection.get_conn()
userid = 0
while userid == 0:
uid = random.randint(11000, 99999)
if query_account_by_id(connection, uid) is None:
userid = uid
sql = config.get("sql", "sql_create_account") % (
userid, loginserver.account,
StringUtils.phoneToNick(loginserver.nick), loginserver.sex,
config.get("gateway", "head_url") % random.randint(1, 50),
StringUtils.md5(loginserver.account), int(t), int(t), address,
loginserver.device)
with connection.cursor() as cursor:
cursor.execute(sql)
connection.commit()
except:
if close and connection is not None:
connection.rollback()
print traceback.print_exc()
finally:
if close and connection is not None:
connection.close()
def login(loginserver, address):
connection = None
account = None
try:
connection = mysql_connection.get_conn()
if not exist_account(connection, loginserver.account):
create_account(time.time(), connection, loginserver, address)
gold = int(config.get("gateway", "login_give"))
account = query_account_by_account(connection, loginserver.account)
s = HttpUtils(config.get("api", "api_host")).get(
config.get("api", "bind") %
(account.id, loginserver.higher, address.split(':')[0],
loginserver.qudao), None)
res = s.read()
if 0 != gold:
update_currency(connection, gold, 0, 0, 0, account.id)
account = query_account_by_account(connection, loginserver.account)
except:
if connection is not None:
connection.rollback()
print traceback.print_exc()
finally:
if connection is not None:
connection.close()
return account
def query_orders(start, page_size):
connection = None
orders = []
try:
connection = mysql_connection.get_conn()
sql = config.get("sql", "sql_query_orders") % (start, page_size)
with connection.cursor() as cursor:
cursor.execute(sql)
r = cursor.fetchall()
if r is not None:
for result in r:
order = Order()
order.room_no = result["room_no"]
order.customer_name = result["customer_name"]
order.order_from = result["order_from"]
order.price = result["price"]
order.return_cash = result["return_cash"]
order.pay_type = result["pay_type"]
order.order_status = result["order_status"]
order.mark = result["mark"]
order.order_time = result["order_time"]
order.check_in_time = result["check_in_time"]
order.check_out_time = result["check_out_time"]
order.operation_account_name = result[
"operation_account_name"]
orders.append(order)
except:
print traceback.print_exc()
finally:
if connection is not None:
connection.close()
return orders
def get_records(allocIds, __userId):
connection = None
recMatchRecordInfo = RecMatchRecordInfo()
try:
connection = mysql_connection.get_conn()
records = []
ps = []
t = int(time.time())
in_p = ""
for a in allocIds:
in_p += "," + str(a)
sql = config.get("sql", "sql_get_record") % (str(
(t - 259200) * 1000000), "%" + str(__userId) + "%", in_p[1:])
with connection.cursor() as cursor:
cursor.execute(sql)
result = cursor.fetchall()
for r in result:
a = Record()
a.id = r["id"]
a.alloc_id = r["alloc_id"]
a.roomNo = r["room_no"]
a.players = r["players"]
a.scores = r["scores"]
a.time = r["time"]
records.append(a)
playes = a.players.split(",")
for p in playes:
if p not in ps:
ps.append(p)
if len(ps) > 0:
accounts = data_account.query_account_by_ids(connection, ps)
for r in records:
recordInfos = recMatchRecordInfo.matchRecords.add()
recordInfos.recordId = r.id
recordInfos.allocId = r.alloc_id
recordInfos.playTime = r.time
recordInfos.gameId = int(r.roomNo)
rplayers = r.players.split(",")
rscore = r.scores.split(",")
for i in range(0, len(rplayers)):
playerDatas = recordInfos.playerDatas.add()
playerDatas.playerId = int(rplayers[i])
if 1 == int(rplayers[i]):
playerDatas.nick = "系统"
else:
playerDatas.nick = accounts[int(rplayers[i])].nick_name
playerDatas.score = int(rscore[i])
except:
print traceback.print_exc()
finally:
if connection is not None:
connection.close()
return recMatchRecordInfo
def update_room_status(status, room_no):
connection = None
try:
connection = mysql_connection.get_conn()
with connection.cursor() as cursor:
sql = config.get("sql",
"sql_update_room_status") % (status, room_no)
cursor.execute(sql)
connection.commit()
except:
print traceback.print_exc()
finally:
if connection is not None:
connection.close()
def update_customer_service(address, account_name):
connection = None
try:
connection = mysql_connection.get_conn()
sql = config.get("sql", "sql_update_login") % (int(
time.time()), address, account_name)
with connection.cursor() as cursor:
cursor.execute(sql)
connection.commit()
except:
print traceback.print_exc()
finally:
if connection is not None:
connection.close()
def query_order_count():
connection = None
try:
connection = mysql_connection.get_conn()
sql = config.get("sql", "sql_query_order_count")
with connection.cursor() as cursor:
cursor.execute(sql)
result = cursor.fetchone()
return result["result"]
except:
print traceback.print_exc()
finally:
if connection is not None:
connection.close()
return 0
def deal(status, id):
connection = None
try:
connection = mysql_connection.get_conn()
with connection.cursor() as cursor:
sql = config.get("sql", "sql_withdrawal_deal") % (status, id)
cursor.execute(sql)
connection.commit()
return cursor.rowcount == 1
except:
print traceback.print_exc()
finally:
if connection is not None:
connection.close()
return False
def exist_account(connection, account):
close = connection is None
try:
if connection is None:
connection = mysql_connection.get_conn()
sql = config.get("sql", "sql_exist_account") % account
with connection.cursor() as cursor:
cursor.execute(sql)
result = cursor.fetchone()
return result["result"] != 0
except:
print traceback.print_exc()
finally:
if close and connection is not None:
connection.close()
return False
def create_user_rebate(create_date, user_id):
connection = None
try:
connection = mysql_connection.get_conn()
sql = config.get("sql", "sql_user_rebate") % (
0, create_date, user_id, 10000, "", 10000, 0, 0, 0)
with connection.cursor() as cursor:
cursor.execute(sql)
connection.commit()
except:
print traceback.print_exc()
if connection is not None:
connection.rollback()
finally:
if connection is not None:
connection.close()
def create_record(id, alloc_id, room_no, game, players, scores, time):
connection = None
try:
connection = mysql_connection.get_conn()
sql = config.get("sql", "sql_create_record") % (
id, alloc_id, room_no, game, players, scores, time)
with connection.cursor() as cursor:
cursor.execute(sql)
connection.commit()
except:
print traceback.print_exc()
if connection is not None:
connection.rollback()
finally:
if connection is not None:
connection.close()
def check_out(room_no):
connection = None
try:
connection = mysql_connection.get_conn()
with connection.cursor() as cursor:
sql = config.get("sql", "sql_order_check_out") % (int(
time.time()), room_no)
cursor.execute(sql)
connection.commit()
return cursor.rowcount == 1
except:
print traceback.print_exc()
finally:
if connection is not None:
connection.close()
return False
def update_login(t, connection, address, account, device):
close = connection is None
try:
if connection is None:
connection = mysql_connection.get_conn()
sql = config.get(
"sql", "sql_update_login") % (int(t), address, device, account)
with connection.cursor() as cursor:
cursor.execute(sql)
connection.commit()
except:
if close and connection is not None:
connection.rollback()
print traceback.print_exc()
finally:
if close and connection is not None:
connection.close()
def create_game_details(details):
connection = None
try:
connection = mysql_connection.get_conn()
with connection.cursor() as cursor:
for d in details:
sql = config.get("sql", "sql_game_details") % (
d.user_id, d.alloc_id, d.room_no, d.score, d.service_charge, d.time)
cursor.execute(sql)
connection.commit()
except:
print traceback.print_exc()
if connection is not None:
connection.rollback()
finally:
if connection is not None:
connection.close()
def update_currencys(updates):
connection = None
try:
connection = mysql_connection.get_conn()
with connection.cursor() as cursor:
for update in updates:
sql = config.get("sql", "sql_update_currency") % (
update.gold, 0, 0, 0, update.user_id)
cursor.execute(sql)
connection.commit()
except:
if connection is not None:
connection.rollback()
print traceback.print_exc()
finally:
if connection is not None:
connection.close()
def update_currency(connection, gold, integral, bankGold, bankIntegral, id):
close = connection is None
try:
if connection is None:
connection = mysql_connection.get_conn()
sql = config.get("sql", "sql_update_currency") % (
gold, integral, bankGold, bankIntegral, id)
with connection.cursor() as cursor:
cursor.execute(sql)
connection.commit()
except:
if close and connection is not None:
connection.rollback()
print traceback.print_exc()
finally:
if close and connection is not None:
connection.close()
def relogin(relogininfo, address):
t = time.time()
connection = None
try:
connection = mysql_connection.get_conn()
if exist_account(connection, relogininfo.account):
update_login(t, connection, address, relogininfo.account, None)
return query_account_by_account(connection, relogininfo.account)
except:
if connection is not None:
connection.rollback()
print traceback.print_exc()
finally:
if connection is not None:
connection.close()
return None
def query_withdrawal_count_by_state():
connection = None
room_count = {}
try:
connection = mysql_connection.get_conn()
sql = config.get("sql", "sql_withdrawal_count_by_status")
with connection.cursor() as cursor:
cursor.execute(sql)
r = cursor.fetchall()
if r is not None:
for result in r:
room_count[result["state"]] = result["result"]
except:
print traceback.print_exc()
finally:
if connection is not None:
connection.close()
return room_count
def order(order):
connection = None
try:
connection = mysql_connection.get_conn()
with connection.cursor() as cursor:
sql = config.get("sql", "sql_order_order") % (
order.room_no, order.customer_name, order.order_from,
order.price, order.return_cash, order.pay_type,
order.mark if order.mark is not None else '', order.order_time,
order.operation_account_name)
cursor.execute(sql)
connection.commit()
return cursor.rowcount == 1
except:
print traceback.print_exc()
finally:
if connection is not None:
connection.close()
return False
def update_introduce(connection, id, content):
account = None
close = connection is None
try:
if connection is None:
connection = mysql_connection.get_conn()
sql = config.get("sql", "sql_update_introduce") % (content, id)
with connection.cursor() as cursor:
cursor.execute(sql)
connection.commit()
account = query_account_by_id(connection, id)
except:
if close and connection is not None:
connection.rollback()
print traceback.print_exc()
finally:
if close and connection is not None:
connection.close()
return account
def create_gold(type, source, user_id, gold):
from data.database import data_account
connection = None
try:
connection = mysql_connection.get_conn()
account = data_account.query_account_by_id(connection, user_id)
sql = config.get("sql", "sql_create_gold") % (
type, source, user_id, gold, account.gold, int(time.time()))
with connection.cursor() as cursor:
cursor.execute(sql)
connection.commit()
except:
print traceback.print_exc()
if connection is not None:
connection.rollback()
finally:
if connection is not None:
connection.close()
def query_account_by_ids(connection, ids):
close = connection is None
accounts = {}
try:
if connection is None:
connection = mysql_connection.get_conn()
in_p = ', '.join((map(lambda x: '%s', ids)))
sql = config.get("sql", "sql_query_account_by_ids") % in_p
with connection.cursor() as cursor:
cursor.execute(sql, ids)
r = cursor.fetchall()
for result in r:
a = Account()
a.id = result["id"]
a.account_name = result["account_name"]
a.nick_name = result["nick_name"]
a.sex = result["sex"]
a.pswd = result["pswd"]
a.head_url = result["head_url"]
a.create_time = result["create_time"]
a.last_time = result["last_time"]
a.last_address = result["last_address"]
a.account_state = result["account_state"]
a.gold = result["gold"]
a.integral = result["integral"]
a.bank_pswd = result["bank_pswd"]
a.bank_gold = result["bank_gold"]
a.bank_integral = result["bank_integral"]
a.authority = result["authority"]
a.total_count = result["total_count"]
a.introduce = result["introduce"]
a.phone = result["phone"]
a.level = result["level"]
a.experience = result["experience"]
a.device = result["device"]
accounts[a.id] = a
except:
print traceback.print_exc()
finally:
if close and connection is not None:
connection.close()
return accounts
def ranking_by_gold(connection, limit):
close = connection is None
try:
if connection is None:
connection = mysql_connection.get_conn()
accounts = []
sql = config.get("sql", "sql_ranking_by_gold") % limit
with connection.cursor() as cursor:
cursor.execute(sql)
result = cursor.fetchall()
for r in result:
a = Account()
a.id = r["id"]
a.account_name = r["account_name"]
a.nick_name = r["nick_name"]
a.sex = r["sex"]
a.pswd = r["pswd"]
a.head_url = r["head_url"]
a.create_time = r["create_time"]
a.last_time = r["last_time"]
a.last_address = r["last_address"]
a.account_state = r["account_state"]
a.gold = r["gold"]
a.integral = r["integral"]
a.bank_pswd = r["bank_pswd"]
a.bank_gold = r["bank_gold"]
a.bank_integral = r["bank_integral"]
a.authority = r["authority"]
a.total_count = r["total_count"]
a.introduce = r["introduce"]
a.phone = r["phone"]
a.level = r["level"]
a.experience = r["experience"]
a.device = r["device"]
accounts.append(a)
return accounts
except:
print traceback.print_exc()
finally:
if close and connection is not None:
connection.close()
return None
def query_room_by_room_no(room_no):
connection = None
try:
connection = mysql_connection.get_conn()
sql = config.get("sql", "sql_query_room_by_room_no") % room_no
with connection.cursor() as cursor:
cursor.execute(sql)
result = cursor.fetchone()
if result is not None:
room = Room()
room.room_no = result["room_no"]
room.room_type = result["room_type"]
room.room_status = result["room_status"]
return room
except:
print traceback.print_exc()
finally:
if connection is not None:
connection.close()
return None
def query_account_by_id(connection, id):
close = connection is None
try:
if connection is None:
connection = mysql_connection.get_conn()
sql = config.get("sql", "sql_query_account_by_id") % id
with connection.cursor() as cursor:
cursor.execute(sql)
result = cursor.fetchone()
if result is not None:
a = Account()
a.id = result["id"]
a.account_name = result["account_name"]
a.nick_name = result["nick_name"]
a.sex = result["sex"]
a.pswd = result["pswd"]
a.head_url = result["head_url"]
a.create_time = result["create_time"]
a.last_time = result["last_time"]
a.last_address = result["last_address"]
a.account_state = result["account_state"]
a.gold = result["gold"]
a.integral = result["integral"]
a.bank_pswd = result["bank_pswd"]
a.bank_gold = result["bank_gold"]
a.bank_integral = result["bank_integral"]
a.authority = result["authority"]
a.total_count = result["total_count"]
a.introduce = result["introduce"]
a.phone = result["phone"]
a.level = result["level"]
a.experience = result["experience"]
a.device = result["device"]
return a
except:
print traceback.print_exc()
finally:
if close and connection is not None:
connection.close()
return None
def query_rooms():
connection = None
rooms = []
try:
connection = mysql_connection.get_conn()
sql = config.get("sql", "sql_query_rooms")
with connection.cursor() as cursor:
cursor.execute(sql)
r = cursor.fetchall()
if r is not None:
for result in r:
room = Room()
room.room_no = result["room_no"]
room.room_type = result["room_type"]
room.room_status = result["room_status"]
rooms.append(room)
except:
print traceback.print_exc()
finally:
if connection is not None:
connection.close()
return rooms
def query_by_id(userid):
connection = None
try:
connection = mysql_connection.get_conn()
sql = config.get("sql", "sql_query_bankcard_by_id") % userid
with connection.cursor() as cursor:
cursor.execute(sql)
result = cursor.fetchone()
if result is not None:
bankcard = Bankcard()
bankcard.user_id = userid
bankcard.rel_name = result["rel_name"]
bankcard.bank_name = result["bank_name"]
bankcard.bank_address = result["bank_address"]
bankcard.phone_num = result["phone_num"]
bankcard.bank_card_num = result["bank_card_num"]
return bankcard
except:
print traceback.print_exc()
finally:
if connection is not None:
connection.close()
return None
def query_by_id(id):
connection = None
try:
connection = mysql_connection.get_conn()
sql = config.get("sql", "sql_query_withdrawal_by_id") % id
with connection.cursor() as cursor:
cursor.execute(sql)
result = cursor.fetchone()
if result is not None:
withdrawal = Withdrawal()
withdrawal.id = result["id"]
withdrawal.time = result["time"]
withdrawal.user_id = result["user_id"]
withdrawal.state = result["state"]
withdrawal.money = result["money"]
withdrawal.type = result["type"]
return withdrawal
except:
print traceback.print_exc()
finally:
if connection is not None:
connection.close()
return None
def query_by_account_name(account_name):
connection = None
try:
connection = mysql_connection.get_conn()
sql = config.get(
"sql", "sql_query_customer_service_by_account_name") % account_name
with connection.cursor() as cursor:
cursor.execute(sql)
result = cursor.fetchone()
if result is not None:
customerService = CustomerService()
customerService.id = result["id"]
customerService.account_name = result["account_name"]
customerService.pswd = result["pswd"]
customerService.create_time = result["create_time"]
customerService.last_time = result["last_time"]
customerService.last_address = result["last_address"]
return customerService
except:
print traceback.print_exc()
finally:
if connection is not None:
connection.close()
return None
