@eventconnectors/ndtrc_model 1.0.5 → 1.0.6

package/.claude/settings.local.json

@@ -0,0 +1,14 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm test)",
+      "Bash(node -e:*)",
+      "WebFetch(domain:github.com)",
+      "WebFetch(domain:api.github.com)",
+      "WebFetch(domain:raw.githubusercontent.com)",
+      "Bash(npm publish:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

package/CLAUDE.md

@@ -0,0 +1,54 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+This is the `@eventconnectors/ndtrc_model` npm package - a Node.js data model library for NDTRC (Nationale Databank Toerisme en Recreatie Centraal), the Dutch national tourism and recreation database. It provides JavaScript classes for representing tourism events, locations, and related entities.
+
+## Commands
+
+- **Run tests**: `npm test` (uses Jest)
+- **Install dependencies**: `npm install`
+
+## Architecture
+
+### Entry Point
+- `index.js` - Exports all model classes from a single entry point
+
+### Model Classes (`src/model/`)
+
+**Core Entry Types:**
+- `FetchedEntry` - Raw data fetched from external sources (with `ExternalLocationInfo`)
+- `ConvertedEntry` - Processed entry containing a validated `TRCItem`
+
+**NDTRC Models (`src/model/ndtrc/`):**
+- `TRCItem` - Main entity representing an event/location with static enums `WFStatus` and `EntityType`
+- `TRCItemDetail` - Multilingual details (title, descriptions) per language
+- `Calendar` - Complex scheduling with single dates, pattern dates, and exception handling
+- `Location` - Location info with address and optional `LocationItem` reference
+- `TRCItemCategories` - Category assignments for items
+
+**Supporting Models:**
+- `Address`, `ContactInfo`, `GISCoordinate` - Location/contact data
+- `PriceElement`, `ExtraPriceInformation` - Pricing information
+- `File`, `Performer`, `Promotion` - Media and marketing
+- `Translations`, `RouteInfo`, `SubItemGroup`, `TRCItemGroup`, `TRCItemRelation`
+
+### Utilities (`src/util/`)
+- `CategoryMap` - Maps external category names to NDTRC category IDs with associated tags
+- `Categories` - NDTRC category ID lookup table
+
+### Key Patterns
+
+1. **Constructor-based initialization**: All model classes use destructured object parameters with defaults
+2. **Nested class instantiation**: Parent classes automatically instantiate child classes (e.g., `TRCItem` creates `Calendar`, `Location` instances)
+3. **Moment.js dates**: Date fields use `moment` for parsing and manipulation
+4. **Static enums**: Enums are defined as static properties on classes (e.g., `TRCItem.WFStatus`, `Calendar.CalendarType`)
+
+### Entity Types
+- `EVENEMENT` - Event
+- `LOCATIE` - Location/venue
+- `EVENEMENTGROEP` - Event group
+- `PLAATSREGIO` - Place/region
+- `ROUTE` - Route

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@eventconnectors/ndtrc_model",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "main": "index.js",
   "scripts": {
     "test": "jest"
   },
   "dependencies": {
-    "dayjs": "^1.11.13",
+    "dayjs": "^1.11.19",
     "moment": "^2.30.1",
     "xmlbuilder": "^15.1.1"
   },
   "devDependencies": {
-    "jest": "^29.7.0"
+    "jest": "^30.2.0"
   },
   "private": false,
   "author": "wwwappz",

package/src/__tests__/model.test.js

@@ -0,0 +1,327 @@
+const {
+  TRCItem,
+  FetchedEntry: FetchedEntryModule,
+  ExternalLocationInfo,
+  ConvertedEntry,
+  Location,
+  Calendar: CalendarModule,
+  Contactinfo,
+  File,
+  PriceElement,
+  Performer,
+  TRCItemDetail,
+  Address,
+  GISCoordinate,
+  Categories,
+  CategoryMap,
+} = require("../../index.js");
+
+const { FetchedEntry } = FetchedEntryModule;
+const { Calendar } = CalendarModule;
+
+describe("TRCItem", () => {
+  test("should create with default values", () => {
+    const item = new TRCItem();
+    expect(item.trcid).toBe("");
+    expect(item.published).toBe(false);
+    expect(item.deleted).toBe(false);
+    expect(item.forceOverwrite).toBe(false);
+  });
+
+  test("should create with custom values", () => {
+    const item = new TRCItem({
+      trcid: "test123",
+      published: true,
+      forceOverwrite: true,
+      entitytype: TRCItem.EntityType.EVENEMENT,
+    });
+    expect(item.trcid).toBe("test123");
+    expect(item.published).toBe(true);
+    expect(item.forceOverwrite).toBe(true);
+    expect(item.entitytype).toBe("EVENEMENT");
+  });
+
+  test("should have all EntityType values", () => {
+    expect(TRCItem.EntityType.EVENEMENT).toBe("EVENEMENT");
+    expect(TRCItem.EntityType.LOCATIE).toBe("LOCATIE");
+    expect(TRCItem.EntityType.EVENEMENTGROEP).toBe("EVENEMENTGROEP");
+    expect(TRCItem.EntityType.PLAATSREGIO).toBe("PLAATSREGIO");
+    expect(TRCItem.EntityType.ROUTE).toBe("ROUTE");
+    expect(TRCItem.EntityType.VENUE).toBe("VENUE");
+  });
+
+  test("should have all WFStatus values", () => {
+    expect(TRCItem.WFStatus.DRAFT).toBe("draft");
+    expect(TRCItem.WFStatus.READY_FOR_VALIDATION).toBe("readyforvalidation");
+    expect(TRCItem.WFStatus.APPROVED).toBe("approved");
+    expect(TRCItem.WFStatus.REJECTED).toBe("rejected");
+    expect(TRCItem.WFStatus.DELETED).toBe("deleted");
+    expect(TRCItem.WFStatus.ARCHIVED).toBe("archived");
+  });
+
+  test("should create nested objects", () => {
+    const item = new TRCItem({
+      trcid: "test",
+      location: { label: "Test Location" },
+      contactinfo: { label: "Test Contact" },
+      performers: [{ label: "Artist 1" }],
+      files: [{ filename: "image.jpg" }],
+      trcItemDetails: [{ lang: "nl", title: "Test" }],
+    });
+    expect(item.location).toBeInstanceOf(Location);
+    expect(item.contactinfo).toBeInstanceOf(Contactinfo);
+    expect(item.performers).toHaveLength(1);
+    expect(item.files).toHaveLength(1);
+    expect(item.trcItemDetails).toHaveLength(1);
+  });
+});
+
+describe("Location", () => {
+  test("should create with default values", () => {
+    const loc = new Location();
+    expect(loc.label).toBe("");
+    expect(loc.address).toBeNull();
+    expect(loc.locationItem).toBeNull();
+    expect(loc.venueItem).toBeNull();
+  });
+
+  test("should create with locationItem and venueItem", () => {
+    const loc = new Location({
+      label: "Test",
+      locationItem: { id: "1", trcid: "loc1", text: "Location" },
+      venueItem: { id: "2", trcid: "venue1", text: "Venue" },
+    });
+    expect(loc.locationItem.id).toBe("1");
+    expect(loc.locationItem.trcid).toBe("loc1");
+    expect(loc.venueItem.id).toBe("2");
+    expect(loc.venueItem.trcid).toBe("venue1");
+  });
+
+  test("should create address", () => {
+    const loc = new Location({
+      address: { city: "Amsterdam", street: "Damrak" },
+    });
+    expect(loc.address).toBeInstanceOf(Address);
+    expect(loc.address.city).toBe("Amsterdam");
+  });
+});
+
+describe("Calendar", () => {
+  test("should create with default values", () => {
+    const cal = new Calendar();
+    expect(cal.singleDates).toEqual([]);
+    expect(cal.patternDates).toEqual([]);
+    expect(cal.excludeholidays).toBe(false);
+    expect(cal.cancelled).toBe(false);
+    expect(cal.soldout).toBe(false);
+    expect(cal.onrequest).toBe(false);
+    expect(cal.alwaysopen).toBe(false);
+    expect(cal.comment).toBeNull();
+    expect(cal.calendarType).toBeNull();
+  });
+
+  test("should have CalendarType enum", () => {
+    expect(Calendar.CalendarType.NONE).toBe("NONE");
+    expect(Calendar.CalendarType.ALWAYSOPEN).toBe("ALWAYSOPEN");
+    expect(Calendar.CalendarType.ONREQUEST).toBe("ONREQUEST");
+    expect(Calendar.CalendarType.OPENINGTIMES).toBe("OPENINGTIMES");
+    expect(Calendar.CalendarType.PATTERNDATES).toBe("PATTERNDATES");
+    expect(Calendar.CalendarType.SINGLEDATES).toBe("SINGLEDATES");
+  });
+
+  test("should determine ALWAYSOPEN calendar type", () => {
+    const cal = new Calendar();
+    cal.alwaysopen = true;
+    cal.determineCalendarType();
+    expect(cal.calendarType).toBe("ALWAYSOPEN");
+  });
+
+  test("should determine ONREQUEST calendar type", () => {
+    const cal = new Calendar();
+    cal.onrequest = true;
+    cal.determineCalendarType();
+    expect(cal.calendarType).toBe("ONREQUEST");
+  });
+});
+
+describe("Contactinfo", () => {
+  test("should create with default values", () => {
+    const contact = new Contactinfo();
+    expect(contact.label).toBe("");
+    expect(contact.mails).toEqual([]);
+    expect(contact.phones).toEqual([]);
+    expect(contact.urls).toEqual([]);
+  });
+
+  test("should create nested Mail objects", () => {
+    const contact = new Contactinfo({
+      mails: [{ email: "test@example.com" }],
+    });
+    expect(contact.mails).toHaveLength(1);
+    expect(contact.mails[0].email).toBe("test@example.com");
+  });
+
+  test("should create nested Url objects", () => {
+    const contact = new Contactinfo({
+      urls: [{ url: "https://example.com", urlServiceType: "general" }],
+    });
+    expect(contact.urls).toHaveLength(1);
+    expect(contact.urls[0].url).toBe("https://example.com");
+  });
+
+  test("should have all URLServiceType values", () => {
+    const types = Contactinfo.Url.URLServiceType;
+    expect(types.general).toBe("general");
+    expect(types.booking).toBe("booking");
+    expect(types.review).toBe("review");
+    expect(types.video).toBe("video");
+    expect(types.webshop).toBe("webshop");
+    expect(types.socialmedia).toBe("socialmedia");
+    expect(types.lastminute).toBe("lastminute");
+    expect(types.virtualtour).toBe("virtualtour");
+    expect(types.dmo).toBe("dmo");
+    expect(types.sustainability).toBe("sustainability");
+    expect(types.venuefinder).toBe("venuefinder");
+    expect(types.travelbase).toBe("travelbase");
+  });
+});
+
+describe("File", () => {
+  test("should create with default values", () => {
+    const file = new File();
+    expect(file.trcid).toBe("");
+    expect(file.main).toBe(false);
+    expect(file.filename).toBe("");
+  });
+
+  test("should have FileType enum", () => {
+    expect(File.FileType.jpeg).toBe("jpeg");
+    expect(File.FileType.youtube).toBe("youtube");
+    expect(File.FileType.vimeo).toBe("vimeo");
+  });
+
+  test("should have MediaType enum", () => {
+    expect(File.MediaType.photo).toBe("photo");
+    expect(File.MediaType.video).toBe("video");
+    expect(File.MediaType.poster).toBe("poster");
+  });
+
+  test("should normalize YouTube URL", () => {
+    const shortUrl = "https://youtu.be/dQw4w9WgXcQ";
+    const normalized = File.normalizeYouTubeURL(shortUrl);
+    expect(normalized).toBe("https://www.youtube.com/watch?v=dQw4w9WgXcQ");
+  });
+
+  test("should extract YouTube video ID", () => {
+    const url = "https://www.youtube.com/watch?v=dQw4w9WgXcQ";
+    const videoId = File.youtubeVideoID(url);
+    expect(videoId).toBe("dQw4w9WgXcQ");
+  });
+});
+
+describe("PriceElement", () => {
+  test("should create with default values", () => {
+    const price = new PriceElement();
+    expect(price.freeentrance).toBe(false);
+    expect(price.priceValue).toBeNull();
+    expect(price.comments).toEqual([]);
+  });
+
+  test("should create with price value", () => {
+    const price = new PriceElement({
+      freeentrance: false,
+      priceValue: { from: 10.0, until: 25.0 },
+    });
+    expect(price.priceValue.from).toBe(10.0);
+    expect(price.priceValue.until).toBe(25.0);
+  });
+
+  test("should have PriceDescriptionValue enum", () => {
+    const values = PriceElement.Description.PriceDescriptionValue;
+    expect(values.Adults).toBe("Adults");
+    expect(values.Children).toBe("Children");
+    expect(values.Groups).toBe("Groups");
+    expect(values.CJP).toBe("CJP");
+  });
+});
+
+describe("FetchedEntry", () => {
+  test("should create with default values", () => {
+    const entry = new FetchedEntry();
+    expect(entry.feed).toBe("");
+    expect(entry.sourceId).toBe("");
+    expect(entry.externalId).toBe("");
+  });
+
+  test("should create with custom values", () => {
+    const entry = new FetchedEntry({
+      feed: "test-feed",
+      sourceId: "source-123",
+      externalId: "ext-456",
+      data: { key: "value" },
+    });
+    expect(entry.feed).toBe("test-feed");
+    expect(entry.sourceId).toBe("source-123");
+    expect(entry.data.key).toBe("value");
+  });
+});
+
+describe("ConvertedEntry", () => {
+  test("should create with default values", () => {
+    const entry = new ConvertedEntry();
+    expect(entry.label).toBe("");
+    expect(entry.externalId).toBe("");
+    expect(entry.trcItem).toBeNull();
+  });
+
+  test("should accept TRCItem instance", () => {
+    const trcItem = new TRCItem({ trcid: "test" });
+    const entry = new ConvertedEntry({
+      label: "Test Entry",
+      trcItem: trcItem,
+    });
+    expect(entry.trcItem).toBe(trcItem);
+  });
+});
+
+describe("Address", () => {
+  test("should create with default values", () => {
+    const address = new Address();
+    expect(address.city).toBe("");
+    expect(address.country).toBe("NL");
+    expect(address.main).toBe(false);
+  });
+
+  test("should normalize zipcode", () => {
+    const address = new Address({ zipcode: "1234ab" });
+    address.normaliseAdresItems();
+    expect(address.zipcode).toBe("1234 AB");
+  });
+
+  test("should check isEmpty", () => {
+    const emptyAddress = new Address();
+    const filledAddress = new Address({ city: "Amsterdam" });
+    expect(emptyAddress.isEmpty()).toBe(true);
+    expect(filledAddress.isEmpty()).toBe(false);
+  });
+});
+
+describe("Categories", () => {
+  test("should have category mappings", () => {
+    expect(Categories.categories).toBeDefined();
+    expect(Categories.categories["Beurs"]).toBe("2.3.1");
+    expect(Categories.categories["Film"]).toBe("2.5.2");
+  });
+});
+
+describe("CategoryMap", () => {
+  test("should have categoryMap", () => {
+    expect(CategoryMap.CategoryMap.categoryMap).toBeDefined();
+    expect(CategoryMap.CategoryMap.categoryMap["concert"].catId).toBe("2.6.5");
+  });
+
+  test("should have categoryType", () => {
+    expect(CategoryMap.CategoryMap.categoryType).toBeDefined();
+    expect(CategoryMap.CategoryMap.categoryType["Cabaret"]).toBe("2.9.1");
+  });
+});

package/src/model/ndtrc/Calendar.js

@@ -1,6 +1,7 @@
 // Calendar.js
 
 const moment = require("moment");
+const Contactinfo = require("./ContactInfo");
 
 class Calendar {
   constructor() {
@@ -15,6 +16,10 @@ class Calendar {
     this.excludeholidays = false;
     this.cancelled = false;
     this.soldout = false;
+    this.onrequest = false;
+    this.alwaysopen = false;
+    this.comment = null;
+    this.calendarType = null;
   }
 
   static CalendarType = {
@@ -172,6 +177,7 @@ class When {
     this.status = status;
     this.statustranslations = [];
     this.extrainformations = [];
+    this.url = Contactinfo.Url ? new Contactinfo.Url() : [];
   }
 
   equals(other) {

package/src/model/ndtrc/ContactInfo.js

@@ -170,7 +170,9 @@ Contactinfo.Url.URLServiceType = {
     lastminute: 'lastminute',
     virtualtour: 'virtualtour',
     dmo: 'dmo',
-    sustainability: 'sustainability'
+    sustainability: 'sustainability',
+    venuefinder: 'venuefinder',
+    travelbase: 'travelbase'
 };
 
 /**

package/src/model/ndtrc/Location.js

@@ -1,10 +1,11 @@
 const Address = require('./Address'); // Importeer de Address-klasse
 
 class Location {
-    constructor({ address = null, label = '', locationItem = null } = {}) {
+    constructor({ address = null, label = '', locationItem = null, venueItem = null } = {}) {
         this.address = address ? new Address(address) : null;
         this.label = label;
         this.locationItem = locationItem ? new Location.LocationItem(locationItem) : null;
+        this.venueItem = venueItem ? new Location.LocationItem(venueItem) : null;
     }
 }
 

package/src/model/ndtrc/TRCItem.js

@@ -53,7 +53,8 @@ class TRCItem {
         extrapriceinformations = [],
         routeInfo = null,
         translations = null,
-        promotions = []
+        promotions = [],
+        forceOverwrite = false
     } = {}) {
         this.trcid = trcid;
         this.creationdate = creationdate ? moment(creationdate) : null;
@@ -96,6 +97,7 @@ class TRCItem {
         this.routeInfo = routeInfo ? new RouteInfo(routeInfo) : null;
         this.translations = translations ? new Translations(translations) : new Translations();
         this.promotions = promotions.map(promotion => new Promotion(promotion));
+        this.forceOverwrite = forceOverwrite;
     }
 }
 
@@ -113,7 +115,8 @@ TRCItem.EntityType = {
     LOCATIE: 'LOCATIE',
     EVENEMENTGROEP: 'EVENEMENTGROEP',
     PLAATSREGIO: 'PLAATSREGIO',
-    ROUTE: 'ROUTE'
+    ROUTE: 'ROUTE',
+    VENUE: 'VENUE'
 };
 
 TRCItem.Category = class Category {