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