emallson/scorecard - Change YNBZFYOVWGJNZEHKYDPHG225PTCYGF27LWBAJTVGWZTLPEPC474QC

log import handles pagination + partial imports. a partial import may occur when a log is loaded during live-logging

Created by emallson on February 25, 2021

YNBZFYOVWGJNZEHKYDPHG225PTCYGF27LWBAJTVGWZTLPEPC474QC

Dependencies

In channels

production

test

main

Change contents

Replacement in server/src/queries/reports.rs at line 12 [3.2692]
B:BD[3.2994] → [3.2994:3034]
```
    variables_derives = "Debug,Default"
```
[3.2994]
[3.3034]
```
    variables_derives = "Debug,Default,Clone"
```

Replacement in server/src/queries/reports.rs at line 30 [3.2692]

B:BD[3.3371] → [3.3371:3423]

) -> Result<Response<tier_reports::ResponseData>> {

[3.3371]

[3.3423]

) -> Result<Vec<tier_reports::TierReportsReportDataReportsData>> {

Insertion in server/src/queries/reports.rs at line 33 [3.2692]
[3.3482]
[3.3482]
```
        page: 1,
```

Replacement in server/src/queries/reports.rs at line 46 [3.2692]

B:BD[3.3697] → [3.3697:3926]

    client
        .post(WCL_ENDPOINT)
        .bearer_auth(&token.access_token)
        .json(&TierReports::build_query(vars))
        .send()
        .await?
        .json()
        .await
        .map_err(anyhow::Error::from)

[3.3697]

[3.3926]

    let mut results = vec![];
    loop {
        let cursor = client
            .post(WCL_ENDPOINT)
            .bearer_auth(&token.access_token)
            .json(&TierReports::build_query(vars.clone()))
            .send()
            .await?
            .json::<Response<tier_reports::ResponseData>>()
            .await?
            .data
            .and_then(|d| d.report_data)
            .and_then(|d| d.reports);
        let more = if let Some(c) = cursor.as_ref() {
            c.has_more_pages
        } else {
            false
        };
        if let Some(data) = cursor.and_then(|d| d.data) {
            results.extend(data.into_iter().filter_map(|d| d));
        }
        if !more {
            break;
        } else {
            vars.page += 1;
        }
    }
    Ok(results)

Insertion in server/src/import.rs at line 67 [3.9354]

[3.10918]

}
pub fn wcl_timestamp(time: f64) -> DateTime<Utc> {
    DateTime::from_utc(
        NaiveDateTime::from_timestamp((time / 1000.0) as i64, 0),
        Utc,
    )

Insertion in server/src/import.rs at line 76 [3.9354]

[3.10921]

// Import new logs. Does not update logs that may have been partially loaded. That is done
// separately by `replace_log`

Replacement in server/src/import.rs at line 81 [3.9354]

B:BD[3.10982] → [3.10982:11066]

    reports: &Vec<Option<reports::tier_reports::TierReportsReportDataReportsData>>,

[3.10982]

[3.11066]

    reports: &Vec<reports::tier_reports::TierReportsReportDataReportsData>,

Replacement in server/src/import.rs at line 88 [3.9354]

B:BD[3.11226] → [3.11226:11533]

B:BD[3.11533] → [4.1636:1943]

∅:D[4.1943] → [3.11708:11739]

B:BD[3.11708] → [3.11708:11739]

B:BD[3.11739] → [4.1944:2140]

∅:D[4.2140] → [3.11910:12161]

B:BD[3.11910] → [3.11910:12161]

                    if let Some(report) = report {
                        if report.zone.is_none() {
                            return None;
                        }
                        Some(NewLog {
                            code: report.code.clone(),
                            team: team.iid,
                            start_time: DateTime::from_utc(
                                NaiveDateTime::from_timestamp(
                                    (report.start_time / 1000.0) as i64,
                                    0,
                                ),
                                Utc,
                            ),
                            end_time: DateTime::from_utc(
                                NaiveDateTime::from_timestamp((report.end_time / 1000.0) as i64, 0),
                                Utc,
                            ),
                            title: report.title.clone(),
                            zone_id: report.zone.as_ref().unwrap().id as i32,
                        })
                    } else {
                        None

[3.11226]

[3.12161]

                    if report.zone.is_none() {
                        return None;

Insertion in server/src/import.rs at line 91 [3.9354]

[3.12183]


                    Some(NewLog {
                        code: report.code.clone(),
                        team: team.iid,
                        start_time: wcl_timestamp(report.start_time),
                        end_time: wcl_timestamp(report.end_time),
                        title: report.title.clone(),
                        zone_id: report.zone.as_ref().unwrap().id as i32,
                    })

Insertion in server/src/import.rs at line 104 [3.9354]

[3.12284]

        .execute(con)?;
    Ok(())
}
pub fn replace_log(
    con: &PgConnection,
    report: &reports::tier_reports::TierReportsReportDataReportsData,
) -> Result<()> {
    diesel::update(logs::table.filter(logs::code.eq(&report.code)))
        .set(logs::end_time.eq(wcl_timestamp(report.end_time)))

Replacement in server/src/graphql.rs at line 4 [3.13630]
∅:D[5.801] → [3.13631:13693]
∅:D[6.1437] → [3.13631:13693]
B:BD[3.13630] → [3.13631:13693]
```
use crate::import::{import_fights, import_logs, import_tags};
```
[6.1437]
[2.591]
```
use crate::import::{import_fights, import_logs, import_tags, replace_log, wcl_timestamp};
```

Replacement in server/src/graphql.rs at line 265 [3.13630]

B:BD[3.15527] → [3.15527:15593]

fn have_log(con: &PgConnection, code_: &str) -> AnyResult<bool> {

[3.15527]

[4.3932]

fn have_log(con: &PgConnection, code_: &str, end_time_: f64) -> AnyResult<bool> {

Replacement in server/src/graphql.rs at line 271 [3.13630]

B:BD[4.4060] → [4.4060:4098]

        .filter(logs::code.eq(code_))

[4.4060]

[4.4098]

        .filter(
            logs::code
                .eq(code_)
                .and(logs::end_time.eq(wcl_timestamp(end_time_))),
        )

Deletion in server/src/graphql.rs at line 314 [3.13630]

B:BD[3.16958] → [3.16958:17100]


    let reports = reports
        .data
        .and_then(|d| d.report_data)
        .and_then(|d| d.reports)
        .and_then(|d| d.data);

Replacement in server/src/graphql.rs at line 315 [3.13630]
B:BD[3.17101] → [3.17101:17128]
```
    if reports.is_none() {
```
[3.17101]
[3.17128]
```
    if reports.is_empty() {
```
Deletion in server/src/graphql.rs at line 324 [3.13630]
B:BD[3.17395] → [3.17395:17431]
```
    let reports = reports.unwrap();
```

Replacement in server/src/graphql.rs at line 331 [3.13630]

B:BD[3.17589] → [3.17589:17717]

    for (ix, report) in reports
        .into_iter()
        .enumerate()
        .filter(|(_, report)| report.is_some())
    {

[3.17589]

[3.17717]

    for (ix, report) in reports.into_iter().enumerate() {

Deletion in server/src/graphql.rs at line 333 [3.13630]
B:BD[3.17770] → [3.17770:17808]
```
        let report = report.unwrap();
```

Replacement in server/src/graphql.rs at line 334 [3.13630]

B:BD[3.17809] → [3.17809:17853]

        if have_log(&*con, &report.code)? {

[3.17809]

[3.17853]

        if have_log(&*con, &report.code, report.end_time)? {

Insertion in server/src/graphql.rs at line 343 [3.13630]

[3.18143]

        } else {
            // log is missing one or more fights
            debug!("log {} missing some fights. reloading.", &report.code);
            replace_log(&*con, &report)?;

Replacement in server/queries/tier_reports.graphql at line 1 [7.303691]

B:BD[7.303691] → [7.303692:303762]

query TierReports($guild: Int = 0, $guildTag: Int = 0, $zone: Int!) {

[7.303691]

[7.303762]

query TierReports($guild: Int = 0, $guildTag: Int = 0, $zone: Int!, $page: Int!) {

Replacement in server/queries/tier_reports.graphql at line 3 [7.303691]

B:BD[7.303777] → [7.303777:303846]

    reports(guildID: $guild, guildTagID: $guildTag, zoneID: $zone) {

[7.303777]

[7.303846]

    reports(guildID: $guild, guildTagID: $guildTag, zoneID: $zone, page: $page) {