def get(self):
try:
args = request.args
if 'match_id' in args:
query_match= """
SELECT SCORE_ID FROM MATCH WHERE ID = %s
"""
params = (args['match_id'],)
row_score = readSQL(query_match, params)
if row_score:
query_score= """
SELECT SCORECARD_ID FROM SCORE WHERE ID = %s
"""
params = (row_score['score_id'],)
row_scorecard_id = readSQL(query_score, params)
if row_scorecard_id:
over = ''
query_playercard= """
select id, ball_id, team_a_over, team_b_over, innings from playerscorecard where s_id = %s
order by innings, team_a_over, team_b_over
"""
params = (row_scorecard_id['scorecard_id'],)
row_match = readManySQL(query_playercard, params)
innings_1_list = []
innings_2_list = []
for over in row_match:
if over['innings'] == 1:
inning_1 = {}
inning_1['id'] = over['id']
inning_1['innings'] = over['innings']
inning_1['over'] = over['team_a_over']
inning_1['ball_id'] = over['ball_id']
innings_1_list.append(inning_1)
for over in row_match:
if over['innings'] == 2:
inning_2 = {}
inning_2['id'] = over['id']
inning_2['innings'] = over['innings']
inning_2['over'] = over['team_b_over']
inning_2['ball_id'] = over['ball_id']
innings_2_list.append(inning_2)
get_curr_inng = app.redis.get("match:"+str(args['match_id'])+":innings")
curr_livecard = {}
if get_curr_inng:
get_inng = json.loads(get_curr_inng)
curr_key = "livescorecard:"+str(args['match_id'])+":current:"+str(get_inng)
curr_livecard = json.loads(app.redis.get(curr_key))
curr_livecard['innings'] = get_inng
data = json.dumps({'success' : True, 'innings_1': innings_1_list, 'innings_2': innings_2_list, 'status': curr_livecard}, default=default)
return json.loads(data), 200
except Exception as e:
app.log.exception(e)
return {'success': False, 'message': "SERVER/DB error" }, 500
def post(self):
parser = reqparse.RequestParser(bundle_errors=True)
parser.add_argument('username', type=str, required=True, help="Username cannot be blank!", location='json')
parser.add_argument('password', type=str, required=True, help="password cannot be blank!", location='json')
args = parser.parse_args()
try:
if args['username'] and args['password'] is not None:
username = args['username']
password = args['password']
if username and password is not None:
query_user= """
SELECT PASSWORD FROM USERS WHERE USERNAME = %s
"""
params = (username,)
row = readSQL(query_user, params)
status = app.bcrypt.check_password_hash(row['password'], password)
if status:
access_token = app.create_access_token(identity=username)
return { 'success' : True, 'token': access_token }, 200
else:
return { 'success' : False }, 404
else:
return { 'success' : False }, 400
except Exception as e:
app.log.exception(e)
return {'success': False, 'message': "SERVER/DB error" }, 500
def get(self):
try:
args = request.args
if 'id' in args:
query= """
SELECT * FROM MATCHTYPE WHERE ID = %s
"""
params = (args['id'],)
series = readSQL(query, params)
elif 'offset' in args and 'limit' in args:
offset = int(request.args['offset'])
limit = int(request.args['limit'])
query= """
SELECT * FROM MATCHTYPE LIMIT %s OFFSET %s
"""
params = (limit, offset)
series = readManySQL(query, params)
else:
return {'sucess' : False, 'message': 'missing parameters' }, 400
if series:
data = json.dumps({'success' : True, 'data': series}, default=default)
return json.loads(data), 200
else:
return {'sucess' : False, 'message': 'no records found' }, 404
except Exception as e:
app.log.exception(e)
return {'success': False, 'message': "SERVER/DB error" }, 500
def put(self):
try:
parser = reqparse.RequestParser(bundle_errors=True)
parser.add_argument('id', type=str, required=True, help="match id cannot be missing!", location='json')
parser.add_argument('team_a', type=int, required=True, help="team id a cannot be missing!", location='json')
parser.add_argument('team_b', type=int, required=True, help="team id b cannot be missing!", location='json')
parser.add_argument('toss', type=int, required=True, help="toss cannot be missing!", location='json')
args = parser.parse_args()
update_match= """
UPDATE MATCH SET TEAM_A = %s, TEAM_B = %s, TOSS = %s WHERE ID = %s
"""
params = (args['team_a'], args['team_b'], args['toss'], args['id'])
update = writeSQL(update_match, params)
if update:
query_match_toss= """
select match.team_a, match.team_b, match.toss, teama.name as team_a_name, teamb.name as team_b_name from "match"
join team as teama on match.team_a = teama.id
join team as teamb on match.team_b = teamb.id
where match.id = %s
"""
params = (args['id'],)
row_match = readSQL(query_match_toss, params)
if row_match:
teamA_name = row_match['team_a_name']
teamB_name = row_match['team_b_name']
match_status = ''
if row_match['toss'] == args['team_a']:
if row_match['team_a'] == args['team_a']:
match_status = row_match['team_a_name']+" won the toss and elected to bat first"
else:
match_status = row_match['team_a_name']+" won the toss and elected to field first"
elif row_match['toss'] == args['team_b']:
if row_match['team_b'] == args['team_a']:
match_status = row_match['team_b_name']+" won the toss and elected to bat first"
else:
match_status = row_match['team_b_name']+" won the toss and elected to field first"
inn_key = "match:"+str(args['id'])+":innings"
live_key_1 = "livescorecard:"+str(args['id'])+":current:1"
live_val_1 = json.dumps({'over': "0.0", 'ball': 0, 'match_status': match_status})
live_key_2 = "livescorecard:"+str(args['id'])+":current:2"
live_val_2 = json.dumps({'over': "0.0", 'ball': 0, 'match_status': 'Innings 2 is in progress'})
quick_key_1 = "quickscorecard:"+str(args['id'])+":current:1"
quick_val_1 = json.dumps({'score': "0/0 (0.0)", 'team': teamA_name})
quick_key_2 = "quickscorecard:"+str(args['id'])+":current:2"
quick_val_2 = json.dumps({'score': "0/0 (0.0)", 'team': teamB_name})
app.redis.set(inn_key, 1)
app.redis.set(live_key_1, live_val_1)
app.redis.set(live_key_2, live_val_2)
app.redis.set(quick_key_1, quick_val_1)
app.redis.set(quick_key_2, quick_val_2)
return {'success': True }, 200
else:
return {'success': False, 'message': 'no match found' }, 404
except Exception as e:
app.log.exception(e)
return {'success': False, 'message': "SERVER/DB error" }, 500
def getMatchType(args):
try:
if args and 'match_type' in args:
query_matchtype = """
SELECT ID FROM MATCHTYPE WHERE ID = %s
"""
params = (args['match_type'], )
row_match_type = readSQL(query_matchtype, params)
return row_match_type
except Exception as e:
app.log.exception(e)
raise e
def getMatchFormat(args):
try:
if args and 'format' in args:
query_format = """
SELECT ID FROM FORMAT WHERE ID = %s
"""
params = (args['format'], )
row_format = readSQL(query_format, params)
return row_format
except Exception as e:
app.log.exception(e)
raise e
def getCountry(args):
try:
if args and 'country' in args:
query_country = """
SELECT ID FROM COUNTRY WHERE ID = %s
"""
params = (args['country'], )
row_country = readSQL(query_country, params)
return row_country
except Exception as e:
app.log.exception(e)
raise e
def get(self):
try:
args = request.args
if 'id' in args:
query_status = """
SELECT * FROM STATUS WHERE ID = %s
"""
params = (args['id'], )
row_status = readSQL(query_status, params)
if row_status:
return {'success': True, 'data': row_status}, 200
else:
return {'success': False, 'message': 'no data found'}, 404
except Exception as e:
app.log.exception(e)
return {'success': False, 'message': "SERVER/DB error"}, 500
def get(self):
try:
args = request.args
if 'id' in args:
query = """
SELECT * FROM TEAM WHERE ID = %s
"""
params = (args['id'], )
teams = readSQL(query, params)
else:
query = """
SELECT * FROM TEAM
"""
teams = readManySQL(query, None)
if teams:
return {'success': True, 'data': teams}, 200
else:
return {'sucess': False, 'message': 'no records found'}, 404
except Exception as e:
app.log.exception(e)
return {'success': False, 'message': "SERVER/DB error"}, 500
def post(self):
parser = reqparse.RequestParser(bundle_errors=True)
parser.add_argument('name', type=str, required=True, help="Name of the match cannot be missing!", location='json')
parser.add_argument('type', type=str, required=True, help="Type cannot be missing!", location='json')
parser.add_argument('startdate', type=str, required=True, help="Start date cannot be missing!", location='json')
parser.add_argument('enddate', type=str, required=True, help="End date cannot be missing!", location='json')
parser.add_argument('venue', type=str, required=True, help="Venue cannot be missing!", location='json')
parser.add_argument('created', type=str, required=True, help="Created date cannot be missing!", location='json')
parser.add_argument('modified', type=str, required=True, help="Modified date cannot be missing!", location='json')
parser.add_argument('teams', type=list, required=True, help="Modified date cannot be missing!", location='json')
args = parser.parse_args()
try:
query_matchtype= """
SELECT G_ID FROM MATCHTYPE ORDER BY ID DESC LIMIT 1
"""
row_grp_id = readSQL(query_matchtype, None)
if row_grp_id:
if(row_grp_id['g_id']):
grp_id = row_grp_id['g_id'] + 1
else:
grp_id = 1
insert_matchtype= """
INSERT INTO MATCHTYPE (NAME, TYPE, START_DATE, END_DATE, G_ID, VENUE, CREATED, MODIFIED)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
"""
params = (args['name'], args['type'], args['startdate'], args['enddate'], grp_id, args['venue'], args['created'], args['modified'])
write_matchtype = writeSQL(insert_matchtype, params)
if write_matchtype:
for team in args['teams']:
insert_points= """
INSERT INTO POINTS (TEAM_ID, G_ID, CREATED, MODIFIED)
VALUES (%s, %s, %s, %s)
"""
params = (team, grp_id, getDatetime(), getDatetime())
writeSQL(insert_points, params)
return {'success': 'true', 'message': 'match type created'}, 200
except Exception as e:
app.log.exception(e)
return {'success': False, 'message': "SERVER/DB error" }, 500
def get(self):
try:
args = request.args
if 'id' in args:
query = """
SELECT * FROM PLAYER WHERE ID = %s
"""
params = (args['id'], )
players = readSQL(query, params)
elif 'teamid' in args:
query = """
SELECT p1.*, t1.NAME as "team_name" FROM PLAYER p1 left join TEAM t1 on p1.team_id=t1.id WHERE p1.TEAM_ID =%s
"""
params = (args['teamid'], )
players = readManySQL(query, params)
elif 'offset' in args and 'limit' in args:
offset = int(request.args['offset'])
limit = int(request.args['limit'])
query = """
SELECT * FROM PLAYER LIMIT %s OFFSET %s
"""
params = (limit, offset)
players = readManySQL(query, params)
else:
return {'sucess': False, 'message': 'missing parameters'}, 400
if players:
data = json.dumps({
'success': True,
'data': players
},
default=default)
return json.loads(data), 200
else:
return {'sucess': False, 'message': 'no records found'}, 404
except Exception as e:
app.log.exception(e)
return {'success': False, 'message': "SERVER/DB error"}, 500
def get(self, livescorecard_id):
try:
if livescorecard_id:
prev_id = int(livescorecard_id) - 1
if prev_id:
query_playerscorecard = """
SELECT * FROM PLAYERSCORECARD WHERE ID = %s
"""
params = (prev_id, )
print(prev_id)
row_playerscorecard = readSQL(query_playerscorecard,
params)
data = json.dumps(
{
'success': True,
'card': row_playerscorecard
},
default=default)
return json.loads(data), 200
else:
return {'success': False}, 404
except Exception as e:
app.log.exception(e)
return {'success': False, 'message': "SERVER/DB error"}, 500
def put(self):
parser = reqparse.RequestParser(bundle_errors=True)
parser.add_argument('match_id',
type=int,
required=True,
help="match id cannot be missing!",
location='json')
parser.add_argument('player_id',
type=int,
required=True,
help="player id cannot be missing!",
location='json')
parser.add_argument('message',
type=str,
required=True,
help="message cannot be missing!",
location='json')
parser.add_argument('type',
type=str,
required=True,
help="type cannot be missing!",
location='json')
args = parser.parse_args()
try:
match_id = args['match_id']
get_curr_inng = app.redis.get("match:" + str(args['match_id']) +
":innings")
get_inng = json.loads(get_curr_inng)
curr_key = "livescorecard:" + str(match_id) + ":current:" + str(
get_inng)
curr_livecard = app.redis.get(curr_key)
key_info = json.loads(curr_livecard)
if (args['type'] == 'batsman'):
get_fullcard = "fullscorecard:" + str(
args['match_id']) + ":" + str(get_inng) + ":" + str(
key_info['ball'])
fullcard = json.loads(app.redis.get(get_fullcard))
if get_inng == 1:
key = "innings_1"
player = str(args['player_id']) + "_pname"
elif get_inng == 2:
key = "innings_2"
player = str(args['player_id']) + "_pname"
if player in fullcard[key]['batting']:
player_record = fullcard[key]['batting'][player]
fullcard[key]['batting'][player]['status'] = 'retrd'
fullcard[key]['yetToBat'].append(player_record['name'])
fullcard_key = "fullscorecard:" + str(
args['match_id']) + ":" + str(get_inng) + ":" + str(
key_info['ball'])
app.redis.set(fullcard_key, json.dumps(fullcard))
query_playerscorecard = """
SELECT * FROM PLAYERSCORECARD WHERE MATCH_ID = %s AND INNINGS = %s ORDER BY ID desc limit 1
"""
params = (args['match_id'], get_inng)
row_playerscorecard = readSQL(query_playerscorecard,
params)
if row_playerscorecard:
update_playerscorecard = """
UPDATE PLAYERSCORECARD SET RETIRED = %s WHERE ID = %s
"""
params = (int(args['player_id']),
row_playerscorecard['id'])
updated_row = writeSQL(update_playerscorecard, params)
if updated_row:
#manual commentry
list_com = "list:" + str(match_id) + ":" + str(
get_inng)
man_com_key = "commentry:" + str(
match_id) + ":" + str(get_inng) + ":manual"
obj = {}
obj['comment'] = args['message']
obj['datetime'] = datetime.utcnow()
if (app.redis.hkeys(man_com_key)):
index_val = [
val for loc, val in enumerate(
app.redis.hkeys(man_com_key)) if
math.floor(float(val)) == key_info['ball']
]
if (index_val):
max_val = float(max(index_val))
field_key = format(max_val + 0.1, ".1f")
else:
field_key = key_info['ball'] + 0.1
else:
field_key = key_info['ball'] + 0.1
list_man_com_key = man_com_key + ":" + str(
field_key)
app.redis.lpush(list_com, list_man_com_key)
app.redis.hset(man_com_key, field_key,
json.dumps(obj, default=default))
return {'success': True}, 200
elif (args['type'] == 'bowler'):
#manual commentry
list_com = "list:" + str(match_id) + ":" + str(get_inng)
man_com_key = "commentry:" + str(match_id) + ":" + str(
get_inng) + ":manual"
obj = {}
obj['comment'] = args['message']
obj['datetime'] = datetime.utcnow()
if (app.redis.hkeys(man_com_key)):
index_val = [
val
for loc, val in enumerate(app.redis.hkeys(man_com_key))
if math.floor(float(val)) == key_info['ball']
]
if (index_val):
max_val = float(max(index_val))
field_key = format(max_val + 0.1, ".1f")
else:
field_key = key_info['ball'] + 0.1
else:
field_key = key_info['ball'] + 0.1
list_man_com_key = man_com_key + ":" + str(field_key)
app.redis.lpush(list_com, list_man_com_key)
app.redis.hset(man_com_key, field_key,
json.dumps(obj, default=default))
return {'success': True}, 200
else:
return {'success': False, 'message': 'no player found'}, 404
except Exception as e:
app.log.exception(e)
return {'success': False, 'message': "SERVER/DB error"}, 500
def put(self):
parser = reqparse.RequestParser(bundle_errors=True)
parser.add_argument('innings',
type=int,
required=True,
help="innings cannot be missing!",
location='json')
parser.add_argument('match_id',
type=int,
required=True,
help="match id of the match cannot be missing!",
location='json')
parser.add_argument('ballid',
type=int,
required=True,
help="ball id cannot be missing!",
location='json')
parser.add_argument('penalty',
type=str,
required=True,
help="penalty cannot be missing!",
location='json')
parser.add_argument('formatOver',
type=str,
required=True,
help="Format over cannot be missing!",
location='json')
parser.add_argument('message',
type=str,
required=True,
help="Message cannot be missing!",
location='json')
args = parser.parse_args()
try:
innings = int(args['innings'])
matchid = args['match_id']
ballid = args['ballid']
penalty = args['penalty']
formatOver = int(args['formatOver']) - 1 + 0.6
query_playerscorecard = """
SELECT * FROM PLAYERSCORECARD WHERE MATCH_ID = %s AND INNINGS = %s ORDER BY ID desc limit 1
"""
params = (matchid, innings)
row_last_record = readSQL(query_playerscorecard, params)
if (row_last_record):
if (innings == 1):
# teamA is doing mistake
if (penalty == 'teamA'):
if (row_last_record['penalty_a']):
pnlt_a = row_last_record['penalty_a'] + 5
else:
pnlt_a = 5
update_record = """
UPDATE PLAYERSCORECARD SET PENALTY_A = %s WHERE MATCH_ID = %s AND BALL_ID = %s
"""
params = (pnlt_a, matchid, ballid)
updated_record = writeSQL(update_record, params)
if (updated_record):
query_playerscorecard = """
SELECT * FROM PLAYERSCORECARD WHERE MATCH_ID = %s AND INNINGS = %s ORDER BY ID desc limit 1
"""
params = (matchid, innings)
row_lastrecord = readSQL(query_playerscorecard,
params)
if (row_lastrecord):
pnlt = 0
if (row_last_record['ball_id'] ==
args['ballid']):
pnlt = row_lastrecord['penalty_a']
else:
if (row_last_record['penalty_a']):
pnlt = row_last_record['penalty_a'] + 5
else:
pnlt = 5
get_curr_inng = app.redis.get("match:" +
str(matchid) +
":innings")
get_inng = json.loads(get_curr_inng)
curr_key = "livescorecard:" + str(
matchid) + ":current:" + str(get_inng)
curr_livecard = app.redis.get(curr_key)
key_info = json.loads(curr_livecard)
get_fullcard = "fullscorecard:" + str(
matchid) + ":" + str(innings) + ":" + str(
key_info['ball'])
fullcard = json.loads(
app.redis.get(get_fullcard))
fullcard['teamBRuns'] = row_lastrecord[
'team_b_score'] + 5
# print(fullcard['teamBRuns'])
for key, value in fullcard['innings_1'].items(
):
if key == 'extras':
fullcard['innings_1']['extras'][
'pnlt'] = pnlt
updated_key = app.redis.set(
get_fullcard,
json.dumps(fullcard, default=default))
if (updated_key):
update_playerscorecard = """
UPDATE PLAYERSCORECARD SET PENALTY_A = %s, TEAM_B_SCORE = %s WHERE ID = %s
"""
params = (pnlt,
row_lastrecord['team_b_score'] +
5, row_lastrecord['id'])
updated_row = writeSQL(
update_playerscorecard, params)
if (updated_row):
#manual commentry
list_com = "list:" + str(
matchid) + ":" + str(get_inng)
man_com_key = "commentry:" + str(
matchid) + ":" + str(
get_inng) + ":manual"
obj = {}
obj['comment'] = args['message']
obj['datetime'] = datetime.utcnow()
if (app.redis.hkeys(man_com_key)):
index_val = [
val for loc, val in enumerate(
app.redis.hkeys(
man_com_key))
if math.floor(float(val)) ==
key_info['ball']
]
if (index_val):
max_val = float(max(index_val))
field_key = format(
max_val + 0.1, ".1f")
else:
field_key = key_info[
'ball'] + 0.1
else:
field_key = key_info['ball'] + 0.1
list_man_com_key = man_com_key + ":" + str(
field_key)
app.redis.lpush(
list_com, list_man_com_key)
app.redis.hset(
man_com_key, field_key,
json.dumps(obj, default=default))
return {'success': True}, 200
# teamB is doing mistake
elif (penalty == 'teamB'):
if (row_last_record['penalty_b']):
pnlt_b = row_last_record['penalty_b'] + 5
else:
pnlt_b = 5
update_record = """
UPDATE PLAYERSCORECARD SET PENALTY_B = %s WHERE MATCH_ID = %s AND BALL_ID = %s
"""
params = (pnlt_b, matchid, ballid)
updated_record = writeSQL(update_record, params)
if (updated_record):
query_playerscorecard = """
SELECT * FROM PLAYERSCORECARD WHERE MATCH_ID = %s AND INNINGS = %s ORDER BY ID desc limit 1
"""
params = (matchid, innings)
row_lastrecord = readSQL(query_playerscorecard,
params)
if (row_lastrecord):
pnlt = 0
if (row_last_record['ball_id'] ==
args['ballid']):
pnlt = row_lastrecord['penalty_b']
else:
if (row_last_record['penalty_b']):
pnlt = row_last_record['penalty_b'] + 5
else:
pnlt = 5
score = row_lastrecord['team_a_score'] + 5
over = row_lastrecord['team_a_over']
balls = int(over) + (round(over % 1, 2) * 10 /
6)
cal_cur_rate = score / balls
get_curr_inng = app.redis.get("match:" +
str(matchid) +
":innings")
get_inng = json.loads(get_curr_inng)
curr_key = "livescorecard:" + str(
matchid) + ":current:" + str(get_inng)
curr_livecard = app.redis.get(curr_key)
key_info = json.loads(curr_livecard)
get_fullcard = "fullscorecard:" + str(
matchid) + ":" + str(innings) + ":" + str(
key_info['ball'])
fullcard = json.loads(
app.redis.get(get_fullcard))
fullcard['teamARuns'] = score
fullcard['curr_rate'] = round(cal_cur_rate, 2)
for key, value in fullcard['innings_2'].items(
):
if key == 'extras':
fullcard['innings_2']['extras'][
'pnlt'] = pnlt
updated_key = app.redis.set(
get_fullcard,
json.dumps(fullcard, default=default))
if updated_key:
update_playerscorecard = """
UPDATE PLAYERSCORECARD SET TEAM_A_SCORE = %s, CURR_RATE = %s, PENALTY_B = %s WHERE ID = %s
"""
params = (score,
float(round(cal_cur_rate, 2)),
pnlt, row_lastrecord['id'])
updated_row = writeSQL(
update_playerscorecard, params)
if (updated_row):
#manual commentry
list_com = "list:" + str(
matchid) + ":" + str(get_inng)
man_com_key = "commentry:" + str(
matchid) + ":" + str(
get_inng) + ":manual"
obj = {}
obj['comment'] = args['message']
obj['datetime'] = datetime.utcnow()
if (app.redis.hkeys(man_com_key)):
index_val = [
val for loc, val in enumerate(
app.redis.hkeys(
man_com_key))
if math.floor(float(val)) ==
key_info['ball']
]
if (index_val):
max_val = float(max(index_val))
field_key = format(
max_val + 0.1, ".1f")
else:
field_key = key_info[
'ball'] + 0.1
else:
field_key = key_info['ball'] + 0.1
list_man_com_key = man_com_key + ":" + str(
field_key)
app.redis.lpush(
list_com, list_man_com_key)
app.redis.hset(
man_com_key, field_key,
json.dumps(obj, default=default))
return {'success': True}, 200
elif (innings == 2):
# teamA is doing mistake
if (penalty == 'teamA'):
if (row_last_record['penalty_a']):
pnlt_a = row_last_record['penalty_a'] + 5
else:
pnlt_a = 5
update_record = """
UPDATE PLAYERSCORECARD SET PENALTY_A = %s WHERE MATCH_ID = %s AND BALL_ID = %s
"""
params = (pnlt_a, matchid, ballid)
updated_record = writeSQL(update_record, params)
if (updated_record):
query_playerscorecard = """
SELECT * FROM PLAYERSCORECARD WHERE MATCH_ID = %s AND INNINGS = %s ORDER BY ID desc limit 1
"""
params = (matchid, innings)
row_lastrecord = readSQL(query_playerscorecard,
params)
if (row_lastrecord):
pnlt = 0
if (row_last_record['ball_id'] ==
args['ballid']):
pnlt = row_lastrecord['penalty_a']
else:
if (row_last_record['penalty_a']):
pnlt = row_last_record['penalty_a'] + 5
else:
pnlt = 5
teama_score = row_lastrecord['team_a_score']
teamb_score = row_lastrecord['team_b_score'] + 5
teamb_over = row_lastrecord['team_b_over']
balls = int(teamb_over) + (
round(teamb_over % 1, 2) * 10 / 6)
cal_cur_rate = teamb_score / balls
remainingOvrs = float(formatOver) - float(
teamb_over)
remainingBalls = int(remainingOvrs) + (
round(remainingOvrs % 1, 2) * 10 / 6)
cal_req_rate = round(
(teama_score - teamb_score) /
remainingBalls, 2)
get_curr_inng = app.redis.get("match:" +
str(matchid) +
":innings")
get_inng = json.loads(get_curr_inng)
curr_key = "livescorecard:" + str(
matchid) + ":current:" + str(get_inng)
curr_livecard = app.redis.get(curr_key)
key_info = json.loads(curr_livecard)
get_fullcard = "fullscorecard:" + str(
matchid) + ":" + str(innings) + ":" + str(
key_info['ball'])
fullcard = json.loads(
app.redis.get(get_fullcard))
fullcard['teamBRuns'] = teamb_score
fullcard['curr_rate'] = round(cal_cur_rate, 2)
fullcard['req_rate'] = cal_req_rate
# print(fullcard)
for key, value in fullcard['innings_1'].items(
):
if key == 'extras':
fullcard['innings_1']['extras'][
'pnlt'] = pnlt
updated_key = app.redis.set(
get_fullcard,
json.dumps(fullcard, default=default))
if updated_key:
query_playerscorecard = """
UPDATE PLAYERSCORECARD SET TEAM_B_SCORE = %s, CURR_RATE = %s, REQ_RATE = %s, PENALTY_A = %s WHERE ID = %s
"""
params = (teamb_score,
float(round(cal_cur_rate,
2)), cal_req_rate,
pnlt, row_lastrecord['id'])
updated_playerscorecard = writeSQL(
query_playerscorecard, params)
if updated_playerscorecard:
#manual commentry
list_com = "list:" + str(
matchid) + ":" + str(get_inng)
man_com_key = "commentry:" + str(
matchid) + ":" + str(
get_inng) + ":manual"
obj = {}
obj['comment'] = args['message']
obj['datetime'] = datetime.utcnow()
if (app.redis.hkeys(man_com_key)):
index_val = [
val for loc, val in enumerate(
app.redis.hkeys(
man_com_key))
if math.floor(float(val)) ==
key_info['ball']
]
if (index_val):
max_val = float(max(index_val))
field_key = format(
max_val + 0.1, ".1f")
else:
field_key = key_info[
'ball'] + 0.1
else:
field_key = key_info['ball'] + 0.1
list_man_com_key = man_com_key + ":" + str(
field_key)
app.redis.lpush(
list_com, list_man_com_key)
app.redis.hset(
man_com_key, field_key,
json.dumps(obj, default=default))
return {'success': True}, 200
# teamB is doing mistake
elif (penalty == 'teamB'):
if (row_last_record['penalty_b']):
pnlt_b = row_last_record['penalty_b'] + 5
else:
pnlt_b = 5
update_record = """
UPDATE PLAYERSCORECARD SET PENALTY_B = %s WHERE MATCH_ID = %s AND BALL_ID = %s
"""
params = (pnlt_b, matchid, ballid)
updated_record = writeSQL(update_record, params)
if (updated_record):
query_playerscorecard = """
SELECT * FROM PLAYERSCORECARD WHERE MATCH_ID = %s AND INNINGS = %s ORDER BY ID desc limit 1
"""
params = (matchid, innings)
row_lastrecord = readSQL(query_playerscorecard,
params)
if (row_lastrecord):
pnlt = 0
if (row_last_record['ball_id'] ==
args['ballid']):
pnlt = row_lastrecord['penalty_b']
else:
if (row_last_record['penalty_b']):
pnlt = row_last_record['penalty_b'] + 5
else:
pnlt = 5
teama_score = row_lastrecord['team_a_score'] + 5
teamb_score = row_lastrecord['team_b_score']
teamb_over = row_lastrecord['team_b_over']
balls = int(teamb_over) + (
round(teamb_over % 1, 2) * 10 / 6)
cal_cur_rate = teamb_score / balls
remainingOvrs = float(formatOver) - float(
teamb_over)
remainingBalls = int(remainingOvrs) + (
round(remainingOvrs % 1, 2) * 10 / 6)
cal_req_rate = round(
(teama_score - teamb_score) /
remainingBalls, 2)
get_curr_inng = app.redis.get("match:" +
str(matchid) +
":innings")
get_inng = json.loads(get_curr_inng)
curr_key = "livescorecard:" + str(
matchid) + ":current:" + str(get_inng)
curr_livecard = app.redis.get(curr_key)
key_info = json.loads(curr_livecard)
get_fullcard = "fullscorecard:" + str(
matchid) + ":" + str(innings) + ":" + str(
key_info['ball'])
fullcard = json.loads(
app.redis.get(get_fullcard))
fullcard['teamARuns'] = teama_score
fullcard['teamBRuns'] = teamb_score
fullcard['curr_rate'] = round(cal_cur_rate, 2)
fullcard['req_rate'] = cal_req_rate
for key, value in fullcard['innings_2'].items(
):
if key == 'extras':
fullcard['innings_2']['extras'][
'pnlt'] = pnlt
updated_key = app.redis.set(
get_fullcard,
json.dumps(fullcard, default=default))
if updated_key:
query_playerscorecard = """
UPDATE PLAYERSCORECARD SET TEAM_A_SCORE = %s, CURR_RATE = %s, REQ_RATE = %s, PENALTY_B = %s WHERE ID = %s
"""
params = (teama_score,
float(round(cal_cur_rate,
2)), cal_req_rate,
pnlt, row_lastrecord['id'])
updated_playerscorecard = writeSQL(
query_playerscorecard, params)
if updated_playerscorecard:
#manual commentry
list_com = "list:" + str(
matchid) + ":" + str(get_inng)
man_com_key = "commentry:" + str(
matchid) + ":" + str(
get_inng) + ":manual"
obj = {}
obj['comment'] = args['message']
obj['datetime'] = datetime.utcnow()
if (app.redis.hkeys(man_com_key)):
index_val = [
val for loc, val in enumerate(
app.redis.hkeys(
man_com_key))
if math.floor(float(val)) ==
key_info['ball']
]
if (index_val):
max_val = float(max(index_val))
field_key = format(
max_val + 0.1, ".1f")
else:
field_key = key_info[
'ball'] + 0.1
else:
field_key = key_info['ball'] + 0.1
list_man_com_key = man_com_key + ":" + str(
field_key)
app.redis.lpush(
list_com, list_man_com_key)
app.redis.hset(
man_com_key, field_key,
json.dumps(obj, default=default))
return {'success': True}, 200
except Exception as e:
app.log.exception(e)
return {'success': False, 'message': "SERVER/DB error"}, 500
def post(self):
parser = reqparse.RequestParser(bundle_errors=True)
parser.add_argument('name',
type=str,
required=True,
help="Name of the match cannot be missing!",
location='json')
parser.add_argument('date',
type=str,
required=True,
help="Date cannot be missing!",
location='json')
parser.add_argument('venue',
type=str,
required=True,
help="Venue cannot be missing!",
location='json')
parser.add_argument('format',
type=int,
required=True,
help="Format cannot be missing!",
location='json')
parser.add_argument('team_squad_1',
type=list,
required=True,
help="Team squad 1 cannot be missing!",
location='json')
parser.add_argument('team_squad_2',
type=list,
required=True,
help="Team squad 2 cannot be missing!",
location='json')
parser.add_argument('team_a',
type=int,
required=True,
help="Team A cannot be missing!",
location='json')
parser.add_argument('team_b',
type=int,
required=True,
help="Team B cannot be missing!",
location='json')
parser.add_argument('match_type',
type=int,
required=True,
help="Match Type cannot be missing!",
location='json')
parser.add_argument('result', type=int, location='json')
parser.add_argument('country',
required=True,
type=int,
help="Country cannot be missing!",
location='json')
parser.add_argument('mom', type=int, location='json')
parser.add_argument('match_status',
type=str,
required=True,
location='json')
parser.add_argument('description',
type=str,
required=True,
help="Description cannot be missing!",
location='json')
args = parser.parse_args()
try:
#get format 'id' for the match
row_format = getMatchFormat(args)
if row_format is None:
return {'success': False, 'message': 'format not found'}, 404
#get match type 'id' for the match
row_match_type = getMatchType(args)
if row_match_type is None:
return {
'success': False,
'message': 'match type not found'
}, 404
#get country 'id' for the match
row_country = getCountry(args)
if row_country is None:
return {'success': False, 'message': 'country not found'}, 404
#get team squad ids for the match
try:
if args and ('team_squad_1' in args
and 'team_squad_2' in args):
query_squad = """
SELECT TEAM_SQUAD_1, TEAM_SQUAD_2 FROM squad ORDER BY ID desc limit 1
"""
row_squad = readSQL(query_squad, None)
if row_squad is None:
t_id_1 = 1
t_id_2 = 2
else:
t_id_1 = row_squad['team_squad_1'] + 2
t_id_2 = row_squad['team_squad_2'] + 2
insert_squad = """
INSERT INTO SQUAD (TEAM_SQUAD_1, TEAM_SQUAD_2)
VALUES (%s, %s)
"""
params = (t_id_1, t_id_2)
writeSQL(insert_squad, params)
# insert team 1 players in team squad
for player in args['team_squad_1']:
query_team_squad_1 = """
INSERT INTO TEAMSQUAD (PLAYER_ID, TEAM_ID, T_ID_1, T_ID_2, SELECTED, POSITION, PLAYER_IN)
VALUES (%s, %s, %s, %s, %s, %s, %s)
"""
params = (player['player'], player['team'], t_id_1,
None, player['status'], player['position'],
player['status'])
writeSQL(query_team_squad_1, params)
# insert team 2 players in team squad
for player in args['team_squad_2']:
query_team_squad_2 = """
INSERT INTO TEAMSQUAD (PLAYER_ID, TEAM_ID, T_ID_1, T_ID_2, SELECTED, POSITION, PLAYER_IN)
VALUES (%s, %s, %s, %s, %s, %s, %s)
"""
params = (player['player'], player['team'], None,
t_id_2, player['status'], player['position'],
player['status'])
writeSQL(query_team_squad_2, params)
except Exception as e:
query_delete_teamsquad = """
DELETE FROM TEAMSQUAD WHERE T_ID_1 = %s OR T_ID_2 = %s
"""
params = (t_id_1, t_id_2)
writeSQL(query_delete_teamsquad, params)
if t_id_1 and t_id_2:
query_delete_squad = """
DELETE FROM SQUAD WHERE TEAM_SQUAD_1 = %s OR TEAM_SQUAD_2 = %s
"""
params = (t_id_1, t_id_2)
writeSQL(query_delete_squad, params)
app.log.exception(e)
return {'success': False, 'message': "SERVER/DB error"}, 500
#get score squad ids for the match
try:
query_score = """
SELECT SCORECARD_ID FROM SCORE ORDER BY ID desc limit 1
"""
row_score = readSQL(query_score, None)
if row_score is None:
s_id = 1
else:
s_id = row_score['scorecard_id'] + 1
query = """
INSERT INTO SCORE (SCORECARD_ID)
VALUES (%s)"""
params = (s_id, )
writeSQL(query, params)
except Exception as e:
query_delete_teamsquad = """
DELETE FROM TEAMSQUAD WHERE T_ID_1 = %s OR T_ID_2 = %s
"""
params = (t_id_1, t_id_2)
writeSQL(query_delete_teamsquad, params)
if t_id_1 and t_id_2:
query_delete_squad = """
DELETE FROM SQUAD WHERE TEAM_SQUAD_1 = %s OR TEAM_SQUAD_2 = %s
"""
params = (t_id_1, t_id_2)
writeSQL(query_delete_squad, params)
if s_id:
query_delete_score = """
DELETE FROM SCORE WHERE SCORECARD_ID = %s
"""
params = (s_id, )
writeSQL(query_delete_score, params)
app.log.exception(e)
return {'success': False, 'message': "SERVER/DB error"}, 500
#match table insertion
try:
query_squad = """
SELECT ID FROM SQUAD ORDER BY ID desc limit 1
"""
row_squad = readSQL(query_squad, None)
query_score = """
SELECT ID FROM SCORE ORDER BY ID desc limit 1
"""
row_score = readSQL(query_score, None)
query = """
INSERT INTO MATCH (NAME, DATE, VENUE, TEAM_A, TEAM_B, STATUS, SQUAD_ID, FORMAT_ID, MATCHTYPE_ID, SCORE_ID, COUNTRY_ID, DESCRIPTION )
VALUES
(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
"""
params = (args['name'], args['date'], args['venue'],
args['team_a'], args['team_b'], args['match_status'],
row_squad['id'], row_format['id'],
row_match_type['id'], row_score['id'],
row_country['id'], args['description'])
count = writeSQL(query, params)
if count:
return {
'success': True,
'message': 'match is created'
}, 200
except Exception as e:
query_delete_teamsquad = """
DELETE FROM TEAMSQUAD WHERE T_ID_1 = %s OR T_ID_2 = %s
"""
params = (t_id_1, t_id_2)
writeSQL(query_delete_teamsquad, params)
if t_id_1 and t_id_2:
query_delete_squad = """
DELETE FROM SQUAD WHERE TEAM_SQUAD_1 = %s OR TEAM_SQUAD_2 = %s
"""
params = (t_id_1, t_id_2)
writeSQL(query_delete_squad, params)
if s_id:
query_delete_score = """
DELETE FROM SCORE WHERE SCORECARD_ID = %s
"""
params = (s_id, )
writeSQL(query_delete_score, params)
app.log.exception(e)
return {'success': False, 'message': "SERVER/DB error"}, 500
except Exception as e:
app.log.exception(e)
return {'success': False, 'message': "SERVER/DB error"}, 500
def get(self):
try:
args = request.args
if args:
if 'status' in args and args['status'] == 'ALL':
query_match = """
SELECT * FROM MATCH ORDER BY ID ASC
"""
params = (None, )
elif 'status' in args:
query_match = """
SELECT * FROM MATCH WHERE STATUS = %s
"""
params = (args['status'], )
elif 'id' in args:
query_match = """
SELECT * FROM MATCH WHERE ID = %s
"""
params = (args['id'], )
row_match = readManySQL(query_match, params)
if 'status' in args:
data = json.dumps({
'success': True,
'data': row_match
},
default=default)
return json.loads(data), 200
elif 'id' in args and row_match:
query_squad = """
SELECT MATCHTYPE.TYPE, MATCHTYPE.NAME AS MATCHTYPE_NAME, FORMAT.NAME AS FORMAT_NAME, FORMAT.OVERS AS FORMAT_OVERS, FORMAT.INNINGS AS FORMAT_INNINGS, TEAMSQUAD.PLAYER_ID AS ID, PLAYER.NAME, PLAYER.FIRST_NAME, PLAYER.LAST_NAME, PLAYER.BOWLING_CAT, PLAYER.BATTING_STYLE, TEAMSQUAD.TEAM_ID AS TEAM, TEAMSQUAD.T_ID_1, TEAMSQUAD.T_ID_2, TEAMSQUAD.SELECTED, TEAMSQUAD.position, TEAMSQUAD.PLAYER_IN FROM MATCH
JOIN SQUAD ON MATCH.SQUAD_ID = SQUAD.ID
JOIN TEAMSQUAD ON SQUAD.TEAM_SQUAD_1 = TEAMSQUAD.T_ID_1 OR SQUAD.TEAM_SQUAD_2 = TEAMSQUAD.T_ID_2
JOIN PLAYER ON TEAMSQUAD.PLAYER_ID = PLAYER.ID
JOIN FORMAT ON FORMAT.ID = MATCH.FORMAT_ID
JOIN MATCHTYPE ON MATCHTYPE.ID = MATCH.MATCHTYPE_ID
WHERE MATCH.ID = %s
ORDER BY TEAMSQUAD.POSITION asc
"""
params = (args['id'], )
row_squads = readManySQL(query_squad, params)
match_type = row_squads[0]['type']
format_name = row_squads[0]['format_name']
format_overs = row_squads[0]['format_overs']
format_innings = row_squads[0]['format_innings']
matchtype_name = row_squads[0]['matchtype_name']
match = row_match[0]
team_squad_1 = []
team_squad_2 = []
for team in row_squads:
if team['t_id_1']:
team_squad_1.append({
'id':
team['id'],
'name':
team['name'],
'first_name':
team['first_name'],
'last_name':
team['last_name'],
'bowling_cat':
team['bowling_cat'],
'team':
team['team'],
'selected':
team['selected'],
'position':
team['position'],
'batting_style':
team['batting_style'],
'player_in':
team['player_in']
})
for team in row_squads:
if team['t_id_2']:
team_squad_2.append({
'id':
team['id'],
'name':
team['name'],
'first_name':
team['first_name'],
'last_name':
team['last_name'],
'bowling_cat':
team['bowling_cat'],
'team':
team['team'],
'selected':
team['selected'],
'position':
team['position'],
'batting_style':
team['batting_style'],
'player_in':
team['player_in']
})
query_result = """
SELECT * FROM RESULT WHERE ID = %s;
"""
params = (match['result_id'], )
row_result = readSQL(query_result, params)
obj = {
'id': match['id'],
'name': match['name'],
'date': match['date'],
'local': match['local'],
'venue': match['venue'],
'toss': match['toss'],
'team_a': match['team_a'],
'team_b': match['team_b'],
'status': match['status'],
'team_squad_1': team_squad_1,
'team_squad_2': team_squad_2,
'format_id': match['format_id'],
'matchtype_id': match['matchtype_id'],
'result': row_result,
'score_id': match['score_id'],
'country_id': match['country_id'],
'mom': match['mom'],
'match_type': match_type,
'format_name': format_name,
'format_overs': format_overs,
'format_innings': format_innings,
'matchtype_name': matchtype_name,
'description': match['description']
}
data = json.dumps({
'success': True,
'data': obj
},
default=default)
return json.loads(data), 200
else:
return {
'success': False,
'message': 'match not found'
}, 404
except Exception as e:
app.log.exception(e)
return {'success': False, 'message': "SERVER/DB error"}, 500
def get(self):
try:
args = request.args
get_curr_inng = app.redis.get("match:" + str(args['matchid']) +
":innings")
get_inng = json.loads(get_curr_inng)
# postgres db
query_playerscorecard = """
SELECT * FROM PLAYERSCORECARD WHERE MATCH_ID = %s AND INNINGS = %s ORDER BY ID desc limit 1
"""
params = (args['matchid'], get_inng)
row_playerscorecard = readSQL(query_playerscorecard, params)
if row_playerscorecard:
del_playerscorecard = """
DELETE FROM PLAYERSCORECARD WHERE ID = %s
"""
params = (row_playerscorecard['id'], )
del_record = writeSQL(del_playerscorecard, params)
prv_playerscorecard = """
SELECT * FROM PLAYERSCORECARD WHERE ID = %s AND MATCH_ID = %s
"""
prv_id = row_playerscorecard['id'] - 1
params = (prv_id, args['matchid'])
prv_record = readSQL(prv_playerscorecard, params)
# ball_id = prv_playerscorecard['ball_id']
if prv_record and 'team_a_over' in prv_record and 'team_b_over' in prv_record:
team_a_over = prv_record['team_a_over']
team_b_over = prv_record['team_b_over']
else:
team_a_over = "0.0"
team_b_over = "0.0"
if del_record:
#redis
if get_inng == 1:
over = team_a_over
else:
over = team_b_over
curr_key = "livescorecard:" + str(
args['matchid']) + ":current:" + str(get_inng)
com_key = "list:" + str(
args['matchid']) + ":" + str(get_inng)
curr_livecard = app.redis.get(curr_key)
key_info = json.loads(curr_livecard)
get_list = app.redis.lrange(com_key, 0, -1)
count_len = app.redis.llen(com_key) - 3
for key in get_list:
actual_key = key
splited_key = key.split(':')
if (splited_key[3] == 'manual' and math.floor(
float(splited_key[4])) == key_info['ball']):
app.redis.lrem(com_key, count_len, actual_key)
elif (splited_key[3].isdigit() and math.floor(
float(splited_key[3])) == key_info['ball']):
app.redis.lrem(com_key, count_len, actual_key)
count_len = count_len - 1
key_info['over'] = str(over)
key_info['ball'] = key_info['ball'] - 1
app.redis.set(curr_key, json.dumps(key_info))
return {
'success': True,
'message': 'sucessfully deleted the last record'
}, 200
else:
return {
'success': False,
'message': 'no record to delete'
}, 200
except Exception as e:
print(e)
app.log.exception(e)
return {'success': False, 'message': "SERVER/DB error"}, 500
def put(self):
parser = reqparse.RequestParser(bundle_errors=True)
parser.add_argument('id',
type=str,
required=True,
help="match id cannot be missing!",
location='json')
parser.add_argument('name',
type=str,
required=True,
help="Name of the match cannot be missing!",
location='json')
parser.add_argument('date',
type=str,
required=True,
help="Date cannot be missing!",
location='json')
parser.add_argument('venue',
type=str,
required=True,
help="Venue cannot be missing!",
location='json')
parser.add_argument('format',
type=int,
required=True,
help="Format cannot be missing!",
location='json')
parser.add_argument('team_squad_1', type=list, location='json')
parser.add_argument('team_squad_2', type=list, location='json')
parser.add_argument('team_a',
type=int,
required=True,
help="Team A cannot be missing!",
location='json')
parser.add_argument('team_b',
type=int,
required=True,
help="Team B cannot be missing!",
location='json')
parser.add_argument('match_type',
type=int,
required=True,
help="Match Type cannot be missing!",
location='json')
parser.add_argument('country',
required=True,
type=int,
help="Country cannot be missing!",
location='json')
parser.add_argument('match_status',
type=str,
required=True,
location='json')
parser.add_argument('description',
type=str,
required=True,
help="Description cannot be missing!",
location='json')
args = parser.parse_args()
try:
#get format 'id' for the match
row_format = getMatchFormat(args)
if row_format is None:
return {'success': False, 'message': 'format not found'}, 404
#get match type 'id' for the match
row_match_type = getMatchType(args)
if row_match_type is None:
return {
'success': False,
'message': 'match type not found'
}, 404
#get country 'id' for the match
row_country = getCountry(args)
if row_country is None:
return {'success': False, 'message': 'country not found'}, 404
#get team squad ids for the match
try:
if args and ('team_squad_1' in args and args['team_squad_1']):
query_squad = """
SELECT * FROM SQUAD WHERE ID = (SELECT SQUAD_ID FROM MATCH WHERE ID = %s)
"""
params = (args['id'], )
row_squad = readSQL(query_squad, params)
# delete team squad
query_delete_teamsquad = """
DELETE FROM TEAMSQUAD WHERE T_ID_1 = %s
"""
params = (row_squad['team_squad_1'], )
writeSQL(query_delete_teamsquad, params)
# insert team 1 players in team squad
for player in args['team_squad_1']:
query_team_squad_1 = """
INSERT INTO TEAMSQUAD (PLAYER_ID, TEAM_ID, T_ID_1, T_ID_2, SELECTED, POSITION, PLAYER_IN)
VALUES (%s, %s, %s, %s, %s, %s, %s)
"""
params = (player['player'], player['team'],
row_squad['team_squad_1'], None,
player['status'], player['position'],
player['status'])
writeSQL(query_team_squad_1, params)
if args and ('team_squad_2' in args and args['team_squad_2']):
query_squad_2 = """
SELECT * FROM SQUAD WHERE ID = (SELECT SQUAD_ID FROM MATCH WHERE ID = %s)
"""
params = (args['id'], )
row_squad_2 = readSQL(query_squad_2, params)
# delete team squad
query_delete_teamsquad_2 = """
DELETE FROM TEAMSQUAD WHERE T_ID_2 = %s
"""
params = (row_squad_2['team_squad_2'], )
writeSQL(query_delete_teamsquad_2, params)
# insert team 2 players in team squad
for player in args['team_squad_2']:
query_team_squad_2 = """
INSERT INTO TEAMSQUAD (PLAYER_ID, TEAM_ID, T_ID_1, T_ID_2, SELECTED, POSITION, PLAYER_IN)
VALUES (%s, %s, %s, %s, %s, %s, %s)
"""
params = (player['player'], player['team'], None,
row_squad['team_squad_2'], player['status'],
player['position'], player['status'])
writeSQL(query_team_squad_2, params)
except Exception as e:
app.log.exception(e)
return {'success': False, 'message': "SERVER/DB error"}, 500
#match table insertion
try:
query = """
UPDATE MATCH SET NAME = %s, DATE = %s, VENUE = %s, TEAM_A = %s, TEAM_B = %s, FORMAT_ID = %s, MATCHTYPE_ID = %s, COUNTRY_ID = %s, DESCRIPTION = %s WHERE ID = %s
"""
params = (args['name'], args['date'], args['venue'],
args['team_a'], args['team_b'], row_format['id'],
row_match_type['id'], row_country['id'],
args['description'], args['id'])
count = writeSQL(query, params)
if count:
return {
'success': True,
'message': 'match is updated'
}, 200
except Exception as e:
app.log.exception(e)
return {'success': False, 'message': "SERVER/DB error"}, 500
except Exception as e:
app.log.exception(e)
return {'success': False, 'message': "SERVER/DB error"}, 500
