From 8a701be6a17fa885ce331267769186b65e0840ef Mon Sep 17 00:00:00 2001 From: Tom Stellard Date: Mon, 8 Mar 2021 20:31:36 -0800 Subject: [PATCH] Complete json serialization support for all Bygfoot objects --- src/json_interface.c | 10 +- src/json_serialize.c | 1357 ++++++++++++++++++++++++++++++++++++++++-- src/json_serialize.h | 290 ++++++++- 3 files changed, 1603 insertions(+), 54 deletions(-) diff --git a/src/json_interface.c b/src/json_interface.c index 84c0e583..22f7afbe 100644 --- a/src/json_interface.c +++ b/src/json_interface.c @@ -16,6 +16,7 @@ static int bygfoot_json_do_commands(Bygfoot *bygfoot, const json_object *command static int bygfoot_json_do_add_user(Bygfoot *bygfoot, const json_object *args); static struct json_object *bygfoot_json_call_load_bygfoot(Bygfoot *bygfoot, const json_object *args); static struct json_object *bygfoot_json_call_save_bygfoot(Bygfoot *bygfoot, const json_object *args); +static struct json_object *bygfoot_json_call_dump_bygfoot(Bygfoot *bygfoot, const json_object *args); static struct json_object *bygfoot_json_call_add_country(Bygfoot *bygfoot, const json_object *args); static struct json_object *bygfoot_json_call_add_user(Bygfoot *bygfoot, const json_object *args); static struct json_object *bygfoot_json_call_start_bygfoot(Bygfoot *bygfoot, const json_object *args); @@ -104,6 +105,7 @@ static int bygfoot_json_do_commands(Bygfoot *bygfoot, const json_object *command } json_funcs[] = { { "load_bygfoot", bygfoot_json_call_load_bygfoot }, { "save_bygfoot", bygfoot_json_call_save_bygfoot }, + { "dump_bygfoot", bygfoot_json_call_dump_bygfoot }, { "add_country", bygfoot_json_call_add_country }, { "add_user", bygfoot_json_call_add_user }, { "start_bygfoot", bygfoot_json_call_start_bygfoot }, @@ -215,6 +217,12 @@ bygfoot_json_call_save_bygfoot(Bygfoot *bygfoot, const json_object *args) return json_object_new_object(); } +static json_object * +bygfoot_json_call_dump_bygfoot(Bygfoot *bygfoot, const json_object *args) +{ + return bygfoot_json_serialize_bygfoot(bygfoot); +} + static json_object * bygfoot_json_call_add_country(Bygfoot *bygfoot, const json_object *args) { @@ -462,7 +470,7 @@ bygfoot_json_call_get_cups(Bygfoot *bygfoot, const json_object *args) for (i = 0; i < country.cups->len; i++) { const Cup *cup = &g_array_index(country.cups, Cup, i); - json_object_array_add(cups_obj, bygfoot_json_serialize_cup(cup, NULL)); + json_object_array_add(cups_obj, bygfoot_json_serialize_cup(cup)); } return cups_obj; diff --git a/src/json_serialize.c b/src/json_serialize.c index b671767f..32940a83 100644 --- a/src/json_serialize.c +++ b/src/json_serialize.c @@ -18,27 +18,78 @@ #include #include +#include "variables.h" #include "json_serialize.h" #include "league_struct.h" +static json_object * +serialize_string(const gchar * string) +{ + if (!string) + return NULL; + + return json_object_new_string(string); +} + static void -serialize_gchar_array_callback(gpointer string, gpointer user_data) +serialize_gchar_ptr_array_callback(gpointer string, gpointer user_data) { struct json_object *obj = (struct json_object*)user_data; - json_object_array_add(obj, json_object_new_string(string)); + json_object_array_add(obj, serialize_string(string)); } static struct json_object* -serialize_gchar_array(GPtrArray* ptr_array) +serialize_gchar_ptr_array(GPtrArray* ptr_array) { struct json_object *array_obj = json_object_new_array_ext(ptr_array->len); int i; - g_ptr_array_foreach(ptr_array, serialize_gchar_array_callback, array_obj); + g_ptr_array_foreach(ptr_array, serialize_gchar_ptr_array_callback, array_obj); return array_obj; } +static json_object * +serialize_gchar_array(gchar *const *array, gint len) +{ + json_object *array_obj = json_object_new_array_ext(len); + gint i; + + for (i = 0; i < len; i++) { + json_object_array_add(array_obj, serialize_string(array[i])); + } + return array_obj; +} + +static struct json_object * +serialize_int_array(const gint *array, gint len) +{ + json_object *array_obj = json_object_new_array_ext(len); + gint i; + + for (i = 0; i < len; i++) { + json_object_array_add(array_obj, json_object_new_int64(array[i])); + } + return array_obj; +} + +static json_object * +serialize_float_array(const float *array, gint len) +{ + json_object *array_obj = json_object_new_array_ext(len); + gint i; + + for (i = 0; i < len; i++) { + json_object_array_add(array_obj, json_object_new_double(array[i])); + } + return array_obj; +} + +static struct json_object * +serialize_int_garray(GArray *array) +{ + return serialize_int_array((const gint*)array->data, array->len); +} static GHashTable* fields_to_hash_table(gchar **fields) @@ -58,7 +109,7 @@ fields_to_hash_table(gchar **fields) struct json_object * bygfoot_json_serialize_country_list(GPtrArray *country_list) { - return serialize_gchar_array(country_list); + return serialize_gchar_ptr_array(country_list); } @@ -78,6 +129,254 @@ bygfoot_json_serialize_country_list(GPtrArray *country_list) #define SERIALIZE_OBJECT_FIELD(json_object, object, field, serialize_func) \ SERIALIZE_OBJECT_FIELD_FILTER(json_object, object, field, serialize_func, NULL) +#define SERIALIZE_GARRAY_FUNC_DEF(func, item_type, item_serialize_func) \ + json_object * \ + func(const GArray *garray) \ + { \ + json_object *array = json_object_new_array_ext(garray->len); \ + gint i; \ + for (i = 0; i < garray->len; i++) { \ + const item_type *item = &g_array_index(garray, item_type, i); \ + json_object_array_add(array, item_serialize_func(item)); \ + } \ + return array; \ + } + + +struct json_object * +bygfoot_json_serialize_bygfoot(const Bygfoot *bygfoot) +{ + struct json_object *bygfoot_obj = json_object_new_object(); + + #define SERIALIZE_BYGFOOT_FIELD(field, serialize_func) \ + json_object_object_add(bygfoot_obj, #field, serialize_func(field)); + + json_object_object_add(bygfoot_obj, "country", bygfoot_json_serialize_country(&country)); + SERIALIZE_BYGFOOT_FIELD(country_list, bygfoot_json_serialize_countries); + SERIALIZE_BYGFOOT_FIELD(users, bygfoot_json_serialize_users); + SERIALIZE_BYGFOOT_FIELD(season, json_object_new_int64); + SERIALIZE_BYGFOOT_FIELD(week, json_object_new_int64); + SERIALIZE_BYGFOOT_FIELD(week_round, json_object_new_int64); + SERIALIZE_BYGFOOT_FIELD(transfer_list, bygfoot_json_serialize_transfers); + SERIALIZE_BYGFOOT_FIELD(season_stats, bygfoot_json_serialize_season_stats); + SERIALIZE_BYGFOOT_FIELD(bets, bygfoot_json_serialize_bets); + SERIALIZE_BYGFOOT_FIELD(current_interest, json_object_new_double); + SERIALIZE_BYGFOOT_FIELD(jobs, bygfoot_json_serialize_jobs); + SERIALIZE_BYGFOOT_FIELD(job_teams, bygfoot_json_serialize_teams); + SERIALIZE_BYGFOOT_FIELD(cur_user, json_object_new_int64); + + return bygfoot_obj; +} + +json_object * +bygfoot_json_serialize_users(const GArray *users) +{ + json_object *users_array = json_object_new_array_ext(users->len); + gint i; + + for (i = 0 ; i < users->len; i++) { + const User *user = &g_array_index(users, User, i); + json_object_array_add(users_array, bygfoot_json_serialize_user(user)); + } + return users_array; +} + +struct json_object* +bygfoot_json_serialize_user(const User *user) +{ + struct json_object *user_obj = json_object_new_object(); + + #define SERIALIZE_USER_FIELD(field, serialize_func) \ + json_object_object_add(user_obj, #field, serialize_func(user->field)); + + SERIALIZE_USER_FIELD(name, serialize_string); + SERIALIZE_USER_FIELD(tm, bygfoot_json_serialize_team_ptr); + SERIALIZE_USER_FIELD(team_id, json_object_new_int64); + /* options: I don't think we need to save these, because they appear to + * be loaded from a file. */ + /* events: I don't think we need to save these, because they appear to + * be temporary */ + SERIALIZE_USER_FIELD(history, bygfoot_json_serialize_user_histories); + json_object_object_add(user_obj, "counters", serialize_int_array(user->counters, COUNT_USER_END)); + SERIALIZE_USER_FIELD(money, json_object_new_int64); + SERIALIZE_USER_FIELD(debt, json_object_new_int64); + SERIALIZE_USER_FIELD(money_in, bygfoot_json_serialize_user_money_in); + SERIALIZE_USER_FIELD(money_out, bygfoot_json_serialize_user_money_out); + SERIALIZE_USER_FIELD(debt_interest, json_object_new_double); + SERIALIZE_USER_FIELD(alr_start_week, json_object_new_int64); + SERIALIZE_USER_FIELD(alr_weekly_installment, json_object_new_int64); + SERIALIZE_USER_FIELD(scout, json_object_new_int64); + SERIALIZE_USER_FIELD(physio, json_object_new_int64); + SERIALIZE_USER_FIELD(live_game, bygfoot_json_serialize_live_game); + SERIALIZE_USER_FIELD(sponsor, bygfoot_json_serialize_user_sponsor); + SERIALIZE_USER_FIELD(youth_academy, bygfoot_json_serialize_youth_academy); + SERIALIZE_USER_FIELD(mmatches_file, serialize_string); + SERIALIZE_USER_FIELD(bets, bygfoot_json_serialize_user_bets); + SERIALIZE_USER_FIELD(default_team, serialize_int_garray); + SERIALIZE_USER_FIELD(default_structure, json_object_new_int64); + SERIALIZE_USER_FIELD(default_style, json_object_new_int64); + SERIALIZE_USER_FIELD(default_style, json_object_new_int64); + SERIALIZE_USER_FIELD(default_boost, json_object_new_int64); + + return user_obj; +} + +json_object * +bygfoot_json_serialize_user_bets(GArray * const *bets) +{ + json_object *bets_array = json_object_new_array_ext(2); + gint i; + + for (i = 0; i < 2; i++) { + const GArray *bets_user = bets[i]; + json_object *bets_user_array = json_object_new_array_ext(bets_user->len); + json_object_array_add(bets_array, bets_user_array); + int j; + for (j = 0; j < bets_user->len; j++) { + const BetUser *bet_user = &g_array_index(bets_user, BetUser, j); + json_object_array_add(bets_user_array, bygfoot_json_serialize_bet_user(bet_user)); + } + } + return bets_array; +} + +json_object * +bygfoot_json_serialize_user_sponsor(UserSponsor sponsor) +{ + json_object *sponsor_obj = json_object_new_object(); + + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(sponsor_obj, (&sponsor), field, serialize_func); + + json_object_object_add(sponsor_obj, "name", + json_object_new_string_len(sponsor.name->str, sponsor.name->len)); + SERIALIZE(benefit, json_object_new_int64); + SERIALIZE(contract, json_object_new_int64); + #undef SERIALIZE + + return sponsor_obj; +} + +json_object * +bygfoot_json_serialize_user_histories(const GArray *histories) +{ + json_object *history_array = json_object_new_array_ext(histories->len); + gint i; + + for (i = 0; i < histories->len; i++) { + const UserHistory *user_history = &g_array_index(histories, UserHistory, i); + json_object_array_add(history_array, + bygfoot_json_serialize_user_history(user_history)); + } + return history_array; +} + +json_object * +bygfoot_json_serialize_user_history(const UserHistory *history) +{ + json_object *history_obj = json_object_new_object(); + + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(history_obj, history, field, serialize_func); + + SERIALIZE(season, json_object_new_int64); + SERIALIZE(week, json_object_new_int64); + SERIALIZE(type, json_object_new_int64); + SERIALIZE(team_name, serialize_string); + json_object_object_add(history_obj, "string", serialize_gchar_array(history->string, 3)); + #undef SERIALIZE + + return history_obj; +} + +json_object * +bygfoot_json_serialize_user_money_in(const gint (*money_in)[5]) +{ + json_object *money_in_array = json_object_new_array_ext(2); + gint i; + + for (i = 0; i < 2; i++) { + json_object_array_add(money_in_array, + serialize_int_array(money_in[i], MON_IN_END)); + } + return money_in_array; +} + +json_object * +bygfoot_json_serialize_user_money_out(const gint (*money_out)[13]) +{ + json_object *money_out_array = json_object_new_array_ext(2); + gint i; + + for (i = 0; i < 2; i++) { + json_object_array_add(money_out_array, + serialize_int_array(money_out[i], MON_OUT_END)); + } + return money_out_array; +} + +json_object * +bygfoot_json_serialize_bet_user(const BetUser *bet_user) +{ + json_object *bet_user_obj = json_object_new_object(); + + #define SERIALIZE_FIELD(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(bet_user_obj, bet_user, field, serialize_func); + + SERIALIZE_FIELD(fix_id, json_object_new_int64); + SERIALIZE_FIELD(outcome, json_object_new_int64); + SERIALIZE_FIELD(wager, json_object_new_int64); + #undef SERIALIZE_FIELD +} + +json_object * +bygfoot_json_serialize_bets(GArray **bets) +{ + json_object *bets_array = json_object_new_array_ext(2); + gint i; + + for (i = 0; i < 2; i++) { + GArray *bet_match_array = bets[i]; + json_object *bet_match_array_obj = json_object_new_array_ext(bet_match_array->len); + json_object_array_add(bets_array, bet_match_array_obj); + gint j; + for (j = 0; j < bet_match_array->len; j++) { + const BetMatch *bet_match = &g_array_index(bet_match_array, BetMatch, j); + json_object_array_add(bet_match_array_obj, + bygfoot_json_serialize_bet_match(bet_match)); + } + } + return bets_array; +} + +json_object * +bygfoot_json_serialize_bet_match(const BetMatch *bet_match) +{ + json_object *bet_match_obj = json_object_new_object(); + + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(bet_match_obj, bet_match, field, serialize_func); + + SERIALIZE(fix_id, json_object_new_int64); + json_object_object_add(bet_match_obj, "odds", serialize_float_array(bet_match->odds, 3)); + #undef SERIALIZE + + return bet_match_obj; +} + +struct json_object * +bygfoot_json_serialize_countries(const GPtrArray *countries) +{ + struct json_object *countries_obj = json_object_new_array_ext(countries->len); + gint i; + + for (i = 0; i < countries->len; i++) { + const Country *country = g_ptr_array_index(countries, i); + json_object_array_add(countries_obj, bygfoot_json_serialize_country(country)); + } + return countries_obj; +} + struct json_object * bygfoot_json_serialize_country(const Country *country) { @@ -85,14 +384,14 @@ bygfoot_json_serialize_country(const Country *country) #define SERIALIZE_COUNTRY_FIELD(field, serialize_func) \ SERIALIZE_OBJECT_FIELD(country_obj, country, field, serialize_func) - SERIALIZE_COUNTRY_FIELD(name, json_object_new_string); - SERIALIZE_COUNTRY_FIELD(symbol, json_object_new_string); - SERIALIZE_COUNTRY_FIELD(sid, json_object_new_string); + SERIALIZE_COUNTRY_FIELD(name, serialize_string); + SERIALIZE_COUNTRY_FIELD(symbol, serialize_string); + SERIALIZE_COUNTRY_FIELD(sid, serialize_string); SERIALIZE_COUNTRY_FIELD(rating, json_object_new_int64); SERIALIZE_COUNTRY_FIELD(reserve_promotion_rules, json_object_new_int64); -// SERIALIZE_COUNTRY_FIELD(leagues, bygfoot_json_serialize_league_array); -// SERIALIZE_COUNTRY_FIELD(cups, bygfoot_json_serialize_cup_array); -// SERIALIZE_COUNTRY_FIELD(allcups, bygfoot_json_serialize_cup_ptr_array); + SERIALIZE_COUNTRY_FIELD(leagues, bygfoot_json_serialize_league_array); + SERIALIZE_COUNTRY_FIELD(cups, bygfoot_json_serialize_cups); + SERIALIZE_COUNTRY_FIELD(allcups, bygfoot_json_serialize_cup_ptrs); #undef SERIALIZE_COUNTRY_FIELD @@ -118,14 +417,165 @@ bygfoot_json_serialize_league(const League *league) { struct json_object *league_obj = json_object_new_object(); - #define SERIALIZE_LEAGUE_FIELD(field, serialize_func) \ + #define SERIALIZE(field, serialize_func) \ SERIALIZE_OBJECT_FIELD(league_obj, league, field, serialize_func); - SERIALIZE_LEAGUE_FIELD(name, json_object_new_string); - SERIALIZE_LEAGUE_FIELD(short_name, json_object_new_string); - SERIALIZE_LEAGUE_FIELD(sid, json_object_new_string); - SERIALIZE_LEAGUE_FIELD(symbol, json_object_new_string); - SERIALIZE_LEAGUE_FIELD(names_file, json_object_new_string); + SERIALIZE(name, serialize_string); + SERIALIZE(short_name, serialize_string); + SERIALIZE(sid, serialize_string); + SERIALIZE(symbol, serialize_string); + SERIALIZE(names_file, serialize_string); + SERIALIZE(prom_rel, bygfoot_json_serialize_prom_rel); + SERIALIZE(id, json_object_new_int64); + SERIALIZE(layer, json_object_new_int64); + SERIALIZE(first_week, json_object_new_int64); + SERIALIZE(week_gap, json_object_new_int64); + SERIALIZE(two_match_weeks, bygfoot_json_serialize_two_match_weeks); + SERIALIZE(round_robins, json_object_new_int64); + SERIALIZE(rr_breaks, serialize_int_garray); + SERIALIZE(yellow_red, json_object_new_int64); + SERIALIZE(average_talent, json_object_new_double); + SERIALIZE(teams, bygfoot_json_serialize_teams); + SERIALIZE(joined_leagues, bygfoot_json_serialize_joined_leagues); + SERIALIZE(tables, bygfoot_json_serialize_tables); + SERIALIZE(new_tables, bygfoot_json_serialize_new_tables); + SERIALIZE(fixtures, bygfoot_json_serialize_fixtures); + SERIALIZE(properties, serialize_gchar_ptr_array); + SERIALIZE(week_breaks, bygfoot_json_serialize_week_breaks); + json_object_object_add(league_obj, "stats", bygfoot_json_serialize_league_stat(&league->stats)); + SERIALIZE(skip_weeks_with, serialize_gchar_ptr_array); + #undef SERIALIZE + + return league_obj; +} + +json_object * +bygfoot_json_serialize_prom_rel(PromRel prom_rel) +{ + json_object *prom_rel_obj = json_object_new_object(); + + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(prom_rel_obj, (&prom_rel), field, serialize_func); + + SERIALIZE(elements, bygfoot_json_serialize_prom_rel_elements); + SERIALIZE(prom_games, bygfoot_json_serialize_prom_games_array); + #undef SERIALIZE + + return prom_rel_obj; +} + +SERIALIZE_GARRAY_FUNC_DEF(bygfoot_json_serialize_prom_rel_elements, + PromRelElement, + bygfoot_json_serialize_prom_rel_element); + +json_object * +bygfoot_json_serialize_prom_rel_element(const PromRelElement* element) +{ + json_object *element_obj = json_object_new_object(); + + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(element_obj, element, field, serialize_func); + + json_object_object_add(element_obj, "ranks", serialize_int_array(element->ranks, 2)); + SERIALIZE(from_table, json_object_new_int64); + SERIALIZE(dest_sid, serialize_string); + SERIALIZE(type, json_object_new_int64); + SERIALIZE(num_teams, json_object_new_int64); + #undef SERIALIZE + + return element_obj; +} + +SERIALIZE_GARRAY_FUNC_DEF(bygfoot_json_serialize_prom_games_array, + PromGames, + bygfoot_json_serialize_prom_games); + +json_object* +bygfoot_json_serialize_prom_games(const PromGames *prom_games) +{ + json_object *prom_games_obj = json_object_new_object(); + + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(prom_games_obj, prom_games, field, serialize_func); + + json_object_object_add(prom_games_obj, "ranks", serialize_int_array(prom_games->ranks, 2)); + SERIALIZE(dest_sid, serialize_string); + SERIALIZE(loser_sid, serialize_string); + SERIALIZE(number_of_advance, json_object_new_int64); + SERIALIZE(cup_sid, serialize_string); + #undef SERIALIZE + + return prom_games_obj; +} + +json_object * +bygfoot_json_serialize_two_match_weeks(GArray * const *two_match_weeks) +{ + json_object *two_match_weeks_array = json_object_new_array_ext(2); + gint i; + + for (i = 0; i < 2; i++) { + json_object_array_add(two_match_weeks_array, + serialize_int_garray(two_match_weeks[i])); + } + return two_match_weeks_array; +} + +SERIALIZE_GARRAY_FUNC_DEF(bygfoot_json_serialize_joined_leagues, + JoinedLeague, + bygfoot_json_serialize_joined_league); + +json_object * +bygfoot_json_serialize_joined_league(const JoinedLeague *league) +{ + json_object *league_obj = json_object_new_object(); + + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(league_obj, league, field, serialize_func); + + SERIALIZE(sid, serialize_string); + SERIALIZE(rr, json_object_new_int64); + #undef SERIALIZE + + return league_obj; +} + +SERIALIZE_GARRAY_FUNC_DEF(bygfoot_json_serialize_new_tables, + NewTable, + bygfoot_json_serialize_new_table); + +json_object * +bygfoot_json_serialize_new_table(const NewTable *table) +{ + json_object *table_obj = json_object_new_object(); + + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(table_obj, table, field, serialize_func); + + SERIALIZE(add_week, json_object_new_int64); + SERIALIZE(name, serialize_string); + #undef SERIALIZE + + return table_obj; +} + +SERIALIZE_GARRAY_FUNC_DEF(bygfoot_json_serialize_week_breaks, + WeekBreak, + bygfoot_json_serialize_week_break); + +json_object * +bygfoot_json_serialize_week_break(const WeekBreak *week_break) +{ + json_object *week_break_obj = json_object_new_object(); + + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(week_break_obj, week_break, field, serialize_func); + + SERIALIZE(week_number, json_object_new_int64); + SERIALIZE(length, json_object_new_int64); + #undef SERIALIZE + + return week_break_obj; } struct json_object * @@ -137,7 +587,7 @@ bygfoot_json_serialize_stadium(Stadium stadium, GHashTable *fields) #define SERIALIZE_STADIUM_FIELD(field, serialize_func) \ SERIALIZE_OBJECT_FIELD_FILTER(stadium_obj, stadium_ptr, field, serialize_func, fields); - SERIALIZE_STADIUM_FIELD(name, json_object_new_string); + SERIALIZE_STADIUM_FIELD(name, serialize_string); SERIALIZE_STADIUM_FIELD(capacity, json_object_new_int64); SERIALIZE_STADIUM_FIELD(average_attendance, json_object_new_int64); SERIALIZE_STADIUM_FIELD(possible_attendance, json_object_new_int64); @@ -147,6 +597,19 @@ bygfoot_json_serialize_stadium(Stadium stadium, GHashTable *fields) return stadium_obj; } +json_object * +bygfoot_json_serialize_teams(const GArray *teams) +{ + json_object *teams_array = json_object_new_array_ext(teams->len); + gint i; + + for (i = 0; i < teams->len; i++) { + Team *team = &g_array_index(teams, Team, i); + json_object_array_add(teams_array, bygfoot_json_serialize_team(team, NULL)); + } + return teams_array; +} + struct json_object * bygfoot_json_serialize_team(const Team *team, GHashTable *fields) { @@ -158,11 +621,11 @@ bygfoot_json_serialize_team(const Team *team, GHashTable *fields) #define SERIALIZE_TEAM_FIELD_STRUCT(field, serialize_func) \ SERIALIZE_OBJECT_FIELD_STRUCT(team_obj, team, field, serialize_func, fields); - SERIALIZE_TEAM_FIELD(name, json_object_new_string); - SERIALIZE_TEAM_FIELD(symbol, json_object_new_string); - SERIALIZE_TEAM_FIELD(names_file, json_object_new_string); - SERIALIZE_TEAM_FIELD(def_file, json_object_new_string); - SERIALIZE_TEAM_FIELD(strategy_sid, json_object_new_string); + SERIALIZE_TEAM_FIELD(name, serialize_string); + SERIALIZE_TEAM_FIELD(symbol, serialize_string); + SERIALIZE_TEAM_FIELD(names_file, serialize_string); + SERIALIZE_TEAM_FIELD(def_file, serialize_string); + SERIALIZE_TEAM_FIELD(strategy_sid, serialize_string); SERIALIZE_TEAM_FIELD(clid, json_object_new_int64); SERIALIZE_TEAM_FIELD(id, json_object_new_int64); SERIALIZE_TEAM_FIELD(structure, json_object_new_int64); @@ -171,8 +634,8 @@ bygfoot_json_serialize_team(const Team *team, GHashTable *fields) SERIALIZE_TEAM_FIELD(average_talent, json_object_new_double); SERIALIZE_TEAM_FIELD(luck, json_object_new_double); SERIALIZE_TEAM_FIELD_STRUCT(stadium, bygfoot_json_serialize_stadium); - //SERIALIZE_TEAM_FIELD_STRUCT(players, bygfoot_json_serialize_players); - SERIALIZE_TEAM_FIELD(first_team_sid, json_object_new_string); + SERIALIZE_TEAM_FIELD(players, bygfoot_json_serialize_players); + SERIALIZE_TEAM_FIELD(first_team_sid, serialize_string); SERIALIZE_TEAM_FIELD(first_team_id, json_object_new_int64); SERIALIZE_TEAM_FIELD(reserve_level, json_object_new_int64); @@ -188,19 +651,182 @@ serialize_team_pointers_callback(gpointer team, gpointer user_data) }; GHashTable *hash_table = fields_to_hash_table(fields); struct json_object *obj = (struct json_object*)user_data; - json_object_array_add(obj, bygfoot_json_serialize_team((Team*)team, hash_table)); + json_object_array_add(obj, bygfoot_json_serialize_team_ptr((Team*)team)); } struct json_object * bygfoot_json_serialize_team_ptrs(GPtrArray *team_ptrs, GHashTable *fields) { - struct json_object *array_obj = json_object_new_array_ext(team_ptrs->len); + struct json_object *array_obj; + + if (!team_ptrs) + return NULL; + + array_obj = json_object_new_array_ext(team_ptrs->len); g_ptr_array_foreach(team_ptrs, serialize_team_pointers_callback, array_obj); return array_obj; } + +struct json_object * +bygfoot_json_serialize_team_ptr(const Team *team) +{ + gchar *fields[] = { + "name", + "id" + }; + GHashTable *hash_table = fields_to_hash_table(fields); + return bygfoot_json_serialize_team(team, hash_table); +} + +json_object * +bygfoot_json_serialize_youth_academy(const YouthAcademy youth_academy) +{ + json_object *youth_academy_obj = json_object_new_object(); + + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(youth_academy_obj, (&youth_academy), field, serialize_func) + + SERIALIZE(tm, bygfoot_json_serialize_team_ptr); + SERIALIZE(pos_pref, json_object_new_int64); + SERIALIZE(coach, json_object_new_int64); + SERIALIZE(percentage, json_object_new_int64); + SERIALIZE(av_coach, json_object_new_double); + SERIALIZE(av_percentage, json_object_new_double); + SERIALIZE(counter_youth, json_object_new_double); + SERIALIZE(players, bygfoot_json_serialize_players); + + #undef SERIALIZE + + return youth_academy_obj; +} + +json_object * +bygfoot_json_serialize_players(const GArray *players) +{ + json_object *players_array = json_object_new_array_ext(players->len); + gint i; + + for (i = 0; i < players->len; i++) { + const Player *player = &g_array_index(players, Player, i); + json_object_array_add(players_array, bygfoot_json_serialize_player(player)); + } + return players_array; +} + +json_object * +bygfoot_json_serialize_player(const Player *player) +{ + json_object *player_obj = json_object_new_object(); + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(player_obj, player, field, serialize_func); + + SERIALIZE(name, serialize_string); + SERIALIZE(pos, json_object_new_int64); + SERIALIZE(cpos, json_object_new_int64); + SERIALIZE(health, json_object_new_int64); + SERIALIZE(recovery, json_object_new_int64); + SERIALIZE(id, json_object_new_int64); + SERIALIZE(value, json_object_new_int64); + SERIALIZE(wage, json_object_new_int64); + SERIALIZE(offers, json_object_new_int64); + SERIALIZE(streak, json_object_new_int64); + SERIALIZE(card_status, json_object_new_int64); + SERIALIZE(skill, json_object_new_double); + SERIALIZE(cskill, json_object_new_double); + SERIALIZE(talent, json_object_new_double); + json_object_object_add(player_obj, "etal", serialize_float_array(player->etal, QUALITY_END)); + SERIALIZE(fitness, json_object_new_double); + SERIALIZE(lsu, json_object_new_double); + SERIALIZE(age, json_object_new_double); + SERIALIZE(peak_age, json_object_new_double); + SERIALIZE(peak_region, json_object_new_double); + SERIALIZE(contract, json_object_new_double); + SERIALIZE(streak_prob, json_object_new_double); + SERIALIZE(streak_count, json_object_new_double); + SERIALIZE(participation, json_object_new_boolean); + SERIALIZE(games_goals, bygfoot_json_serialize_games_goals_array); + SERIALIZE(cards, bygfoot_json_serialize_cards); + json_object_object_add(player_obj, "career", serialize_int_array(player->career, PLAYER_VALUE_END)); + SERIALIZE(team, bygfoot_json_serialize_team_ptr); + #undef SERIALIZE + + return player_obj; +} + +json_object * +bygfoot_json_serialize_player_ptr(const Player *player) +{ + json_object *player_obj = json_object_new_object(); + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(player_obj, player, field, serialize_func); + + SERIALIZE(name, serialize_string); + SERIALIZE(id, json_object_new_int64); + #undef SERIALIZE + + return player_obj; +} + +json_object * +bygfoot_json_serialize_cards(const GArray *cards) +{ + json_object *cards_array = json_object_new_array_ext(cards->len); + gint i; + + for (i = 0; i < cards->len; i++) { + const PlayerCard *card = &g_array_index(cards, PlayerCard, i); + json_object_array_add(cards_array, bygfoot_json_serialize_player_card(card)); + } + return cards_array; +} + +json_object * +bygfoot_json_serialize_player_card(const PlayerCard *card) +{ + json_object *card_obj = json_object_new_object(); + + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(card_obj, card, field, serialize_func); + + SERIALIZE(clid, json_object_new_int64); + SERIALIZE(yellow, json_object_new_int64); + SERIALIZE(red, json_object_new_int64); + #undef SERIALIZE + + return card_obj; +} + +json_object * +bygfoot_json_serialize_games_goals_array(const GArray *games_goals) +{ + json_object *games_goals_array = json_object_new_array_ext(games_goals->len); + gint i; + for (i = 0; i < games_goals->len; i++) { + const PlayerGamesGoals *stats = &g_array_index(games_goals,PlayerGamesGoals, i); + json_object_array_add(games_goals_array, bygfoot_json_serialize_games_goals(stats)); + } + return games_goals_array; +} + +json_object * +bygfoot_json_serialize_games_goals(const PlayerGamesGoals *games_goals) +{ + json_object *games_goals_obj = json_object_new_object(); + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(games_goals_obj, games_goals, field, serialize_func); + + SERIALIZE(clid, json_object_new_int64); + SERIALIZE(games, json_object_new_int64); + SERIALIZE(goals, json_object_new_int64); + SERIALIZE(shots, json_object_new_int64); + #undef SERIALIZE + + return games_goals_obj; +} + struct json_object * bygfoot_json_serialize_cup_round(const CupRound *round, GHashTable *fields) @@ -212,7 +838,7 @@ bygfoot_json_serialize_cup_round(const CupRound *round, #define SERIALIZE_CUP_ROUND_FIELD_STRUCT(field, serialize_func) \ SERIALIZE_OBJECT_FIELD_STRUCT(cup_round_obj, round, field, serialize_func, fields); - SERIALIZE_CUP_ROUND_FIELD(name, json_object_new_string); + SERIALIZE_CUP_ROUND_FIELD(name, serialize_string); SERIALIZE_CUP_ROUND_FIELD(home_away, json_object_new_boolean); SERIALIZE_CUP_ROUND_FIELD(replay, json_object_new_int64); SERIALIZE_CUP_ROUND_FIELD(neutral, json_object_new_boolean); @@ -221,15 +847,15 @@ bygfoot_json_serialize_cup_round(const CupRound *round, SERIALIZE_CUP_ROUND_FIELD(round_robin_number_of_advance, json_object_new_int64); SERIALIZE_CUP_ROUND_FIELD(round_robin_number_of_best_advance, json_object_new_int64); SERIALIZE_CUP_ROUND_FIELD(round_robins, json_object_new_int64); - //SERIALIZE_CUP_ROUND_FIELD(rr_breaks, bygfoot_json_serialize_int_array); + SERIALIZE_CUP_ROUND_FIELD(rr_breaks, serialize_int_garray); SERIALIZE_CUP_ROUND_FIELD(new_teams, json_object_new_int64); SERIALIZE_CUP_ROUND_FIELD(byes, json_object_new_int64); SERIALIZE_CUP_ROUND_FIELD(delay, json_object_new_int64); - //SERIALIZE_CUP_ROUND_FIELD(two_match_weeks, bygfoot_json_serialize_int_int_array); + SERIALIZE_CUP_ROUND_FIELD(two_match_weeks, bygfoot_json_serialize_two_match_weeks); SERIALIZE_CUP_ROUND_FIELD_STRUCT(team_ptrs, bygfoot_json_serialize_team_ptrs); - //SERIALIZE_CUP_ROUND_FIELD(choose_teams, bygfoot_json_serialize_choose_teams); - //SERIALIZE_CUP_ROUND_FIELD(tables, bygfoot_json_serialize_tables); - //SERIALIZE_CUP_ROUND_FIELD(waits, bygfoot_json_seriialize_waits); + SERIALIZE_CUP_ROUND_FIELD(choose_teams, bygfoot_json_serialize_cup_choose_teams); + SERIALIZE_CUP_ROUND_FIELD(tables, bygfoot_json_serialize_tables); + SERIALIZE_CUP_ROUND_FIELD(waits, bygfoot_json_serialize_cup_round_waits); return cup_round_obj; } @@ -249,20 +875,24 @@ bygfoot_json_serialize_cup_rounds(const GArray *rounds, return rounds_array_obj; } +SERIALIZE_GARRAY_FUNC_DEF(bygfoot_json_serialize_cups, + Cup, + bygfoot_json_serialize_cup); + struct json_object * -bygfoot_json_serialize_cup(const Cup *cup, GHashTable *fields) +bygfoot_json_serialize_cup(const Cup *cup) { struct json_object *cup_obj = json_object_new_object(); #define SERIALIZE_CUP_FIELD(field, serialize_func) \ - SERIALIZE_OBJECT_FIELD_FILTER(cup_obj, cup, field, serialize_func, fields); + SERIALIZE_OBJECT_FIELD(cup_obj, cup, field, serialize_func); #define SERIALIZE_CUP_FIELD_STRUCT(field, serialize_func) \ - SERIALIZE_OBJECT_FIELD_STRUCT(cup_obj, cup, field, serialize_func, fields); + SERIALIZE_OBJECT_FIELD_STRUCT(cup_obj, cup, field, serialize_func, NULL); - SERIALIZE_CUP_FIELD(name, json_object_new_string); - SERIALIZE_CUP_FIELD(short_name, json_object_new_string); - SERIALIZE_CUP_FIELD(symbol, json_object_new_string); - SERIALIZE_CUP_FIELD(sid, json_object_new_string); + SERIALIZE_CUP_FIELD(name, serialize_string); + SERIALIZE_CUP_FIELD(short_name, serialize_string); + SERIALIZE_CUP_FIELD(symbol, serialize_string); + SERIALIZE_CUP_FIELD(sid, serialize_string); SERIALIZE_CUP_FIELD(id, json_object_new_int64); SERIALIZE_CUP_FIELD(group, json_object_new_int64); SERIALIZE_CUP_FIELD(last_week, json_object_new_int64); @@ -272,13 +902,648 @@ bygfoot_json_serialize_cup(const Cup *cup, GHashTable *fields) SERIALIZE_CUP_FIELD(talent_diff, json_object_new_double); SERIALIZE_CUP_FIELD(next_fixture_update_week, json_object_new_int64); SERIALIZE_CUP_FIELD(next_fixture_update_week_round, json_object_new_int64); - SERIALIZE_CUP_FIELD(properties, serialize_gchar_array); + SERIALIZE_CUP_FIELD(properties, serialize_gchar_ptr_array); SERIALIZE_CUP_FIELD_STRUCT(rounds, bygfoot_json_serialize_cup_rounds); -// SERIALIZE_CUP_FIELD(bye + SERIALIZE_CUP_FIELD_STRUCT(bye, bygfoot_json_serialize_team_ptrs); SERIALIZE_CUP_FIELD_STRUCT(teams, bygfoot_json_serialize_team_ptrs); - SERIALIZE_CUP_FIELD(team_names, serialize_gchar_array); -// SERIALIZE_CUP_FIELD(fixtures, -// SERIALIZE_CUP_FIELD(week_breaks -// SERIALIZE_CUP_FIELD(skip_weeks_with + SERIALIZE_CUP_FIELD(team_names, serialize_gchar_ptr_array); + SERIALIZE_CUP_FIELD(fixtures, bygfoot_json_serialize_fixtures); + SERIALIZE_CUP_FIELD(week_breaks, bygfoot_json_serialize_week_breaks); + SERIALIZE_CUP_FIELD(skip_weeks_with, serialize_gchar_ptr_array); return cup_obj; } + +json_object * +bygfoot_json_serialize_cup_ptrs(GPtrArray *cups) +{ + struct json_object *cups_array = json_object_new_array_ext(cups->len); + gint i; + + for (i = 0; i < cups->len; i++) { + const Cup *cup = g_ptr_array_index(cups, i); + json_object_array_add(cups_array, bygfoot_json_serialize_cup_ptr(cup)); + } + return cups_array; +} + +json_object * +bygfoot_json_serialize_cup_ptr(const Cup *cup) +{ + struct json_object *cup_obj = json_object_new_object(); + + json_object_object_add(cup_obj, "sid", serialize_string(cup->sid)); + json_object_object_add(cup_obj, "id", json_object_new_int64(cup->id)); + return cup_obj; +} + +SERIALIZE_GARRAY_FUNC_DEF(bygfoot_json_serialize_cup_choose_teams, + CupChooseTeam, + bygfoot_json_serialize_cup_choose_team); + +json_object * +bygfoot_json_serialize_cup_choose_team(const CupChooseTeam *choose_team) +{ + json_object *choose_team_array = json_object_new_array(); + const CupChooseTeam *iter; + + for (iter = choose_team; iter; iter = iter->next) { + json_object *choose_team_obj = json_object_new_object(); + json_object_array_add(choose_team_array, choose_team_obj); + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(choose_team_obj, iter, field, serialize_func); + + SERIALIZE(sid, serialize_string); + SERIALIZE(number_of_teams, json_object_new_int64); + SERIALIZE(from_table, json_object_new_int64); + SERIALIZE(start_idx, json_object_new_int64); + SERIALIZE(end_idx, json_object_new_int64); + SERIALIZE(randomly, json_object_new_boolean); + SERIALIZE(generate, json_object_new_boolean); + SERIALIZE(preload, json_object_new_boolean); + SERIALIZE(optional, json_object_new_boolean); + SERIALIZE(previous_season, json_object_new_boolean); + #undef SERIALIZE + } + return choose_team_array; +} + +SERIALIZE_GARRAY_FUNC_DEF(bygfoot_json_serialize_cup_round_waits, + CupRoundWait, + bygfoot_json_serialize_cup_round_wait); + +json_object * +bygfoot_json_serialize_cup_round_wait(const CupRoundWait *wait) +{ + json_object *wait_obj = json_object_new_object(); + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(wait_obj, wait, field, serialize_func); + + SERIALIZE(cup_sid, serialize_string); + SERIALIZE(cup_round, json_object_new_int64); + #undef SERIALIZE + + return wait_obj; +} + +json_object * +bygfoot_json_serialize_transfers(const GArray *transfers) +{ + json_object *transfers_array = json_object_new_array_ext(transfers->len); + gint i; + + for (i = 0; i < transfers->len; i++) { + const Transfer *transfer = &g_array_index(transfers, Transfer, i); + json_object_array_add(transfers_array, + bygfoot_json_serialize_transfer(transfer)); + } + return transfers_array; +} + +struct json_object * +bygfoot_json_serialize_transfer(const Transfer *transfer) +{ + struct json_object *transfer_obj = json_object_new_object(); + + #define SERIALIZE_TRANSFER_FIELD(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(transfer_obj, transfer, field, serialize_func); + + SERIALIZE_TRANSFER_FIELD(tm, bygfoot_json_serialize_team_ptr); + SERIALIZE_TRANSFER_FIELD(id, json_object_new_int64); + SERIALIZE_TRANSFER_FIELD(time, json_object_new_int64); + json_object_object_add(transfer_obj, "fee", serialize_int_array(transfer->fee, QUALITY_END)); + json_object_object_add(transfer_obj, "wage", serialize_int_array(transfer->wage, QUALITY_END)); + SERIALIZE_TRANSFER_FIELD(offers, bygfoot_json_serialize_transfer_offers); + + return transfer_obj; +} + +struct json_object * +bygfoot_json_serialize_transfer_offers(const GArray *offers) +{ + struct json_object *offers_array_obj = + json_object_new_array_ext(offers->len); + gint i; + + for (i = 0; i < offers->len; i++) { + const TransferOffer *offer = &g_array_index(offers, TransferOffer, i); + json_object_array_add(offers_array_obj, + bygfoot_json_serialize_transfer_offer(offer)); + } + return offers_array_obj; +} + +struct json_object * +bygfoot_json_serialize_transfer_offer(const TransferOffer *offer) +{ + + struct json_object *offer_obj = json_object_new_object(); + + #define SERIALIZE_TRANSFER_OFFER_FIELD(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(offer_obj, offer, field, serialize_func); + + SERIALIZE_TRANSFER_OFFER_FIELD(tm, bygfoot_json_serialize_team_ptr); + SERIALIZE_TRANSFER_OFFER_FIELD(fee, json_object_new_int64); + SERIALIZE_TRANSFER_OFFER_FIELD(wage, json_object_new_int64); + SERIALIZE_TRANSFER_OFFER_FIELD(status, json_object_new_int64); +} + +json_object* +bygfoot_json_serialize_fixture_ptr(const Fixture *fixture) +{ + struct json_object *fixture_obj = json_object_new_object(); + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(fixture_obj, fixture, field, serialize_func); + + SERIALIZE(id, json_object_new_int64); + #undef SERIALIZE + + return fixture_obj; +} + +json_object * +bygfoot_json_serialize_live_game(LiveGame live_game) +{ + struct json_object *live_game_obj; + + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(live_game_obj, (&live_game), field, serialize_func); + + SERIALIZE(fix, bygfoot_json_serialize_fixture_ptr); + SERIALIZE(fix_id, json_object_new_int64); + json_object_object_add(live_game_obj, "team_names", serialize_gchar_array(live_game.team_names, 2)); + SERIALIZE(attendance, json_object_new_int64); + json_object_object_add(live_game_obj, "subs_left", serialize_int_array(live_game.subs_left, 2)); + SERIALIZE(started_game, json_object_new_int64); + SERIALIZE(stadium_event, json_object_new_int64); + SERIALIZE(team_values, bygfoot_json_serialize_live_game_team_values); + SERIALIZE(home_advantage, json_object_new_double); + SERIALIZE(units, bygfoot_json_serialize_live_game_units); + SERIALIZE(stats, bygfoot_json_serialize_live_game_stats); + SERIALIZE(team_state, bygfoot_json_serialize_live_game_team_state_array); + SERIALIZE(action_ids, bygfoot_json_serialize_live_game_action_ids); + #undef SERIALIZE + + return live_game_obj; +} + +json_object * +bygfoot_json_serialize_live_game_team_values(const gfloat (*team_values)[4]) +{ + json_object *team_values_array = json_object_new_array_ext(2); + gint i; + + for (i = 0; i < 2; i++) { + const float *values = team_values[i]; + json_object_array_add(team_values_array, serialize_float_array(values, GAME_TEAM_VALUE_END)); + } + return team_values_array; +} + +json_object * +bygfoot_json_serialize_live_game_units(const GArray *units) +{ + json_object *units_array = json_object_new_array_ext(units->len); + gint i; + + for (i = 0; i < units->len; i++) { + const LiveGameUnit *unit = &g_array_index(units, LiveGameUnit, i); + json_object_array_add(units_array, bygfoot_json_serialize_live_game_unit(unit)); + } + return units_array; +} + +json_object * +bygfoot_json_serialize_live_game_unit(const LiveGameUnit *unit) +{ + json_object *unit_obj = json_object_new_object(); + + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(unit_obj, unit, field, serialize_func); + + SERIALIZE(possession, json_object_new_int64); + SERIALIZE(area, json_object_new_int64); + SERIALIZE(minute, json_object_new_int64); + SERIALIZE(time, json_object_new_int64); + json_object_object_add(unit_obj, "result", serialize_int_array(unit->result, 2)); + SERIALIZE(event, bygfoot_json_serialize_live_game_event); + #undef SERIALIZE + + return unit_obj; +} + +json_object * +bygfoot_json_serialize_live_game_event(LiveGameEvent event) +{ + json_object *event_obj = json_object_new_object(); + + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(event_obj, (&event), field, serialize_func); + + SERIALIZE(type, json_object_new_int64); + SERIALIZE(verbosity, json_object_new_int64); + SERIALIZE(team, json_object_new_int64); + SERIALIZE(player, json_object_new_int64); + SERIALIZE(player2, json_object_new_int64); + SERIALIZE(commentary, serialize_string); + SERIALIZE(commentary_id, json_object_new_int64); + #undef SERIALIZE + + return event_obj; + +} + +json_object * +bygfoot_json_serialize_live_game_stats(LiveGameStats stats) +{ + json_object *stats_obj = json_object_new_object(); + + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(stats_obj, (&stats), field, serialize_func); + + SERIALIZE(possession, json_object_new_double); + SERIALIZE(values, bygfoot_json_serialize_live_game_stats_values); + SERIALIZE(players, bygfoot_json_serialize_live_game_stats_players); + #undef SERIALIZE + + return stats_obj; +} + +json_object * +bygfoot_json_serialize_live_game_stats_values(gint (*values)[9]) +{ + static const struct key_index { + const gchar *key; + gint index; + } value_fields[] = { + { "goals_regular", LIVE_GAME_STAT_VALUE_GOALS_REGULAR }, + { "shots", LIVE_GAME_STAT_VALUE_SHOTS }, + { "shot_percentage", LIVE_GAME_STAT_VALUE_SHOT_PERCENTAGE }, + { "possession", LIVE_GAME_STAT_VALUE_POSSESSION }, + { "penalties", LIVE_GAME_STAT_VALUE_PENALTIES }, + { "fouls", LIVE_GAME_STAT_VALUE_FOULS }, + { "cards", LIVE_GAME_STAT_VALUE_CARDS }, + { "reds", LIVE_GAME_STAT_VALUE_REDS } , + { "injuries", LIVE_GAME_STAT_VALUE_INJURIES }, + { NULL, LIVE_GAME_STAT_VALUE_END } + }; + + json_object *values_array = json_object_new_array_ext(2); + gint i; + + for (i = 0; i < 2; i++) { + const struct key_index *iter; + json_object *value_obj = json_object_new_object(); + json_object_array_add(values_array, value_obj); + for (iter = value_fields; iter; iter++) { + json_object_object_add(value_obj, iter->key, json_object_new_int64(values[i][iter->index])); + } + } + return values_array; +} + +json_object * +bygfoot_json_serialize_live_game_stats_players(GPtrArray* (*players)[5]) +{ + + json_object *players_array = json_object_new_array_ext(2); + gint i; + + for (i = 0; i < 2; i ++) { + json_object *stats_array = json_object_new_array_ext(LIVE_GAME_STAT_ARRAY_END); + gint j; + json_object_array_add(players_array, stats_array); + for (j = 0; j < LIVE_GAME_STAT_ARRAY_END; j++) { + const GPtrArray *player_stats = players[i][j]; + gint k; + for (k = 0; k < player_stats->len; k++) { + const Player *player = g_ptr_array_index(player_stats, k); + json_object_array_add(stats_array, bygfoot_json_serialize_player_ptr(player)); + } + } + } + return players_array; +} + +json_object * +bygfoot_json_serialize_live_game_team_state_array(LiveGameTeamState *team_states) +{ + json_object *team_state_array = json_object_new_array_ext(2); + gint i; + + for (i = 0; i < 2; i++) { + const LiveGameTeamState *team_state = team_states + i; + json_object_array_add(team_state_array, + bygfoot_json_serialize_live_game_team_state(team_state)); + } + return team_state_array; +} + +json_object * +bygfoot_json_serialize_live_game_team_state(const LiveGameTeamState *team_state) +{ + json_object *team_state_obj = json_object_new_object(); + + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(team_state_obj, team_state, field, serialize_func); + + SERIALIZE(structure, json_object_new_int64); + SERIALIZE(style, json_object_new_int64); + SERIALIZE(boost, json_object_new_boolean); + json_object_object_add(team_state_obj, "player_ids", serialize_int_array(team_state->player_ids, 11)); + #undef SERIALIZE + + return team_state_obj; +} + +json_object * +bygfoot_json_serialize_live_game_action_ids(GArray **action_ids) +{ + json_object *action_ids_array = json_object_new_array_ext(2); + gint i; + + for (i = 0; i < 2; i++) { + json_object_array_add(action_ids_array, serialize_int_garray(action_ids[i])); + } + return action_ids_array; +} + +json_object* +bygfoot_json_serialize_season_stats(const GArray *stats) +{ + json_object *stats_array = json_object_new_array_ext(stats->len); + gint i; + + for (i = 0; i < stats->len; i++) { + SeasonStat *stat = &g_array_index(stats, SeasonStat, i); + json_object_array_add(stats_array, bygfoot_json_serialize_season_stat(stat)); + } + return stats_array; +} + +json_object * +bygfoot_json_serialize_season_stat(const SeasonStat *stat) +{ + json_object *stat_obj = json_object_new_object(); + + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(stat_obj, stat, field, serialize_func); + + SERIALIZE(season_number, json_object_new_int64); + SERIALIZE(league_champs, bygfoot_json_serialize_champ_stats); + SERIALIZE(cup_champs, bygfoot_json_serialize_champ_stats); + SERIALIZE(league_stats, bygfoot_json_serialize_league_stats); + #undef SERIALIZE + + return stat_obj; +} + +json_object * +bygfoot_json_serialize_champ_stats(const GArray *stats) +{ + json_object *stats_array = json_object_new_array_ext(stats->len); + gint i; + + for (i = 0 ; i < stats->len; i++) { + const ChampStat *stat = &g_array_index(stats, ChampStat, i); + json_object_array_add(stats_array, bygfoot_json_serialize_champ_stat(stat)); + } + return stats_array; +} + +json_object * +bygfoot_json_serialize_champ_stat(const ChampStat *stat) +{ + json_object *stat_obj = json_object_new_object(); + + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(stat_obj, stat, field, serialize_func); + + SERIALIZE(team_name, serialize_string); + SERIALIZE(cl_name, serialize_string); + #undef SERIALIZE + + return stat_obj; +} + +json_object * +bygfoot_json_serialize_league_stats(const GArray *stats) +{ + json_object *stats_array = json_object_new_array_ext(stats->len); + gint i; + + for (i = 0; i < stats->len; i++) { + const LeagueStat *stat = &g_array_index(stats, LeagueStat, i); + json_object_array_add(stats_array, bygfoot_json_serialize_league_stat(stat)); + } + return stats_array; +} + +json_object * +bygfoot_json_serialize_league_stat(const LeagueStat *stat) +{ + json_object *stat_obj = json_object_new_object(); + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(stat_obj, stat, field, serialize_func); + + SERIALIZE(league_symbol, serialize_string); + SERIALIZE(league_name, serialize_string); + SERIALIZE(teams_off, bygfoot_json_serialize_stats); + SERIALIZE(teams_def, bygfoot_json_serialize_stats); + SERIALIZE(player_scorers, bygfoot_json_serialize_stats); + SERIALIZE(player_goalies, bygfoot_json_serialize_stats); + #undef SERIALIZE + + return stat_obj; +} + +json_object * +bygfoot_json_serialize_stats(const GArray *stats) +{ + json_object *stats_array = json_object_new_array_ext(stats->len); + gint i; + + for (i = 0; i < stats->len; i++) { + const Stat *stat = &g_array_index(stats, Stat, i); + json_object_array_add(stats_array, bygfoot_json_serialize_stat(stat)); + } + return stats_array; +} + +json_object * +bygfoot_json_serialize_stat(const Stat *stat) +{ + json_object *stat_obj = json_object_new_object(); + + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(stat_obj, stat, field, serialize_func); + + SERIALIZE(team_name, serialize_string); + SERIALIZE(value1, json_object_new_int64); + SERIALIZE(value2, json_object_new_int64); + SERIALIZE(value3, json_object_new_int64); + SERIALIZE(value_string, serialize_string); + #undef SERIALIZE + + return stat_obj; +} + +json_object * +bygfoot_json_serialize_jobs(const GArray *jobs) +{ + json_object *jobs_array = json_object_new_array_ext(jobs->len); + gint i; + + for (i = 0; i < jobs->len; i++) { + const Job *job = &g_array_index(jobs, Job, i); + json_object_array_add(jobs_array, bygfoot_json_serialize_job(job)); + } + return jobs_array; +} + +json_object * +bygfoot_json_serialize_job(const Job *job) +{ + json_object *job_obj = json_object_new_object(); + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(job_obj, job, field, serialize_func); + + SERIALIZE(type, json_object_new_int64); + SERIALIZE(time, json_object_new_int64); + SERIALIZE(country_file, serialize_string); + SERIALIZE(country_name, serialize_string); + SERIALIZE(league_name, serialize_string); + SERIALIZE(league_layer, json_object_new_int64); + SERIALIZE(country_rating, json_object_new_int64); + SERIALIZE(talent_percent, json_object_new_int64); + SERIALIZE(team_id, json_object_new_int64); + #undef SERIALIZE + + return job_obj; +} + +SERIALIZE_GARRAY_FUNC_DEF(bygfoot_json_serialize_tables, + Table, + bygfoot_json_serialize_table); + +json_object * +bygfoot_json_serialize_table(const Table *table) +{ + json_object *table_obj = json_object_new_object(); + + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(table_obj, table, field, serialize_func); + + SERIALIZE(name, serialize_string); + SERIALIZE(clid, json_object_new_int64); + SERIALIZE(round, json_object_new_int64); + SERIALIZE(elements, bygfoot_json_serialize_table_elements); + #undef SERIALIZE + + return table_obj; +} + +SERIALIZE_GARRAY_FUNC_DEF(bygfoot_json_serialize_table_elements, + TableElement, + bygfoot_json_serialize_table_element); + +json_object * +bygfoot_json_serialize_table_element(const TableElement *element) +{ + json_object *element_obj = json_object_new_object(); + + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(element_obj, element, field, serialize_func); + + SERIALIZE(team, bygfoot_json_serialize_team_ptr); + SERIALIZE(team_id, json_object_new_int64); + SERIALIZE(old_rank, json_object_new_int64); + json_object_object_add(element_obj, "played", + json_object_new_int64(element->values[TABLE_PLAYED])); + json_object_object_add(element_obj, "won", + json_object_new_int64(element->values[TABLE_WON])); + json_object_object_add(element_obj, "draw", + json_object_new_int64(element->values[TABLE_DRAW])); + json_object_object_add(element_obj, "lost", + json_object_new_int64(element->values[TABLE_LOST])); + json_object_object_add(element_obj, "gf", + json_object_new_int64(element->values[TABLE_GF])); + json_object_object_add(element_obj, "ga", + json_object_new_int64(element->values[TABLE_GA])); + json_object_object_add(element_obj, "gd", + json_object_new_int64(element->values[TABLE_GD])); + json_object_object_add(element_obj, "pts", + json_object_new_int64(element->values[TABLE_PTS])); + #undef SERIALIZE + + return element_obj; +} + +SERIALIZE_GARRAY_FUNC_DEF(bygfoot_json_serialize_fixtures, + Fixture, + bygfoot_json_serialize_fixture); + +json_object * +bygfoot_json_serialize_fixture(const Fixture *fixture) +{ + json_object *fixture_obj = json_object_new_object(); + + #define SERIALIZE(field, serialize_func) \ + SERIALIZE_OBJECT_FIELD(fixture_obj, fixture, field, serialize_func); + + SERIALIZE(clid, json_object_new_int64); + SERIALIZE(id, json_object_new_int64); + SERIALIZE(round, json_object_new_int64); + SERIALIZE(replay_number, json_object_new_int64); + SERIALIZE(week_number, json_object_new_int64); + SERIALIZE(week_round_number, json_object_new_int64); + SERIALIZE(teams, bygfoot_json_serialize_fixture_teams); + json_object_object_add(fixture_obj, "team_ids", serialize_int_array(fixture->team_ids, 2)); + SERIALIZE(result, bygfoot_json_serialize_fixture_result); + SERIALIZE(home_advantage, json_object_new_boolean); + SERIALIZE(second_leg, json_object_new_boolean); + SERIALIZE(decisive, json_object_new_boolean); + /* live_game not serialized, because it is temporary */ + #undef SERIALIZE + + return fixture_obj; +} + +json_object * +bygfoot_json_serialize_fixture_teams(Team * const *teams) +{ + json_object *teams_array = json_object_new_array_ext(2); + gint i; + + for (i = 0; i < 2; i++) { + const Team *team = teams[i]; + json_object_array_add(teams_array, bygfoot_json_serialize_team_ptr(team)); + } + return teams_array; +} + +json_object * +bygfoot_json_serialize_fixture_result(const gint (*result)[3]) +{ + json_object *result_array = json_object_new_array_ext(2); + gint i; + + for (i = 0; i < 2; i++) { + static const struct key_index { + const gchar *key; + gint index; + } result_fields[] = { + { "goals_regulation", 0 }, + { "goals_extra_time", 1 }, + { "goals_penalty_shootout", 2 }, + { NULL, 0 } + }; + const struct key_index *iter; + json_object *result_obj = json_object_new_object(); + json_object_array_add(result_array, result_obj); + for (iter = result_fields; iter->key; iter++) { + gint value = result[i][iter->index]; + json_object_object_add(result_obj, iter->key, json_object_new_int64(value)); + } + } + return result_array; +} diff --git a/src/json_serialize.h b/src/json_serialize.h index 8034f9c0..dd69c403 100644 --- a/src/json_serialize.h +++ b/src/json_serialize.h @@ -2,26 +2,302 @@ #define JSON_SERIALIZE_H #include "bygfoot.h" +#include "bet_struct.h" #include "cup_struct.h" #include "league_struct.h" +#include "job_struct.h" +#include "transfer_struct.h" #include "json_compat.h" -struct json_object * +json_object * +bygfoot_json_serialize_bygfoot(const Bygfoot *bygfoot); + +json_object * bygfoot_json_serialize_country_list(GPtrArray *country_list); -struct json_object * +json_object * +bygfoot_json_serialize_countries(const GPtrArray *countries); + +json_object * bygfoot_json_serialize_country(const Country *country); -struct json_object * +/** @name League */ +/* @{ */ +json_object * bygfoot_json_serialize_league_array(const GArray *league_array); -struct json_object * +json_object * bygfoot_json_serialize_league(const League *league); -struct json_object * +json_object * +bygfoot_json_serialize_prom_rel(PromRel prom_rel); + +json_object * +bygfoot_json_serialize_prom_rel_elements(const GArray *garry); + +json_object * +bygfoot_json_serialize_prom_rel_element(const PromRelElement *element); + +json_object* +bygfoot_json_serialize_prom_games_array(const GArray *garry); + +json_object* +bygfoot_json_serialize_prom_games(const PromGames *prom_games); + +json_object * +bygfoot_json_serialize_two_match_weeks(GArray * const *two_match_weeks); + +json_object * +bygfoot_json_serialize_joined_leagues(const GArray *garray); + +json_object * +bygfoot_json_serialize_joined_league(const JoinedLeague *league); + +json_object * +bygfoot_json_serialize_new_tables(const GArray *garray); + +json_object * +bygfoot_json_serialize_new_table(const NewTable *table); + +json_object * +bygfoot_json_serialize_week_breaks(const GArray *garry); + +json_object * +bygfoot_json_serialize_week_break(const WeekBreak *week_break); +/* @} */ + +/** @name User */ +/* @{ */ +json_object * +bygfoot_json_serialize_users(const GArray *users); + +json_object * +bygfoot_json_serialize_user(const User *user); + +json_object * +bygfoot_json_serialize_user_bets(GArray * const *bets); + +json_object * +bygfoot_json_serialize_user_sponsor(UserSponsor sponsor); + +json_object * +bygfoot_json_serialize_user_histories(const GArray *histories); + +json_object * +bygfoot_json_serialize_user_history(const UserHistory *history); + +json_object * +bygfoot_json_serialize_user_money_in(const gint (*money_in)[5]); + +json_object * +bygfoot_json_serialize_user_money_out(const gint (*money_out)[13]); +/* @} */ + +/** @name Bet */ +/* @{ */ +json_object * +bygfoot_json_serialize_bet_user(const BetUser *bet_user); + +json_object * +bygfoot_json_serialize_bets(GArray **bets); + +json_object * +bygfoot_json_serialize_bet_match(const BetMatch *bet_match); + +/* @} */ + +/** @name Team */ +/* @{ */ +json_object * +bygfoot_json_serialize_teams(const GArray *teams); + +json_object * bygfoot_json_serialize_team_ptrs(GPtrArray *team_ptrs, GHashTable *fields); +json_object * +bygfoot_json_serialize_team_ptr(const Team *team); -struct json_object * -bygfoot_json_serialize_cup(const Cup *cup, GHashTable *fields); +json_object * +bygfoot_json_serialize_team(const Team *team, GHashTable *fields); + +json_object * +bygfoot_json_serialize_youth_academy(YouthAcademy youth_academy); +/* @} */ + + +/** @name Player */ +/* @{ */ +json_object * +bygfoot_json_serialize_players(const GArray *player); + +json_object * +bygfoot_json_serialize_player(const Player *player); + +json_object * +bygfoot_json_serialize_player_ptr(const Player *player); + +json_object * +bygfoot_json_serialize_cards(const GArray *cards); + +json_object * +bygfoot_json_serialize_player_card(const PlayerCard *card); + +json_object * +bygfoot_json_serialize_games_goals_array(const GArray *games_goals); + +json_object * +bygfoot_json_serialize_games_goals(const PlayerGamesGoals *games_goals); + +/* @} */ + +/** @name Cup */ +/* @{ */ +json_object * +bygfoot_json_serialize_cups(const GArray *garry); + +json_object * +bygfoot_json_serialize_cup(const Cup *cup); + +json_object * +bygfoot_json_serialize_cup_ptrs(GPtrArray *cups); + +json_object * +bygfoot_json_serialize_cup_ptr(const Cup *cup); + +json_object * +bygfoot_json_serialize_cup_choose_teams(const GArray *garray); + +json_object * +bygfoot_json_serialize_cup_choose_team(const CupChooseTeam *choose_team); + +json_object * +bygfoot_json_serialize_cup_round_waits(const GArray *garray); + +json_object * +bygfoot_json_serialize_cup_round_wait(const CupRoundWait *wait); +/* @} */ + +/** @name Transfers */ +/* @{ */ + +json_object * +bygfoot_json_serialize_transfers(const GArray *transfers); + +json_object * +bygfoot_json_serialize_transfer(const Transfer *transfer); + +json_object * +bygfoot_json_serialize_transfer_offers(const GArray *offers); + +json_object * +bygfoot_json_serialize_transfer_offer(const TransferOffer *offer); +/* @} */ + +/** @name Fixtures */ +/* @{ */ +json_object* +bygfoot_json_serialize_fixture_ptr(const Fixture *fixture); +/* @} */ + +/** @name Live Game */ +/* @{ */ +json_object * +bygfoot_json_serialize_live_game(LiveGame live_game); + +json_object * +bygfoot_json_serialize_live_game_team_values(const gfloat (*team_values)[4]); + +json_object * +bygfoot_json_serialize_live_game_units(const GArray *units); + +json_object * +bygfoot_json_serialize_live_game_unit(const LiveGameUnit *unit); + +json_object * +bygfoot_json_serialize_live_game_event(LiveGameEvent event); + +json_object * +bygfoot_json_serialize_live_game_stats(LiveGameStats stats); + +json_object * +bygfoot_json_serialize_live_game_stats_values(gint (*values)[9]); + +json_object * +bygfoot_json_serialize_live_game_stats_players(GPtrArray * (*players)[5]); + +json_object * +bygfoot_json_serialize_live_game_team_state_array(LiveGameTeamState *team_states); + +json_object * +bygfoot_json_serialize_live_game_team_state(const LiveGameTeamState *team_state); + +json_object * +bygfoot_json_serialize_live_game_action_ids(GArray **action_ids); +/* @} */ + +/** @name Stats */ +/* @{ */ +json_object* +bygfoot_json_serialize_season_stats(const GArray *stats); + +json_object * +bygfoot_json_serialize_season_stat(const SeasonStat *stat); + +json_object * +bygfoot_json_serialize_champ_stats(const GArray *stats); + +json_object * +bygfoot_json_serialize_champ_stat(const ChampStat *stat); + +json_object * +bygfoot_json_serialize_league_stats(const GArray *stats); + +json_object * +bygfoot_json_serialize_league_stat(const LeagueStat *stat); + +json_object * +bygfoot_json_serialize_stats(const GArray *stats); + +json_object * +bygfoot_json_serialize_stat(const Stat *stat); +/* @} */ + +/** @name Job */ +/* @{ */ +json_object * +bygfoot_json_serialize_jobs(const GArray *jobs); + +json_object * +bygfoot_json_serialize_job(const Job *job); +/* @} */ + +/** @name Table */ +/* @{ */ +json_object * +bygfoot_json_serialize_tables(const GArray *garray); + +json_object * +bygfoot_json_serialize_table(const Table *table); + +json_object * +bygfoot_json_serialize_table_elements(const GArray *garray); + +json_object * +bygfoot_json_serialize_table_element(const TableElement *element); +/* @} */ + +/** @name Fixture */ +/* @{ */ +json_object * +bygfoot_json_serialize_fixtures(const GArray *garray); + +json_object * +bygfoot_json_serialize_fixture(const Fixture *fixture); + +json_object * +bygfoot_json_serialize_fixture_teams(Team * const *teams); + +json_object * +bygfoot_json_serialize_fixture_result(const gint (*result)[3]); +/* @} */ #endif