text-to-map 1.1.17 → 1.1.19

package/dist/bin/parse-ordinance.js

@@ -8,7 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { readFileSync, writeFileSync } from "fs";
-import { getNewMunicipality, parseOrdinanceToAddressPoints, } from "../street-markdown/smd";
+import { getNewMunicipalityByName, parseOrdinanceToAddressPoints, } from "../street-markdown/smd";
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
         // take first node argument as a file name
@@ -35,10 +35,16 @@ function main() {
             warningCount++;
         };
         console.time("downloadAndImportAllLatestAddressPoints");
-        const { municipality } = yield getNewMunicipality("Česká Lípa");
-        const addressPoints = yield parseOrdinanceToAddressPoints(lines, {
-        // currentMunicipality: municipality,
-        }, reportErrors, reportWarnings);
+        const { municipality } = yield getNewMunicipalityByName("Česká Lípa");
+        const addressPoints = yield parseOrdinanceToAddressPoints({
+            lines,
+            initialState: {
+            // currentMunicipality: municipality,
+            },
+            onError: reportErrors,
+            onWarning: reportWarnings,
+            includeUnmappedAddressPoints: true,
+        });
         console.timeEnd("downloadAndImportAllLatestAddressPoints");
         console.log(`Parsed ${lines.length} lines, ${errorCount} errors, ${warningCount} warnings.`);
         if (errorCount > 0) {

package/dist/db/founders.d.ts

@@ -1,6 +1,10 @@
 import { DbMunicipalityResult, MunicipalityPartResult, SmdError } from "../street-markdown/types";
 import { Founder, MunicipalityType } from "./types";
 export declare const insertFounders: (founders: Founder[]) => Promise<number>;
+export declare const getFounderById: (id: number) => Promise<{
+    founder: Founder;
+    errors: SmdError[];
+}>;
 export declare const findFounder: (nameWithHashtag: string) => Promise<{
     founder: Founder;
     errors: SmdError[];

package/dist/db/founders.js

@@ -223,14 +223,27 @@ const extractFounderName = (line) => {
         return line.trim();
     }
 };
-export const findFounder = (nameWithHashtag) => __awaiter(void 0, void 0, void 0, function* () {
-    const errors = [];
-    const name = extractFounderName(nameWithHashtag);
-    const result = yield getKnexDb()
+const getBaseFounderQuery = () => {
+    return getKnexDb()
         .select("f.id", "f.name", "f.ico", "f.founder_type_code", "f.city_code", "f.city_district_code")
         .from("founder as f")
         .leftJoin("city as c", "c.code", "f.city_code")
-        .leftJoin("city_district as d", "d.code", "f.city_district_code")
+        .leftJoin("city_district as d", "d.code", "f.city_district_code");
+};
+export const getFounderById = (id) => __awaiter(void 0, void 0, void 0, function* () {
+    const result = yield getBaseFounderQuery().where("f.id", id).first();
+    const founder = yield resultToFounder(result);
+    return {
+        founder: founder !== null && founder !== void 0 ? founder : null,
+        errors: founder
+            ? []
+            : [wholeLineError(`Zřizovatel s id ${id} neexistuje.`, "")],
+    };
+});
+export const findFounder = (nameWithHashtag) => __awaiter(void 0, void 0, void 0, function* () {
+    const errors = [];
+    const name = extractFounderName(nameWithHashtag);
+    const result = yield getBaseFounderQuery()
         .where("f.name", name)
         .orWhere("c.name", name)
         .orWhere("d.name", name)

package/dist/street-markdown/smd.d.ts

@@ -1,10 +1,17 @@
 import { Founder } from "../db/types";
-import { ErrorCallbackParams, Municipality, MunicipalityWithFounder, ProcessLineCallbackParams, School, SmdError, SmdState } from "./types";
-export declare const parseOrdinanceToAddressPoints: (lines: string[], initialState?: Partial<SmdState>, onError?: (params: ErrorCallbackParams) => void, onWarning?: (params: ErrorCallbackParams) => void, onProcessedLine?: (params: ProcessLineCallbackParams) => void) => Promise<Municipality[]>;
+import { ErrorCallbackParams, Municipality, MunicipalityWithFounder, MunicipalityWithFounderResult, ProcessLineCallbackParams, School, SmdError, SmdState } from "./types";
+interface ParseOrdinanceProps {
+    lines: string[];
+    initialState?: Partial<SmdState>;
+    onError?: (params: ErrorCallbackParams) => void;
+    onWarning?: (params: ErrorCallbackParams) => void;
+    onProcessedLine?: (params: ProcessLineCallbackParams) => void;
+    includeUnmappedAddressPoints: boolean;
+}
+export declare const parseOrdinanceToAddressPoints: ({ lines, initialState, onError, onWarning, onProcessedLine, includeUnmappedAddressPoints, }: ParseOrdinanceProps) => Promise<Municipality[]>;
 export declare const convertMunicipality: (municipality: MunicipalityWithFounder) => Municipality;
-export declare const getNewMunicipality: (name: string) => Promise<{
-    municipality: MunicipalityWithFounder;
-    errors: SmdError[];
-}>;
+export declare const getNewMunicipalityByName: (name: string) => Promise<MunicipalityWithFounderResult>;
+export declare const getNewMunicipalityByFounderId: (founderId: number) => Promise<MunicipalityWithFounderResult>;
 export declare const getNewSchool: (name: string, founder: Founder | null, lineNumber: number, onError: (params: ErrorCallbackParams) => void) => Promise<School>;
 export declare const wholeLineError: (message: string, line: string) => SmdError;
+export {};

package/dist/street-markdown/smd.js

@@ -9,18 +9,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { checkStreetExists, findAddressPoints, getAddressPointById, } from "../db/address-points";
 import { disconnectKnex } from "../db/db";
-import { findFounder } from "../db/founders";
+import { findFounder, getFounderById } from "../db/founders";
 import { findSchool } from "../db/schools";
 import { founderToMunicipality } from "../db/types";
 import { getMunicipalityPartResult, getRestOfMunicipalityPart, getSwitchMunicipality, getWholeMunicipality, isMunicipalitySwitch, isRestOfMunicipalityLine, isRestOfMunicipalityPartLine, isRestWithNoStreetNameLine, isWholeMunicipality, } from "./municipality";
 import { parseLine } from "./smd-line-parser";
 import { isAddressPoint, } from "./types";
-export const parseOrdinanceToAddressPoints = (lines, initialState = {}, onError = () => { }, onWarning = () => { }, onProcessedLine = () => { }) => __awaiter(void 0, void 0, void 0, function* () {
+export const parseOrdinanceToAddressPoints = ({ lines, initialState = {}, onError = () => { }, onWarning = () => { }, onProcessedLine = () => { }, includeUnmappedAddressPoints = false, }) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const state = Object.assign({ currentMunicipality: null, currentFilterMunicipality: null, currentSchool: null, rests: {
                 noStreetNameSchoolIzo: null,
                 municipalityParts: [],
                 wholeMunicipalitySchoolIzo: null,
+                includeUnmappedAddressPoints,
             }, municipalities: [] }, initialState);
         let lineNumber = 1;
         for (const rawLine of lines) {
@@ -61,6 +62,7 @@ export const convertMunicipality = (municipality) => {
     return {
         municipalityName: municipality.municipalityName,
         schools: municipality.schools,
+        unmappedPoints: municipality.unmappedPoints,
     };
 };
 const processOneLine = (params) => __awaiter(void 0, void 0, void 0, function* () {
@@ -115,7 +117,7 @@ const processMunicipalityLine = ({ line, lineNumber, state, onError, }) => __awa
         state.currentSchool = null;
     }
     yield completeCurrentMunicipality(state);
-    const { municipality, errors } = yield getNewMunicipality(line);
+    const { municipality, errors } = yield getNewMunicipalityByName(line);
     if (errors.length > 0) {
         onError({ lineNumber, line, errors });
     }
@@ -210,14 +212,14 @@ const processAddressPointLine = ({ line, state, lineNumber, onError, onWarning,
         }
     }
 });
-const addRestToSchool = (restPoints, schoolIzo, state) => __awaiter(void 0, void 0, void 0, function* () {
+const addRestToSchool = (restPoints, schoolIzo, state) => {
     const addressPoints = state.currentMunicipality.schools.flatMap((school) => school.addresses);
     // filter out address points already present
     const remainingPoints = restPoints.filter((point) => !addressPoints.some((ap) => ap.address === point.address));
     // find the right school and add the remaining address points
     const schoolIndex = state.currentMunicipality.schools.findIndex((school) => school.izo === schoolIzo);
     state.currentMunicipality.schools[schoolIndex].addresses.push(...remainingPoints);
-});
+};
 const addRests = (state) => __awaiter(void 0, void 0, void 0, function* () {
     if (state.rests.noStreetNameSchoolIzo) {
         yield addRestWithNoStreetNameToSchool(state);
@@ -228,6 +230,9 @@ const addRests = (state) => __awaiter(void 0, void 0, void 0, function* () {
     for (const rest of state.rests.municipalityParts) {
         yield addRestOfMunicipalityPart(state, rest.municipalityPartCode, rest.schoolIzo);
     }
+    if (state.rests.includeUnmappedAddressPoints) {
+        yield addRestOfMunicipalityToUnmappedPoints(state);
+    }
     state.rests.noStreetNameSchoolIzo = null;
     state.rests.wholeMunicipalitySchoolIzo = null;
     state.rests.municipalityParts = [];
@@ -241,18 +246,23 @@ const addRestWithNoStreetNameToSchool = (state) => __awaiter(void 0, void 0, voi
             type: state.currentMunicipality.founder.municipalityType,
         },
     });
-    yield addRestToSchool(pointsNoStreetName, state.rests.noStreetNameSchoolIzo, state);
+    addRestToSchool(pointsNoStreetName, state.rests.noStreetNameSchoolIzo, state);
 });
 const addRestOfMunicipality = (state) => __awaiter(void 0, void 0, void 0, function* () {
+    addRestToSchool(yield getRestOfMunicipality(state), state.rests.wholeMunicipalitySchoolIzo, state);
+});
+const addRestOfMunicipalityToUnmappedPoints = (state) => __awaiter(void 0, void 0, void 0, function* () {
+    state.currentMunicipality.unmappedPoints = (yield getRestOfMunicipality(state)).map(mapAddressPointForExport);
+});
+const getRestOfMunicipality = (state) => __awaiter(void 0, void 0, void 0, function* () {
     // get all address points for current municipality
-    const allPoints = yield findAddressPoints({
+    return yield findAddressPoints({
         type: "wholeMunicipality",
         municipality: {
             code: state.currentMunicipality.founder.cityOrDistrictCode,
             type: state.currentMunicipality.founder.municipalityType,
         },
     });
-    yield addRestToSchool(allPoints, state.rests.wholeMunicipalitySchoolIzo, state);
 });
 const addRestOfMunicipalityPart = (state, municipalityPartCode, schoolIzo) => __awaiter(void 0, void 0, void 0, function* () {
     // get all address points for current municipality
@@ -260,18 +270,24 @@ const addRestOfMunicipalityPart = (state, municipalityPartCode, schoolIzo) => __
         type: "wholeMunicipalityPart",
         municipalityPartCode,
     });
-    yield addRestToSchool(allPoints, schoolIzo, state);
+    addRestToSchool(allPoints, schoolIzo, state);
 });
-export const getNewMunicipality = (name) => __awaiter(void 0, void 0, void 0, function* () {
+export const getNewMunicipalityByName = (name) => __awaiter(void 0, void 0, void 0, function* () {
     const { founder, errors } = yield findFounder(name);
-    return {
-        municipality: {
-            municipalityName: founder ? founder.name : "Neznámá obec",
-            founder,
-            schools: [],
-        },
-        errors,
-    };
+    return getNewMunicipality(founder, errors);
+});
+export const getNewMunicipalityByFounderId = (founderId) => __awaiter(void 0, void 0, void 0, function* () {
+    const { founder, errors } = yield getFounderById(founderId);
+    return getNewMunicipality(founder, errors);
+});
+const getNewMunicipality = (founder, errors) => ({
+    municipality: {
+        municipalityName: founder ? founder.name : "Neznámá obec",
+        founder,
+        schools: [],
+        unmappedPoints: [],
+    },
+    errors,
 });
 export const getNewSchool = (name, founder, lineNumber, onError) => __awaiter(void 0, void 0, void 0, function* () {
     let exportSchool = {

package/dist/street-markdown/types.d.ts

@@ -64,6 +64,7 @@ export interface School {
 export interface Municipality {
     municipalityName: string;
     schools: School[];
+    unmappedPoints: ExportAddressPoint[];
 }
 export interface DbMunicipalityResult {
     municipality: DbMunicipality;
@@ -76,6 +77,10 @@ export interface MunicipalityPartResult {
 export interface MunicipalityWithFounder extends Municipality {
     founder: Founder | null;
 }
+export interface MunicipalityWithFounderResult {
+    municipality: MunicipalityWithFounder;
+    errors: SmdError[];
+}
 export interface SmdState {
     currentMunicipality: MunicipalityWithFounder;
     currentFilterMunicipality: DbMunicipality;
@@ -87,6 +92,7 @@ export interface SmdState {
             schoolIzo: string;
         }[];
         wholeMunicipalitySchoolIzo: string;
+        includeUnmappedAddressPoints: boolean;
     };
     municipalities: Municipality[];
 }

package/package.json

@@ -57,7 +57,7 @@
   },
   "name": "text-to-map",
   "description": "Text To Map usiluje o lepší, strojově zpracovatelné využití částí vyhlášek s výčtem ulic a dalších lokací. Jde o rozšiřitelnou sadu konceptů a nástrojů, které zajistí hladký převod výčtu ulic a jejich rozsahů v lidsky srozumitelném jazyce do strojově zpracovatelného, uchopitelného formátu.",
-  "version": "1.1.17",
+  "version": "1.1.19",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [