@rasifix/orienteering-utils 1.0.6 → 2.0.0

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@rasifix/orienteering-utils",
-  "version": "1.0.6",
+  "version": "2.0.0",
   "description": "utility functions for orienteering result analyzis",
   "main": "index",
   "typings": "index",
   "scripts": {
-    "test": "mocha test/test.js"
+    "test": "mocha test/test.js",
+    "build": "tsc"
   },
   "keywords": [
     "orienteering"
@@ -19,5 +20,12 @@
   "dependencies": {
     "chai": "^4.3.6",
     "mocha": "^9.2.1"
+  },
+  "devDependencies": {
+    "@types/chai": "^5.2.3",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^16.0.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^4.5.5"
   }
 }

package/src/format.ts

@@ -0,0 +1,11 @@
+import { Competition } from "./model/competition";
+
+export interface Format {
+
+    check(content:string):boolean;
+
+    parse(content:string, options:any):Competition;
+
+    serialize(competition:Competition):string;
+
+}

package/src/formats/index.ts

@@ -0,0 +1,9 @@
+import * as kraemer from './kraemer';
+import * as oware from './oware';
+import * as solv from './solv';
+
+export {
+    kraemer,
+    oware,
+    solv
+}

package/src/formats/kraemer.ts

@@ -0,0 +1,145 @@
+import { Format } from "../format";
+import { Category } from "../model/category";
+import { Competition } from "../model/competition";
+import { Runner } from "../model/runner";
+import { parseTime, formatTime } from "../time";
+
+function strip(str: string | undefined) {
+  if (!str) {
+    return "";
+  } else if (str.length > 0 && str[0] === '"') {
+    return str.substring(1, str.length - 1);
+  } else {
+    return str;
+  }
+}
+
+export class KraemerFormater implements Format {
+  // OE0014;Stnr;XStnr;Chipnr;Datenbank Id;Nachname;Vorname;Jg;G;Block; AK;	Start;Ziel;	 Zeit;		Wertung;Gutschrift -;Zuschlag +;Kommentar;Club-Nr.;Abk; Ort; Nat; Sitz;Region;Katnr;Kurz; Lang;		 MeldeKat. Nr;MeldeKat. (kurz);MeldeKat. (lang);Rang;Ranglistenpunkte;Num1;Num2; Num3;		 Text1;	 Text2;		Text3;	Adr. Nachname;Adr. Vorname;Straße;Zeile2;PLZ;				Adr. Ort;Tel;				 Mobil;			Fax;		EMail;	 Gemietet;Startgeld;Bezahlt;Mannschaft;Bahnnummer;Bahn;	 km;		 Hm;			Bahn Posten;Platz;	 Startstempel;Zielstempel;Posten1;Stempel1;Posten2;Stempel2;Posten3; Stempel3;Posten4;Stempel4;Posten5;Stempel5;Posten6;Stempel6;Posten7;Stempel7;Posten8;Stempel8;Posten9;Stempel9;Posten10;Stempel10;Posten11;Stempel11;Posten12;Stempel12;Posten13;Stempel13;Posten14;Stempel14;Posten15;Stempel15;Posten16;Stempel16;Posten17;Stempel17;Posten18;Stempel18;Posten19;Stempel19;Posten20;Stempel20;Posten21;Stempel21;Posten22;Stempel22;Posten23;Stempel23;Posten24;Stempel24;Posten25;Stempel25;Posten26;Stempel26;Posten27;Stempel27;Posten28;Stempel28;Posten29;Stempel29;Posten30;Stempel30;Posten31;Stempel31;Posten32;Stempel32;Posten33;Stempel33;Posten34;Stempel34;Posten35;Stempel35;Posten36;Stempel36;Posten37;Stempel37;Posten38;Stempel38;Posten39;Stempel39;Posten40;Stempel40;Posten41;Stempel41;Posten42;Stempel42;Posten43;Stempel43;Posten44;Stempel44;Posten45;Stempel45;Posten46;Stempel46;Posten47;Stempel47;Posten48;Stempel48;Posten49;Stempel49;Posten50;Stempel50;Posten51;Stempel51;Posten52;Stempel52;Posten53;Stempel53;Posten54;Stempel54;Posten55;Stempel55;Posten56;Stempel56;Posten57;Stempel57;Posten58;Stempel58;Posten59;Stempel59;Posten60;Stempel60;Posten61;Stempel61;Posten62;Stempel62;Posten63;Stempel63;Posten64;Stempel64;
+  // Stnr	;Chip;Datenbank Id;Nachname;Vorname;Jg;G;Block;AK;Start;Ziel;Zeit; Wertung;Club-Nr.;Abk;		Ort;				 Nat;			 Katnr;		Kurz;		Lang;Num1;Num2;Num3;Text1; Text2;Text3;Adr. Name;Straße;			Zeile2;					PLZ;						 Ort; Tel;						 Fax; EMail;Id/Verein;Gemietet;Startgeld;Bezahlt;Bahnnummer;	 Bahn;				km;		Hm;		Bahn Posten;Pl;			Startstempel;Zielstempel;Posten1;Stempel1;Posten2; Stempel2; Posten3;Stempel3;	Posten4;	Stempel4;Posten5;Stempel5;Posten6;		Stempel6;Posten7;		 Stempel7;	 Posten8;Stempel8;Posten9;Stempel9;Posten10;Stempel10;(und weitere)...
+  parse(text: string, options: any = {}) {
+    // split text into lines
+    var lines = text.split(/\r?\n|\r|\n/g);
+
+    // extract header
+    var header = lines[0].split(";");
+    var firstTimeIdx: number;
+
+    // trying to get hold of correct column indices
+    var indices: { [key: string]: number } = {};
+    indices["Melde Id"] = header.indexOf("Melde Id");
+    indices["Nachname"] = header.indexOf("Nachname");
+    indices["Vorname"] = header.indexOf("Vorname");
+    indices["Jg"] = header.indexOf("Jg");
+    indices["G"] = header.indexOf("G");
+    indices["Datenbank Id"] = header.indexOf("Datenbank Id");
+    indices["Abk"] = header.indexOf("Abk");
+    indices["Club"] = header.indexOf("Ort");
+    indices["Ort"] = header.indexOf("Adr. Ort");
+    indices["Nat"] = header.indexOf("Nat");
+    indices["Start"] = header.indexOf("Start");
+    indices["Ziel"] = header.indexOf("Ziel");
+    indices["Zeit"] = header.indexOf("Zeit");
+    indices["Katnr"] = header.indexOf("Kurz");
+    indices["Rang"] = header.indexOf("Rang");
+    indices["Wertung"] = header.indexOf("Wertung");
+    indices["Posten"] = header.indexOf("Bahn Posten");
+    indices["km"] = header.indexOf("km");
+    indices["hm"] = header.indexOf("Hm");
+    firstTimeIdx = header.indexOf("Posten1");
+
+    if (header[0] === "OE0014") {
+      indices["Chip"] = header.indexOf("Chipnr");
+    } else {
+      indices["Chip"] = header.indexOf("Chip");
+    }
+
+    lines = lines.slice(1);
+
+    // the result object
+    var categories: { [key: string]: Category } = {};
+
+    function objectify(cols: string[]): any {
+      var result: any = {};
+      Object.keys(indices).forEach(function (key) {
+        result[key] = cols[indices[key]];
+      });
+      return result;
+    }
+
+    lines.forEach(function (line) {
+      var cols = line.split(";");
+      var lineObj = objectify(cols);
+
+      if (lineObj["Wertung"] !== "0") {
+        return;
+      }
+
+      let categoryName = strip(lineObj["Katnr"]);
+      let runnerName = strip(lineObj["Nachname"]);
+      let runnerFirstname = strip(lineObj["Vorname"]);
+
+      let runTime = parseTime(lineObj["Zeit"]);
+      let startTime = parseTime(lineObj["Start"]);
+
+      var runner: Runner = {
+        id: lineObj["Melde Id"],
+        category: categoryName,
+        firstName: runnerFirstname,
+        name: runnerName,
+        fullName: [runnerFirstname, runnerName].join(" "),
+        yearOfBirth: lineObj["Jg"],
+        club: (strip(lineObj["Abk"]) + " " + strip(lineObj["Club"])).trim(),
+        city: strip(lineObj["Ort"]),
+        nation: strip(lineObj["Nat"]),
+        time: formatTime(runTime) || "",
+        startTime: formatTime(startTime) || "",
+        splits: [],
+      };
+
+      var category = categories[categoryName];
+      if (typeof category === "undefined") {
+        category = {
+          name: strip(lineObj["Katnr"]),
+          distance: parseInt(strip(lineObj["km"]), 10) * 1000,
+          ascent: parseInt(strip(lineObj["hm"])),
+          controls: parseInt(strip(lineObj["Posten"])),
+          runners: [],
+        };
+        categories[category.name] = category;
+      }
+
+      var times = cols.slice(firstTimeIdx);
+      for (var idx = 0; idx < parseInt(lineObj["Posten"], 10) * 2; idx += 2) {
+        if (idx === times.length - 1) {
+          continue;
+        }
+        const parsedTime = parseTime(times[idx + 1]);
+        runner.splits.push({ code: times[idx], time: formatTime(parsedTime) });
+      }
+
+      category.runners.push(runner);
+    });
+
+    return {
+      name: options.event || "Anonymous Event",
+      map: options.map || "Unknown Map",
+      date: options.date || "",
+      startTime: options.startTime || "",
+      categories: Object.keys(categories).map(function (category) {
+        return categories[category];
+      }),
+    };
+  }
+
+  check(text: string) {
+    return (
+      text.substring(0, 6) === "OE0014" ||
+      text.substring(0, 23) === "Stnr;Chip;Datenbank Id;"
+    );
+  }
+
+  serialize(competition: Competition): string {
+    throw new Error("format does not implement serialization");
+  }
+}

package/src/formats/oware.ts

@@ -0,0 +1,143 @@
+import { Format } from "../format";
+import { Category } from "../model/category";
+import { Competition } from "../model/competition";
+import { Runner } from "../model/runner";
+
+function parseCategory(row: string[]) {
+  return {
+    name: row[0],
+    distance: parseInt(row[1], 10),
+    ascent: parseInt(row[2], 10),
+    controls: parseInt(row[3], 10),
+    runners: [],
+  };
+}
+
+function parseRunner(row: string[], category: string, id: number):Runner {
+  var headerLength = 15;
+  var i;
+
+  var splits = [];
+  for (i = headerLength; i < row.length; i += 2) {
+    splits.push({ code: row[i], time: row[i + 1] });
+  }
+
+  // split cleanup - detect two following splits with identical time
+  // --> control not working properly; set 's' as split time (substitute)
+  // going from back to front to catch several not working controls
+  for (i = splits.length - 1; i > 0; i--) {
+    if (splits[i].time === splits[i - 1].time && splits[i].time !== "-") {
+      splits[i].time = "s";
+    }
+  }
+
+  return {
+    id: id,
+    category: category,
+    rank: row[0] ? parseInt(row[0]) : undefined,
+	firstName: row[2],
+	name: row[1],
+    fullName: [row[2], row[1]].join(" "),
+    yearOfBirth: row[3],
+    club: row[8],
+    city: row[7],
+    nation: row[9],
+    time: row[12],
+    startTime: row[13],
+    splits: splits,
+  };
+}
+
+export class OwareFormat implements Format {
+  parse(text: string):Competition {
+    // split text into lines
+    var lines = text.trim().split(/[\r\n]+/);
+
+    // throw away first row containing headers
+    lines = lines.splice(1);
+
+    // second row contains information about the event
+    var header = lines[0].split(";");
+
+    var competition: Competition = {
+      // row starts with a double slash
+      name: header[0].substring(2, header[0].length),
+      map: header[1],
+      date: header[2],
+      startTime: header[3],
+      categories: [],
+    };
+
+    // throw a way the now parsed header
+    lines = lines.splice(1);
+
+    var category: Category;
+
+    let idx = 0;
+    lines
+      .filter((line) => line.trim().length > 0)
+      .forEach(function (line) {
+        var cols = line.split(";");
+        if (cols.length === 4) {
+          category = parseCategory(cols);
+          competition.categories.push(category);
+        } else {
+          category.runners.push(parseRunner(cols, category.name, ++idx));
+        }
+      });
+
+    return competition;
+  }
+
+  serialize(event: Competition) {
+    var result =
+      "//Format: Rank;Name;Firstname;YearOfBirth;SexMF;FedNr;Zip;Town;Club;NationIOF;StartNr;eCardNr;RunTime;StartTime;FinishTime;CtrlCode;SplitTime; ...\n";
+    result +=
+      "//" +
+      [event.name, event.map, event.date, event.startTime, ""].join(";") +
+      "\n";
+
+    event.categories.forEach(function (category) {
+      result +=
+        [
+          category.name,
+          category.distance,
+          category.ascent,
+          category.controls,
+        ].join(";") + "\n";
+      category.runners.forEach(function (runner) {
+        result += [
+          runner.rank,
+          runner.fullName,
+          "",
+          runner.yearOfBirth,
+          "",
+          "",
+          "",
+          runner.city,
+          runner.club,
+          runner.nation,
+          "",
+          "", // ecard
+          runner.time,
+          runner.startTime,
+          "",
+        ].join(";");
+        result +=
+          ";" +
+          runner.splits
+            .map(function (split) {
+              return split.code + ";" + split.time;
+            })
+            .join(";") +
+          "\n";
+      });
+    });
+
+    return result;
+  }
+
+  check(text: string) {
+    return text.substring(0, 8) === "//Format";
+  }
+}

package/src/formats/solv.ts

@@ -0,0 +1,169 @@
+import { Format } from "../format";
+import { Category } from "../model/category";
+import { Competition } from "../model/competition";
+import { Runner } from "../model/runner";
+import { formatTime, parseTime } from "../time";
+
+function reformatTime(str: string): string | undefined {
+  // "special" total times (like wrong or missing control)
+  if (str.indexOf(":") === -1) {
+    return str;
+  }
+
+  const parsed = parseTime(str);
+  return parsed ? formatTime(parsed) : undefined;
+}
+
+function reformatSplitTime(str: string): string | undefined {
+  // normalize missing punch time
+  if (str === "-" || str === "-----") {
+    return "-";
+  }
+
+  // normalize not working control
+  if (str === "0.00") {
+    return "s";
+  }
+
+  const parsed = parseTime(str);
+  return parsed ? formatTime(parsed) : undefined;
+}
+
+// flat csv file format - every row contains full info including category
+// Kategorie;Laenge;Steigung;PoAnz;Rang;Name;Jahrgang;Ort;Club;Zeit;Startzeit;Zielzeit;Zwischenzeiten
+export class SolvFormat implements Format {
+  parse(text: string, options: any = {}) {
+    const categories: { [key: string]: Category } = {};
+
+    const lines = text.split("\n");
+
+    // drop header column
+    lines.splice(0, 1)[0].split(";");
+
+    lines.forEach(function (line, idx) {
+      const tokens = line.split(";");
+      if (tokens.length < 11) {
+        // invalid input? not enough data for runner
+        return;
+      }
+
+      const categoryName = tokens[0];
+      let category = categories[categoryName];
+      if (!category) {
+        category = {
+          name: categoryName,
+          distance: Math.round(parseFloat(tokens[1]) * 1000),
+          ascent: parseInt(tokens[2]),
+          controls: parseInt(tokens[3]),
+          runners: [],
+        };
+        categories[categoryName] = category;
+      }
+
+      const name = tokens[5].split(" ");
+      const runner:Runner = {
+        id: idx,
+        category: categoryName,
+        rank: tokens[4] ? parseInt(tokens[4]) : undefined,
+        firstName: name[0],
+        name: name.slice(1).join(" "),
+        fullName: tokens[5],
+        yearOfBirth: tokens[6],
+        city: tokens[7],
+        club: tokens[8],
+        time: reformatTime(tokens[9]),
+        startTime: tokens[10],
+        splits: [],
+      };
+
+      if (tokens.length - 12 < category.controls * 2) {
+        // some crappy SOLV data...
+        console.log(
+          "fix crappy data from SOLV - not enough tokens on line for runner " +
+            runner.fullName
+        );
+        for (var i = tokens.length; i < category.controls * 2 + 12; i++) {
+          if (i % 2 === 0) {
+            tokens[i] =
+              category.runners.length === 0
+                ? "???"
+                : category.runners[0].splits[(i - 12) / 2].code;
+          } else {
+            tokens[i] = "-";
+          }
+        }
+      }
+
+      for (let i = 12; i < tokens.length - 1; i += 2) {
+        let time = reformatSplitTime(tokens[i + 1]);
+        if (runner.splits.length > 0 && time) {
+          let prev = runner.splits[runner.splits.length - 1].time;
+          let parsedTime = parseTime(tokens[i + 1]);
+          if (
+            time === prev ||
+            tokens[i + 1] === "0.00" || (parsedTime && parsedTime > 180 * 60)) {
+            // normalize valid manual punches
+            time = "s";
+          }
+        }
+        runner.splits.push({ code: tokens[i], time: time });
+      }
+
+      category.runners.push(runner);
+    });
+
+    return {
+      name: options.event || "Anonymous Event",
+      map: options.map || "Unknown Map",
+      date: options.date || "",
+      startTime: options.startTime || "",
+      categories: Object.keys(categories).map(function (category) {
+        return categories[category];
+      }),
+    };
+  }
+
+  serialize(competition: Competition) {
+    var result =
+      "Kategorie;Laenge;Steigung;PoAnz;Rang;Name;Jahrgang;Ort;Club;Zeit;Startzeit;Zielzeit;Zwischenzeiten\n";
+
+    competition.categories.forEach(function (category) {
+      category.runners.forEach(function (runner) {
+        const distance = category.distance
+          ? category.distance
+          : null;
+        const runTime = parseTime(runner.time);
+        const startTime = parseTime(runner.startTime);
+        const finishTime = runTime && startTime ? formatTime(runTime + startTime) : '';
+        result += [
+          category.name,
+          distance,
+          category.ascent,
+          category.controls,
+          runner.rank,
+          runner.fullName,
+          runner.yearOfBirth,
+          runner.city,
+          runner.club,
+          runner.time,
+          runner.startTime,
+          finishTime,
+        ].join(";");
+        result +=
+          ";" +
+          runner.splits
+            .map(function (split) {
+              return split.code + ";" + split.time;
+            })
+            .join(";") +
+          "\n";
+      });
+    });
+
+    return result;
+  }
+
+  check(text: string) {
+    return text.indexOf("Kategorie;Laenge;Steigung;PoAnz;Rang;") === 0;
+  }
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+ import * as formats from './formats';
+
+ export {
+     formats
+ }

package/src/model/category.ts

@@ -0,0 +1,9 @@
+import { Runner } from "./runner";
+
+export interface Category {
+    name: string;
+    distance?: number;
+    ascent?: number;
+    controls: number;
+    runners: Runner[];
+}

package/src/model/competition.ts

@@ -0,0 +1,9 @@
+import { Category } from "./category";
+
+export interface Competition {
+    name: string;
+    map?: string;
+    date: string;
+    startTime: string;
+    categories: Category[];
+}

package/src/model/ranking.ts

@@ -0,0 +1,83 @@
+export interface Ranking {
+    /* indexed information about runners */
+    runners: { [key:string]: RunnerInfo },
+
+    /* extracted information about all legs found */
+    legs: { [key:string]: Leg },
+
+    /* this is the overall ranking of the given runners */
+    ranking: RankingEntry[]
+}
+
+export interface Leg {
+    from: string;
+    to: string;
+    ranking: RankingEntry[];
+}
+
+export interface RankingEntry {
+    rank: number;
+    time: string;
+    runnerRef: string;
+}
+
+export interface RunnerInfo {
+    fullName: string;
+    club: string;
+    city: string;
+    category: string;
+    course: string[];
+    startTime: string;
+}
+
+
+const sample:Ranking = {
+    runners: {
+        "22": {
+            fullName: "Hans Dobeli",
+            club: "OLG Hopp Hopp",
+            city: "Witzwil",
+            category: "HB",
+            startTime: "01:33:00",
+            course: [ "St", "31", "32", "33", "Zi" ]
+        },
+        "23": {
+            fullName: "Fritz Berger",
+            club: "OLV Chapf",
+            city: "Langnau",
+            category: "HB",
+            startTime: "00:55:00",
+            course: [ "St", "31", "32", "33", "Zi" ]
+        }
+    },
+    legs: {
+        "St-31": {
+            from: "St",
+            to: "31",
+            ranking: [
+                {
+                    rank: 1,
+                    time: "02:33",
+                    runnerRef: "22"
+                },
+                {
+                    rank: 2,
+                    time: "08:02",
+                    runnerRef: "23"
+                }
+            ]
+        }
+    },
+    ranking: [
+        {
+            rank: 1,
+            runnerRef: "22",
+            time: "38:22"
+        },
+        {
+            rank: 2,
+            runnerRef: "23",
+            time: "46:44"
+        }
+    ]
+}

package/src/model/runner.ts

@@ -0,0 +1,23 @@
+import { Split } from "./split";
+
+export interface Runner {
+  id: number;
+  category: string;
+  rank?: number;
+  name: string;
+  firstName: string;
+  fullName: string;
+  yearOfBirth?: string;
+  sex?: Sex;
+  city?: string;
+  nation?: string;
+  club?: string;
+  time?: string;
+  startTime: string;
+  splits: Split[];
+}
+
+export enum Sex {
+    male = 'm',
+    female = 'f'
+}

package/src/model/split.ts

@@ -0,0 +1,4 @@
+export interface Split {
+    code: string;
+    time: string|undefined;
+}

package/{lib/time.js → src/time.ts}

@@ -1,4 +1,4 @@
-function pad(value) {
+function pad(value:number) {
     return value < 10 ? '0' + value : value;
 };
   
@@ -12,17 +12,17 @@ var regex = /(-)?[0-9]?[0-9]:[0-9][0-9](:[0-9][0-9])?/;
  * @param str input string
  * @returns the number of seconds in the given input string or null if input is not parseable
  */
-module.exports.parseTime = function(str) {
+export function parseTime(str:string|undefined):number|undefined {
     if (!str) {
-        return null;
+        return undefined;
     } else if (typeof str !== 'string') {
-        return null;
+        return undefined;
     } else if (!regex.test(str)) {
-        return null;
+        return undefined;
     }
   
     var split = str.split(":");
-    var result = null;
+    var result:number = NaN;
     if (split.length === 2) {
         var negative = split[0][0] === '-';
         var minutes = parseInt(split[0], 10);
@@ -31,10 +31,13 @@ module.exports.parseTime = function(str) {
         result = parseInt(split[0], 10) * 3600 + parseInt(split[1], 10) * 60 + parseInt(split[2], 10);
     }
     
-    return isNaN(result) ? null : result;
+    return isNaN(result) ? undefined : result;
 }
   
-module.exports.formatTime = function(seconds) {
+export function formatTime(seconds:number|undefined) {
+    if (!seconds) {
+        return undefined;
+    }
     const sign = seconds < 0 ? '-' : '';
     const value = Math.abs(seconds);
     if (value >= 3600) {