🎅🏽 😆 🦆 यूईएफए देश अनुपात गणना 🎹 😠 🐴

फुटबॉल में दो लोकप्रिय टूर्नामेंट हैं: चैंपियंस लीग और यूरोपा लीग। उनके परिणामों के आधार पर, फुटबॉल संघों की तथाकथित रेटिंग की गणना की जाती है। इस रेटिंग के आधार पर, यह निर्धारित किया जाता है कि प्रत्येक देश की कितनी टीमें बाद के टूर्नामेंट में भाग लेंगी।

इस लेख में, मैं खुले और मुक्त lsFusion मंच पर आधारित एक एप्लिकेशन बनाऊंगा जो इस रेटिंग की गणना करेगा। यह PostgreSQL में अपने सभी डेटा को स्टोर करेगा, फ़िल्टरिंग और छँटाई क्षमताओं के साथ उन्हें बदलने और प्रदर्शित करने के लिए एक वेब इंटरफ़ेस प्रदान करेगा, साथ ही एक विशेष एपीआई का उपयोग करके मैच परिणाम आयात करेगा।

इस एप्लिकेशन को लागू करने के लिए सभी कोड में लगभग 300 महत्वपूर्ण लाइनें शामिल होंगी।

डोमेन तर्क

किसी भी सूचना प्रणाली का निर्माण डोमेन लॉजिक के कार्य से शुरू होता है।
सबसे पहले, यह सबसे आसान निर्देशिकाओं को एकल करने के लिए तर्कसंगत है जिनके पास केवल एक कोड और एक नाम है:

टूर्नामेंट। चैंपियंस लीग या यूरोपा लीग।
सीज़न । 2018-2019 / 2017-2018 आदि।
गोल । फाइनल, सेमीफाइनल, ग्रुप स्टेज आदि। इसे टूर्नामेंट के लिए एक रचना के रूप में माना जा सकता है, लेकिन इसके कार्यान्वयन में मैंने इसे एक अलग इकाई के रूप में गाया।
देश। इस एप्लिकेशन का उपयोग फुटबॉल एसोसिएशन के रूप में किया जाता है। उदाहरण के लिए, मोनाको का क्लब मोनाको के देश में स्थित है, लेकिन फ्रेंच चैम्पियनशिप में खेलता है।
क्लब। बार्सिलोना, रियल मैड्रिड, मैनचेस्टर यूनाइटेड आदि।

चूंकि lsFusion उन्हें घोषित करने के लिए एक ही प्रकार के तर्क का उपयोग करता है, हम एक मेटाकोड (या कोड टेम्प्लेट) घोषित करेंगे जो संबंधित तर्क उत्पन्न करेगा:

निर्देशिका घोषणा मेटाकोड

META defineMasterObject(object, caption, captions, nameLength)
CLASS ### object caption;

id '' = DATA INTEGER ( ### object);
object ( INTEGER id) = GROUP AGGR ### object o BY id(o); //

name '' = DATA ISTRING ( ### object) CHARWIDTH nameLength;
object ( ISTRING name) = GROUP AGGR ### object o BY name(o); //

FORM object caption
OBJECTS o = ### object PANEL
PROPERTIES (o) id, name

EDIT ### object OBJECT o
;

FORM object ## s captions
OBJECTS o = ### object
PROPERTIES (o) READONLY id, name
PROPERTIES (o) NEWSESSION NEW , EDIT , DELETE
;

FORM dialog ### object ## s captions
OBJECTS o = ### object
PROPERTIES (o) READONLY id, name

LIST ### object OBJECT o
;

NAVIGATOR {
NEW object ## s;
}
END

वह घोषणा करेंगे:

दिए गए नाम के साथ कक्षा
नए वर्ग के लिए कोड और नाम के साथ गुण
तीन रूप: एक वस्तु का संपादन, सभी वस्तुओं की सूची के साथ एक रूप, जिसे फिर नाविक में जोड़ा जाता है, इस वस्तु को चुनने के लिए एक संवाद। संवाद के रूप में, आप दूसरे फ़ॉर्म का उपयोग कर सकते हैं, लेकिन तब उपयोगकर्ता के पास चुनने पर वस्तुओं को बदलने का अवसर होगा, जिससे उपयोगकर्ताओं की ओर से त्रुटियां हो सकती हैं।

मेटाकोड को चार पैरामीटर दिए गए हैं:

पहचानकर्ता (वस्तु) । इसके साथ नाम वर्ग और प्रपत्र बनाए जाएंगे। परिणामी कोड में पूंजीकृत पहचानकर्ता के पहले अक्षर को बनाने के लिए ### निर्माण का उपयोग किया जाता है।
एकवचन में नाम । वर्ग और रूप के शीर्षक के लिए उपयोग किया जाता है।
नाम बहुवचन में है । कॉम्बो बॉक्स और संवाद के लिए उपयोग किया जाता है।
नाम लंबाई । विभिन्न वस्तुओं के नामों में, अलग-अलग लंबाई की अपेक्षा की जाती है, जो इंटरफ़ेस का निर्माण करते समय महत्वपूर्ण है।

बनाए गए मेटाकोड का उपयोग करके, ऊपर वर्णित पांच इकाइयां जोड़ें:

@defineMasterObject (tournament, '' , '' , 20 );
@defineMasterObject (season, '' , '' , 5 );
@defineMasterObject (round, '' , '' , 15 );
@defineMasterObject (country, '' , '' , 10 );
@defineMasterObject (team, '' , '' , 20 );

एक कोड के लिए, उदाहरण के लिए, उत्पन्न कोड इस तरह दिखेगा:

CLASS Tournament '' ;

id '' = DATA INTEGER (Tournament);
tournament ( INTEGER id) = GROUP AGGR Tournament o BY id(o);

name '' = DATA ISTRING (Tournament) CHARWIDTH 20 ;
tournament ( ISTRING name) = GROUP AGGR Tournament o BY name(o);

FORM tournament ''
OBJECTS o = Tournament PANEL
PROPERTIES (o) id, name

EDIT Tournament OBJECT o
;

FORM tournaments ''
OBJECTS o = Tournament
PROPERTIES (o) READONLY id, name
PROPERTIES (o) NEWSESSION NEW , EDIT , DELETE
;

FORM dialogTournaments ''
OBJECTS o = Tournament
PROPERTIES (o) READONLY id, name

LIST Tournament OBJECT o
;

NAVIGATOR {
NEW tournaments;
}

जनरेट क्लब तर्क के लिए देश के लिए लिंक जोड़ें। ऐसा करने के लिए, पहले संबंधित प्रॉपर्टी बनाएं, जिसे बाद में क्लब के संपादन और देखने के रूपों पर डालें:

country = DATA Country (Team);
nameCountry '' (Team t) = name(country(t));

EXTEND FORM team PROPERTIES (o) nameCountry;
EXTEND FORM teams PROPERTIES (o) READONLY nameCountry;

हमने सभी बनाए गए लॉजिक को एक अलग मास्टर मॉड्यूल (फ़ाइल Master.lsf) में रखा है।

अब एक इकाई लीग बनाएँ। वह एक विशेष सत्र के टूर्नामेंट का निर्धारण करेगी। उदाहरण के लिए, चैंपियंस लीग 2017-18 या यूरोपा लीग 2018-19। लीग में एक नाम नहीं होगा, लेकिन केवल टूर्नामेंट और सीज़न के लिए लिंक होगा। इसलिए, हम पिछले मेटाकोड का उपयोग नहीं करेंगे, लेकिन हम एक ही तर्क करेंगे और इसे नए लीग मॉड्यूल में डालेंगे:

MODULE League;

REQUIRE Master;

CLASS League '' ;

id '' = DATA INTEGER (League);
league ( INTEGER id) = GROUP AGGR League o BY id(o);

tournament = DATA Tournament (League);
nameTournament '' (League l)= name(tournament(l));

season = DATA Season(League);
nameSeason '' (League l)= name(season(l));

FORM league ''
OBJECTS o = League PANEL
PROPERTIES (o) id, nameTournament, nameSeason

EDIT League OBJECT o
;

FORM leagues ''
OBJECTS o = League
PROPERTIES (o) READONLY id, nameTournament, nameSeason
PROPERTIES (o) NEWSESSION NEW , EDIT , DELETE
;

FORM dialogLeagues ''
OBJECTS o = League
PROPERTIES (o) READONLY id, nameTournament, nameSeason

LIST League OBJECT o
;

NAVIGATOR {
NEW leagues;
}

और अंत में, मैचों के तर्क को जोड़ें। ऐसा करने के लिए, क्लास मैच बनाएं, जो लीग और राउंड को संदर्भित करेगा। उसके लिए, इसमें भाग लेने वाले क्लब और परिणाम भी पूछा जाएगा। हमने यह सब एक अलग मिलान मॉड्यूल में रखा है:

MODULE Match;

REQUIRE League;

CLASS Match '' ;

id '' = DATA INTEGER (Match);
match ( INTEGER id) = GROUP AGGR Match o BY id(o);

dateTime '' = DATA DATETIME (Match);

league = DATA League (Match);

tournament (Match m) = tournament(league(m));
nameTournament '' (Match m) = name(tournament(m));

season(Match m) = season(league(m));
nameSeason '' (Match m) = name(season(m));

round = DATA Round (Match);
nameRound '' (Match m) = name(round(m));

homeTeam = DATA Team (Match);
nameHomeTeam '' (Match m) = name(homeTeam(m));

awayTeam = DATA Team (Match);
nameAwayTeam '' (Match m) = name(awayTeam(m));

goalsHome ' ()' = DATA INTEGER (Match);
goalsAway ' ()' = DATA INTEGER (Match);

FORM match ''
OBJECTS o = Match PANEL
PROPERTIES (o) id, dateTime, nameTournament, nameSeason, nameRound,
nameHomeTeam, goalsHome, goalsAway, nameAwayTeam

EDIT Match OBJECT o
;

FORM matches ''
OBJECTS o = Match
PROPERTIES (o) READONLY id, dateTime, nameTournament, nameSeason, nameRound,
nameHomeTeam, goalsHome, goalsAway, nameAwayTeam
PROPERTIES (o) NEWSESSION NEW , EDIT , DELETE

LIST Match OBJECT o
;

NAVIGATOR {
NEW matches;
}

डेटा आयात

दुर्भाग्य से, मैं केवल एक सार्वजनिक और मुफ्त एपीआई खोजने में कामयाब रहा जो सभी यूरोकप का समर्थन करता है। यह फुटबॉल एपीआई है । हालाँकि, समस्याएं हैं:

2016 तक कोई परिणाम नहीं हैं।
2018 तक यूरोपा लीग के लिए कोई योग्यता नहीं है।
डेटा में कुछ त्रुटियां हैं। उदाहरण के लिए, इरित्श पावलोदर रूस को सौंपा गया है, हालांकि यह क्लब कजाकिस्तान का प्रतिनिधित्व करता है। इसके अलावा, किसी कारण से यूरोपा एफसी जिब्राल्टर के बजाय स्पेन को संदर्भित करता है।

डेटा त्रुटियों को पहले से बनाए गए प्रपत्रों का उपयोग करके मैन्युअल रूप से ठीक किया जा सकता है। हालांकि, चूंकि कुल गुणांक की गणना पिछले पांच वर्षों पर आधारित है, दुर्भाग्य से, यह एपीआई फुटबॉल डेटा से कुल गुणांक की गणना करने के लिए काम नहीं करेगा। यदि टिप्पणियों में कोई व्यक्ति सुझाव देता है कि पिछले वर्षों से किसी भी प्रारूप में आवश्यक डेटा कहां प्राप्त करना है, तो मैं बहुत आभारी रहूंगा। लेकिन, चूंकि 2018 के लिए पूरा डेटा है, इसलिए कम से कम इस वर्ष के लिए गणना की शुद्धता को सत्यापित करना संभव होगा।

हमें जिस एपीआई की आवश्यकता है, उसे HTTP अनुरोधों के रूप में कार्यान्वित किया जाता है, जहां पैरामीटर url के माध्यम से प्रेषित होते हैं, और हेडर में एक विशेष एक्सेस कुंजी इंगित की जाती है। इसी तर्क को घोषित करें:

host = 'api-football-v1.p.rapidapi.com' ;
key ' API Football' = DATA STRING () CHARWIDTH 50 ;

url = 'https://' + host() + '/v2' ;

headers( TEXT name) = CASE
WHEN name = 'x-rapidapi-host' THEN host()
WHEN name = 'x-rapidapi-key' THEN key();

सभी डेटा आयात क्रियाएं पहले बनाए गए लीग फॉर्म पर रखी जाएंगी। वहां हम तालिका की टूलबार में एक्सेस कुंजी को लीग की सूची के साथ रखेंगे:

EXTEND FORM leagues
PROPERTIES () key DRAW o TOOLBAR
;

सबसे पहले, हम लीग की सूची को लागू करते हैं। इसके लिए, फुटबॉल एपीआई में एक विशेष यूआरएल है: / लीग। इसे प्राप्त करने का अनुरोध फॉर्म के JSON देता है:

जवाब है

 { "api":{ "results":2, "leagues":[ { "league_id":1, "name":"2018 Russia World Cup", "country":"World", "country_code":null, "season":2018, "season_start":"2018-06-14", "season_end":"2018-07-15", "logo":"https://www.api-football.com/public/leagues/1.png", "flag":null, "standings":0, "is_current":1 }, { "league_id":2, "name":"Premier League", "country":"England", "country_code":"GB", "season":2018, "season_start":"2018-08-10", "season_end":"2019-05-12", "logo":"https://www.api-football.com/public/leagues/2.png", "flag":"https://www.api-football.com/public/flags/gb.svg", "standings":1, "is_current":1 } ] } }

इसके लिए एक GET अनुरोध उत्पन्न करने और प्रतिक्रिया निकाय को रिकॉर्ड करने के लिए, निम्नलिखित निर्माण का उपयोग किया जाता है:

LOCAL result = FILE ();
EXTERNAL HTTP GET url() + '/leagues' HEADERS headers TO result;

यह टाइप FILE के मापदंडों के बिना स्थानीय परिणाम संपत्ति के लिए परिणाम लिखता है।

JSON प्रारूप में एक फ़ाइल को पार्स करने के लिए, एक फॉर्म बनाया जाता है जिसकी संरचना JSON संरचना से मेल खाती है। आप मेनू आइटम का उपयोग करके IDE में इसे उत्पन्न कर सकते हैं:

उपरोक्त JSON के लिए, फॉर्म इस तरह दिखाई देगा (केवल उन मूल्यों को ध्यान में रखते हुए जिन्हें आयात किया जाएगा):

GROUP api;

tournamentName = DATA LOCAL STRING ( INTEGER );
seasonName = DATA LOCAL STRING ( INTEGER );
leagueId = DATA LOCAL INTEGER ( INTEGER );

FORM importLeagues
OBJECTS leagues = INTEGER IN api
PROPERTIES (leagues) name = tournamentName, season = seasonName, league_id = leagueId
;

आयात के प्रारूप में JSON परिणाम संपत्ति से सीधे आयात करने के लिए, निम्न आदेश का उपयोग करें:

IMPORT importLeagues JSON FROM result();

इसके निष्पादन के बाद, JSON फ़ाइल से संबंधित मान को टूर्नामेंटनाम , सीज़ननाम और लीग आईडी गुणों में रखा जाएगा:

यही है, टूर्नामेंटनाम (0) के लिए मान "विश्व कप" होगा, और टूर्नामेंटनाम (1) में यह "प्रीमियर लीग" होगा।

दुर्भाग्य से, एपीआई फुटबॉल में एक टूर्नामेंट इकाई बिल्कुल नहीं है। सभी लीगों को जोड़ने का एकमात्र तरीका एक नाम है जो विभिन्न सत्रों से एक ही टूर्नामेंट के लीग से मेल खाता है। ऐसा करने के लिए, आयात में, पहले हम आयातित लीग के सभी नामों को समूहीकृत करते हैं और यदि डेटाबेस में नहीं हैं, तो नए टूर्नामेंट बनाएं:

FOR [ GROUP SUM 1 BY tournamentName( INTEGER i)]( STRING tn) AND NOT tournament(tn) DO NEW t = Tournament {
name(t) <- tn;
}

सीज़न के लिए कोई कोड भी नहीं हैं, इसलिए लीग आयात करते समय, उन्हें उसी तरह बनाया जाता है। लापता वस्तुओं के बनने के बाद, लीग को सीधे आयात किया जाता है। टूर्नामेंट और सीज़न को ग्रुप एजीजीआर के माध्यम से पहले निर्मित गुणों के नाम से खोजा जाता है:

FOR leagueId( INTEGER i) AND NOT league(leagueId(i)) DO NEW l = League {
id(l) <- leagueId(i);
tournament(l) <- tournament(tournamentName(i));
season(l) <- season(seasonName(i));
}

डिफ़ॉल्ट रूप से, डेटा लोड किया जाएगा, लेकिन केवल डेटाबेस पर सहेजा जाएगा जब उपयोगकर्ता प्रपत्र पर सहेजें बटन पर क्लिक करता है। यदि आवश्यक हो, तो आप एक्शन के अंत में APPLY कमांड जोड़ सकते हैं ताकि यह बिना किसी पूर्वावलोकन के तुरंत डेटाबेस में सेव हो जाए।

और अंत में, आयात कार्रवाई को लीग सूची फॉर्म में जोड़ें:

EXTEND FORM leagues
PROPERTIES () importLeagues DRAW o TOOLBAR
;

इसी तरह, हम क्लब और मैच आयात करते हैं। हालाँकि, चूंकि API उन्हें केवल एक विशिष्ट लीग के लिए आयात करने की क्षमता प्रदान करता है, इसलिए कार्रवाई को लीग को इनपुट के रूप में लेना चाहिए:

क्लब और मैच आयात करें

//
teamId = DATA LOCAL INTEGER ( INTEGER );
teamName = DATA LOCAL STRING ( INTEGER );
countryName = DATA LOCAL STRING ( INTEGER );

FORM importTeams
OBJECTS teams = INTEGER IN api
PROPERTIES (teams) team_id = teamId, name = teamName, country = countryName
;

importTeams ' ' (League l) {
LOCAL result = FILE ();
EXTERNAL HTTP GET url() + '/teams/league/' + id(l) HEADERS headers TO result;

IMPORT importTeams JSON FROM result();
FOR [ GROUP SUM 1 BY countryName( INTEGER i)]( STRING cn) AND NOT country(cn) DO NEW c = Country {
name(c) <- cn;
}

FOR teamId( INTEGER i) AND NOT team(teamId(i)) DO NEW t = Team {
id(t) <- teamId(i);
name(t) <- teamName(i);
country(t) <- country(countryName(i));
}
}

//

matchId = DATA LOCAL INTEGER ( INTEGER );
dateTime = DATA LOCAL STRING ( INTEGER );
roundName = DATA LOCAL STRING ( INTEGER );

GROUP homeTeam;
homeTeamId = DATA LOCAL INTEGER ( INTEGER );

GROUP awayTeam;
awayTeamId = DATA LOCAL INTEGER ( INTEGER );

goalsHome = DATA LOCAL INTEGER ( INTEGER );
goalsAway = DATA LOCAL INTEGER ( INTEGER );

FORM importMatches
OBJECTS fixtures = INTEGER IN api
PROPERTIES (fixtures) fixture_id = matchId, league_id = leagueId, event_date = dateTime, round = roundName,
homeTeamId IN homeTeam EXTID 'team_id' ,
awayTeamId IN awayTeam EXTID 'team_id' ,
goalsHomeTeam = goalsHome, goalsAwayTeam = goalsAway
;

importMatches ' ' (League l) {
LOCAL result = FILE ();
EXTERNAL HTTP GET url() + '/fixtures/league/' + id(l) HEADERS headers TO result;

IMPORT importMatches JSON FROM result();
FOR [ GROUP SUM 1 BY awayTeamId( INTEGER i)]( INTEGER id) AND NOT team(id) DO {
MESSAGE ' ' + id;
RETURN ;
}

FOR [ GROUP SUM 1 BY awayTeamId( INTEGER i)]( INTEGER id) AND NOT team(id) DO {
MESSAGE ' ' + id;
RETURN ;
}

FOR [ GROUP SUM 1 BY roundName( INTEGER i)]( STRING rn) AND NOT round(rn) DO NEW r = Round {
name(r) <- rn;
}

FOR matchId( INTEGER i) AND NOT match(matchId(i)) DO NEW m = Match {
id(m) <- matchId(i);
dateTime(m) <- toDateTimeFormat(left(dateTime(i), 19 ), 'yyyy-MM-ddThh24:mi:ss' );
league(m) <- league(leagueId(i));
round(m) <- round(roundName(i));
homeTeam(m) <- team(homeTeamId(i));
awayTeam(m) <- team(awayTeamId(i));
goalsHome(m) <- goalsHome(i);
goalsAway(m) <- goalsAway(i);
}
}

मैचों के लिए एक ख़ासियत है: टीम कोड अतिरिक्त होमटैम और दूर के टैग के अंदर जाते हैं। एपि के साथ अनुरूपता द्वारा उनके लिए अनुरूप समूह बनाए जाते हैं। इसके अलावा, उनके अंदर समान team_id टैग हैं। चूँकि समान नाम वाले गुणों को प्रपत्र में नहीं जोड़ा जा सकता है, इसलिए विशेष EXTID कीवर्ड का उपयोग किया जाता है , जो आयातित SON में टैग नाम को परिभाषित करता है।

सभी आयातों को एक ही रूप में होने के लिए, और चूंकि वे लीग से बंधे हैं, इसलिए हम उन सभी को उसी रूप में ले जाते हैं। इसके अलावा, हम फॉर्म में टीमों और मैचों को जोड़ते हैं ताकि यह देखा जा सके कि बचत करने से पहले क्या आयात किया जाता है:

EXTEND FORM leagues
OBJECTS t = Team
PROPERTIES (t) READONLY id, name

PROPERTIES importTeams(o) DRAW t TOOLBAR

OBJECTS m = Match
PROPERTIES (m) READONLY id, dateTime, nameRound, nameHomeTeam, goalsHome, goalsAway, nameAwayTeam
FILTERS league(m) = o

PROPERTIES importMatches(o) DRAW m TOOLBAR
;

DESIGN leagues {
OBJECTS {
NEW leagueDetails {
fill = 2 ;
type = SPLITH ;
MOVE BOX (t);
MOVE BOX (m);
}
}
}

परिणामी रूप इस तरह दिखेगा:

सभी आयातों को एक अलग APIFootball मॉड्यूल में रखा जाएगा।

गुणांक गणना

हम यूईएफए देश गुणांक की गणना के लिए सीधे आगे बढ़ते हैं। इसके लिए विशेष रूप से स्थापित यूईएफए मॉड्यूल में सभी कोड डालना तर्कसंगत है।

सबसे पहले, ध्यान रखें कि फुटबॉल एपीआई सभी मैचों के आयात के लिए एक इंटरफ़ेस प्रदान करता है, न कि केवल यूरोकप। इसलिए, हम टूर्नामेंट के नाम के अनुसार यूरोकप मैचों को अलग करते हैं (इसके लिए एक अलग प्राथमिक संपत्ति होना अधिक सही है, लेकिन गुणों के कार्यान्वयन को हमेशा बाकी के तर्क को संशोधित किए बिना बदला जा सकता है):

isCL (Tournament t) = name(t) = 'Champions League' ;
isEL (Tournament t) = name(t) = 'Europa League' ;

isUL (Tournament t) = isCL(t) OR isEL(t);
isUL (Match m) = isUL(tournament(m));

सबसे पहले, आइए उन बिंदुओं की गणना करें जो प्रत्येक क्लब को विशिष्ट मैचों के परिणामों के लिए एक सीजन में प्राप्त होता है।

इस अवधि के दौरान, प्रत्येक टीम प्राप्त करती है:
जीत के मामले में 2 अंक;
एक टाई के मामले में 1 अंक।
1999 के बाद से, इन अंकों को दो में विभाजित किया जाता है यदि वे योग्यता राउंड में अर्जित किए जाते हैं, तो यह है:
जीत के मामले में 1 अंक;
एक टाई के लिए 0.5 अंक।

सहायक गुण बनाएँ जो मैच और क्लब के बीच संबंध निर्धारित करते हैं:

played (Team t, Match m) = homeTeam(m) = t OR awayTeam(m) = t;
won (Team t, Match m) = (homeTeam(m) = t AND goalsHome(m) > goalsAway(m)) OR (awayTeam(m) = t AND goalsHome(m) < goalsAway(m));
draw (Team t, Match m) = played(t, m) AND goalsHome(m) = goalsAway(m);

यह निर्धारित करने के लिए कि प्रत्येक मैच में कितने अंक हैं, हम राउंड के लिए संख्यात्मक प्रकार की प्राथमिक संपत्ति जोड़ते हैं, जो डिफ़ॉल्ट रूप से निम्न के बराबर होगी:

dataMatchCoeff = DATA NUMERIC [ 10 , 1 ] (Round);
matchCoeff ' ' (Round r) = OVERRIDE dataMatchCoeff(r), 1.0 ;

फिर हम जीत और ड्रॉ के लिए अंक गिनते हैं और एक साथ जोड़ते हैं:

wonPoints ' ' (Season s, Team t) =
GROUP SUM 2 * matchCoeff(round(Match m)) IF won(t, m) AND season(m) = s AND isUL(m);
drawPoints ' ' (Season s, Team t) =
GROUP SUM 1 * matchCoeff(round(Match m)) IF draw(t, m) AND season(m) = s AND isUL(m);
matchPoints ' ' (Season s, Team t) = wonPoints(s, t) (+) drawPoints(s, t) MATERIALIZED ;

मैचों के लिए अंक को MATERIALIZED के रूप में चिह्नित किया जाता है ताकि वे तालिका में सहेजे जाएं, और हर बार गणना न की जाए।

अब आपको बोनस अंक गिनने होंगे:

इसके अलावा, बोनस अंक प्रदान किए जाते हैं:
1 अंक उस स्थिति में दिया जाता है जब टीम क्वार्टर फ़ाइनल, सेमीफ़ाइनल और फ़ाइनल में यूरोपीय कप में पहुँचती है;
चैंपियंस लीग के समूह चरण तक पहुंचने के लिए 4 अंक (1996 तक - 2 अंक, 1997 से 2003 तक - 1 बिंदु, 2004 से 2008 - 3 अंक तक);
चैंपियंस लीग (2008 से पहले - 1 अंक) के 1/8 फ़ाइनल के लिए रवाना होने वाली टीम की स्थिति में 5 अंक।
केवल खेले गए मैचों को ध्यान में रखा जाता है (तकनीकी नुकसान को ध्यान में नहीं रखा जाता है)। पेनल्टी शूटआउट की एक श्रृंखला में समाप्त होने वाले मैच, जब गुणांक की गणना परिणाम के अनुसार की जाती है, जो मुख्य और अतिरिक्त समय में खेल के परिणामों से तय होती है।

इस क्रियान्वयन में, हम मानते हैं कि अगर वह कम से कम एक मैच खेलता तो क्लब टूर्नामेंट के दौर में जाता। ऐसा करने के लिए, हम गणना करते हैं कि क्लब किसी विशेष सीज़न, टूर्नामेंट, राउंड में कितने मैच खेले:

played '' (Season s, Tournament t, Round r, Team tm) =
GROUP SUM 1 IF played(tm, Match m) AND round(m) = r AND tournament(m) = t AND season(m) = s;

अब आपको यह निर्धारित करने की आवश्यकता है कि किसी विशेष दौर में पारित होने के लिए कितने अंक हैं। चूंकि यह टूर्नामेंट पर निर्भर करता है (उदाहरण के लिए, League चैंपियंस लीग में 5 अंक दिए जाते हैं, लेकिन यूरोपा लीग में कुछ भी नहीं)। ऐसा करने के लिए, हम प्राथमिक संपत्ति का परिचय देते हैं:

bonusPoints ' ' = DATA NUMERIC [ 10 , 1 ] (Tournament, Round);

आइए अब बोनस अंक और सीज़न के क्लब के लिए कुल अंकों की गणना करें:

bonusPoints ' ' (Season s, Team tm) = GROUP SUM bonusPoints(Tournament t, Round r) IF played(s, t, r, tm) MATERIALIZED ;

points '' (Season s, Team tm) = matchPoints(s, tm) (+) bonusPoints(s, tm);

अंत में, हम सीधे देश के गुणांक पर जाते हैं।

एसोसिएशन की रेटिंग की गणना करने के लिए, चैंपियंस लीग और यूरोपा लीग में भाग लेने वाले क्लबों द्वारा बनाए गए सभी बिंदुओं को जोड़ा जाता है, और परिणाम इस एसोसिएशन [2] [3] से क्लबों की संख्या से विभाजित होता है।

यूरोपीय संघों में भाग लेने वाले प्रत्येक संघ के लिए क्लबों की संख्या की गणना करें:

matchesUL ' ' (Season s, Team t) = GROUP SUM 1 IF played(t, Match m) AND season(m) = s AND isUL(m);
teams '' (Season s, Country c) = GROUP SUM 1 IF matchesUL(s, Team t) AND country(t) = c;

अब हम सीजन के लिए कुल संघ बिंदुओं पर विचार करते हैं और क्लबों की संख्या से विभाजित करते हैं:

totalPoints ' ()' (Season s, Country c) = GROUP SUM points(s, Team t) IF country(t) = c;
points '' (Season s, Country c) = trunc( NUMERIC [ 13 , 4 ](totalPoints(s, c)) / teams(s, c), 3 );

देश की रेटिंग पिछले 5 वर्षों के लिए देश के गुणांक का योग है।

ऐसा करने के लिए, हम आंतरिक कोड द्वारा अंतिम से शुरू होने वाले सभी मौसमों को संख्या देते हैं (हम मानते हैं कि बाद को बाद में जोड़ा गया था और एक बड़ा कोड है):

index '' (Season s) = PARTITION SUM 1 IF s IS Season ORDER DESC s;

यदि आवश्यक हो, तो आप नाम से एक अलग फ़ील्ड या संख्या दर्ज कर सकते हैं।
यह केवल देश के लिए अंतिम रेटिंग की गणना करने के लिए बनी हुई है:

rating '' (Country c) = GROUP SUM points(Season s, c) IF index(s) <= 5 ;

ऊपर, हमने टूर्नामेंट और राउंड के लिए बाधाओं की घोषणा की। टूर्नामेंट में केवल उन्हीं राउंड को फ़िल्टर करते हुए, उन्हें टूर्नामेंट एडिटिंग फॉर्म में जोड़ें:

matches (Tournament t, Round r) = GROUP SUM 1 IF tournament(Match m) = t AND round(m) = r;

EXTEND FORM tournament
OBJECTS r = Round
PROPERTIES name(r) READONLY , matchCoeff(r), bonusPoints(o, r)
FILTERS matches(o, r)
;

ऑडियंस सेटिंग, उदाहरण के लिए, चैंपियंस लीग के लिए आपको इस तरह सेट करने की आवश्यकता है:

आइए एक फॉर्म ड्रा करें जो रेटिंग प्रदर्शित करेगा, जहां टीमों को प्रत्येक देश के लिए दिखाया जाएगा, और प्रत्येक टीम को उसके मैचों के लिए:

FORM countryCoefficientUEFA ' UEFA'
OBJECTS s = Season
FILTERS index(s) <= 5

OBJECTS c = Country
PROPERTIES (c) READONLY name, rating
PROPERTIES (s, c) COLUMNS (s) points HEADER ' : ' + name(s), teams HEADER ' : ' + name(s)

OBJECTS t = Team
PROPERTIES (t) READONLY nameCountry, name
PROPERTIES (s,t) COLUMNS (s) HEADER name(s) points BACKGROUND matchesUL(s, t)
FILTERGROUP country
FILTER ' ' country(t) = c DEFAULT

OBJECTS m = Match
PROPERTIES (m) READONLY dateTime, nameTournament, nameSeason, nameRound,
nameHomeTeam,
goalsHome BACKGROUND goalsHome(m) > goalsAway(m),
goalsAway BACKGROUND goalsHome(m) < goalsAway(m),
nameAwayTeam
FILTERS played(t, m)
ORDER dateTime(m) DESC
;

DESIGN countryCoefficientUEFA {
OBJECTS {
NEW countryDetails {
type = SPLITH ;
fill = 0.5 ;
MOVE BOX (t);
MOVE BOX (m);
}
}

}

NAVIGATOR {
NEW countryCoefficientUEFA;
}

परिणामी रूप इस तरह दिखेगा:

क्लबों के टेबल में रंग दिखाता है जब उसने सीजन में भाग लिया, और मैचों की तालिका में - कौन जीता।
तस्वीर से पता चलता है कि 2018 के लिए रेटिंग की गणना बिल्कुल वैसी ही है जैसी विकिपीडिया पर की गई है। पिछले वर्षों के लिए, जैसा कि ऊपर बताया गया है, फुटबॉल एपीआई सभी जानकारी प्रदान नहीं करता है।

परिणाम

हमने एक छोटा अनुप्रयोग बनाया है जो उपरोक्त कोड द्वारा पूरी तरह से वर्णित है और पोस्टग्रेक्यूक्यू में अपना डेटा संग्रहीत करता है, डेटा देखने और संपादित करने के लिए एक वेब इंटरफ़ेस प्रदान करता है। एक ही समय में, यह बड़े संस्करणों पर प्रभावी ढंग से काम करेगा, क्योंकि सभी रूप केवल दृश्यमान विंडो को पढ़ते हैं। बॉक्स से बाहर फिल्टर, छांटना, एक्सेल पर अपलोड करना, और बहुत कुछ हैं।

यह ध्यान दिया जाना चाहिए कि प्लेटफॉर्म का उपयोग करके गुणांक की गणना के कार्य को व्यक्तिगत गुणों में कैसे विघटित किया गया था। जब निष्पादित किया जाता है, तो यह सभी तर्क एसक्यूएल प्रश्नों में अनुवादित किए जाएंगे, और सभी गणना सीधे सभी डीबीएमएस अनुकूलन का उपयोग करके डेटाबेस सर्वर पर किया जाएगा।

इस बात का एक उदाहरण है कि आवेदन किस तरह से लोड किए गए डेटा के साथ काम करता है: https://demo.lsfusion.org/euroleague पर । पासवर्ड के बिना अतिथि लॉगिन। उपयोगकर्ता आसानी से मोड में है।

जो लोग खुद को स्थानीय रूप से सब कुछ सेट कर सकते हैं और उदाहरण के लिए, भविष्य के मैचों के परिणामों को दर्ज करके गुणांक को मॉडल करते हैं। ऊपर वर्णित सभी एप्लिकेशन मॉड्यूल जीथब पर होस्ट किए गए हैं। स्वचालित स्थापना के बाद, आपको बस इन फ़ाइलों को निर्देशों से उपयुक्त फ़ोल्डर में पॉप अप करना होगा और सर्वर को पुनरारंभ करना होगा।

फुटबॉल एपीआई से डेटा डाउनलोड करने के लिए, आपको उनके साथ पंजीकरण करने और एपीआई कुंजी प्राप्त करने की आवश्यकता है। इसके लिए एक कार्ड की आवश्यकता होती है, लेकिन यदि आप प्रति दिन 50 से अधिक अनुरोध नहीं करते हैं, तो इससे कुछ भी नहीं काटा जाएगा।

इसके अलावा, आप इस एप्लिकेशन को साइट पर उपयुक्त अनुभाग में ऑनलाइन चला सकते हैं। प्लेटफ़ॉर्म टैब पर, यूईएफए ऑड्स गणना उदाहरण का चयन करें और प्ले पर क्लिक करें।

वैसे, अगर किसी को कुछ सरल प्रणाली को लागू करने की आवश्यकता है जिसके लिए एक्सेल अब उपयुक्त नहीं है, तो टिप्पणियों में लिखें। मंच की क्षमताओं को सीखने के लिए, हम इसे लागू करने और संबंधित लेख लिखने का प्रयास करेंगे।

यूईएफए देश अनुपात गणना

डोमेन तर्क

डेटा आयात

गुणांक गणना

परिणाम

More articles: