crazy-odds-bet-shared 1.0.45 → 1.0.47

package/bookmakers/specifiers/superbetSpecifiers.js

@@ -107,6 +107,9 @@ class SuperbetSpecifiersHelper extends SpecifiersHelperBase {
 
   getQuarter(externalRef) {
     const s = String(externalRef?.value ?? '').trim();
+    if (['1', '2', '3', '4'].includes(s)) {
+      return { value: String(s) };
+    }
     const m = s.match(/Sfertul\s*([0-9])/i);
     if (!m) return { value: null };
     const n = Number(m[1]);

package/models/fixture.js

@@ -23,8 +23,10 @@ const fixtureSchema = new Schema(
     ...createBaseSchema(),
     sportId: { type: String, required: true, ref: 'Sport' },
     competitionId: { type: String, required: true, ref: 'Competition' },
-    homeTeamId: { type: String, required: true, ref: 'Team' },
-    awayTeamId: { type: String, required: true, ref: 'Team' },
+    homeTeamId: { type: String, required: false, ref: 'Team' },
+    awayTeamId: { type: String, required: false, ref: 'Team' },
+    firstPlayerId: { type: String, required: false, ref: 'Player' },
+    secondPlayerId: { type: String, required: false, ref: 'Player' },
     name: { type: String, required: true },
     slug: { type: String, unique: true, sparse: true },
     scheduledAt: { type: Date, required: true },
@@ -45,6 +47,8 @@ fixtureSchema.index({ sportId: 1 });
 fixtureSchema.index({ competitionId: 1 });
 fixtureSchema.index({ homeTeamId: 1 });
 fixtureSchema.index({ awayTeamId: 1 });
+fixtureSchema.index({ firstPlayerId: 1 });
+fixtureSchema.index({ secondPlayerId: 1 });
 fixtureSchema.index({ scheduledAt: 1 });
 fixtureSchema.index({ status: 1 });
 fixtureSchema.index({ scheduledAt: 1, status: 1 });
@@ -78,6 +82,20 @@ fixtureSchema.virtual('awayTeam', {
   justOne: true
 });
 
+fixtureSchema.virtual('firstPlayer', {
+  ref: 'Player',
+  localField: 'firstPlayerId',
+  foreignField: '_id',
+  justOne: true
+});
+
+fixtureSchema.virtual('secondPlayer', {
+  ref: 'Player',
+  localField: 'secondPlayerId',
+  foreignField: '_id',
+  justOne: true
+});
+
 // Static methods
 fixtureSchema.static('findBySlug', function (slug) {
   return this.findOne({ slug });
@@ -123,6 +141,12 @@ fixtureSchema.static('findByTeam', function (teamId) {
   }).sort({ scheduledAt: 1 });
 });
 
+fixtureSchema.static('findByPlayer', function (playerId) {
+  return this.find({
+    $or: [{ firstPlayerId: playerId }, { secondPlayerId: playerId }]
+  }).sort({ scheduledAt: 1 });
+});
+
 fixtureSchema.static('findUpcoming', function (limit = 20) {
   return this.find({
     scheduledAt: { $gte: new Date() },

package/models/index.js

@@ -2,6 +2,7 @@ const { Bookmaker } = require('./bookmaker');
 const { Provider } = require('./provider');
 const { Sport } = require('./sport');
 const { Competition } = require('./competition');
+const { Tournament } = require('./tournament');
 const { Team } = require('./team');
 const { Player } = require('./player');
 const { Fixture, FixtureStatus } = require('./fixture');
@@ -20,6 +21,7 @@ module.exports = {
   Provider,
   Sport,
   Competition,
+  Tournament,
   Team,
   Player,
   Fixture,

package/models/player.js

@@ -11,7 +11,7 @@ const playerSchema = new Schema(
   {
     ...createBaseSchema(),
     sportId: { type: String, required: true, ref: 'Sport' },
-    teamId: { type: String, required: true, ref: 'Team' },
+    teamId: { type: String, required: false, ref: 'Team' },
     fullName: { type: String, required: true },
     firstName: { type: String },
     lastName: { type: String },

package/models/sport.js

@@ -13,6 +13,12 @@ const sportSchema = new Schema(
     name: { type: String, required: true },
     slug: { type: String, unique: true, sparse: true },
     displayName: { type: String, required: true },
+    category: {
+      type: String,
+      required: true,
+      enum: ['team', 'individual'],
+      default: 'team'
+    },
     isActive: { type: Boolean, default: true },
     externalRefs: { type: Schema.Types.Mixed, default: {} }
   },

package/models/tournament.js

@@ -0,0 +1,187 @@
+const { Schema, model } = require('mongoose');
+const {
+  createBaseSchema,
+  baseSchemaOptions
+} = require('./base');
+
+/**
+ * Tournament schema
+ */
+const tournamentSchema = new Schema(
+  {
+    ...createBaseSchema(),
+    sportId: { type: String, required: true, ref: 'Sport' },
+    competitionId: { type: String, required: true, ref: 'Competition' },
+    name: { type: String, required: true },
+    slug: { type: String, sparse: true },
+    location: { type: String, required: false, sparse: true },
+    startDate: { type: Date, required: false, sparse: true },
+    endDate: { type: Date, required: false, sparse: true },
+    isActive: { type: Boolean, default: true },
+    externalRefs: { type: Schema.Types.Mixed, default: {} },
+    providerRefs: { type: Schema.Types.Mixed, default: {} },
+    metadata: { type: Schema.Types.Mixed, default: {} }
+  },
+  {
+    ...baseSchemaOptions,
+    autoIndex: process.env.NODE_ENV !== 'production'
+  }
+);
+
+// Indexes (slug unique per sport via compound)
+tournamentSchema.index({ slug: 1, sportId: 1 }, { unique: true, sparse: true });
+tournamentSchema.index({ sportId: 1 });
+tournamentSchema.index({ competitionId: 1 });
+tournamentSchema.index({ isActive: 1 });
+tournamentSchema.index({ name: 'text' });
+
+// Virtuals
+tournamentSchema.virtual('sport', {
+  ref: 'Sport',
+  localField: 'sportId',
+  foreignField: '_id',
+  justOne: true
+});
+
+tournamentSchema.virtual('competition', {
+  ref: 'Competition',
+  localField: 'competitionId',
+  foreignField: '_id',
+  justOne: true
+});
+
+// Migration hook: convert array externalRefs to object
+tournamentSchema.pre('save', function (next) {
+  if (this.externalRefs && Array.isArray(this.externalRefs)) {
+    // Migrate from array to object format
+    const converted = {};
+    this.externalRefs.forEach((ref) => {
+      if (ref && ref.bookmaker) {
+        // If array has bookmaker property, use it as key
+        const { bookmaker, ...refData } = ref;
+        converted[bookmaker] = refData;
+      } else if (ref && ref.slug) {
+        // Fallback to slug as key
+        converted[ref.slug] = ref;
+      }
+    });
+    this.externalRefs = converted;
+  }
+  next();
+});
+
+// Static methods
+tournamentSchema.static('findBySlug', function (slug, sport, season) {
+  const query = { slug };
+  if (sport) query.sportId = sport;
+  if (season) query.season = season;
+  return this.findOne(query);
+});
+
+tournamentSchema.static('getActive', function () {
+  return this.find({ isActive: true }).sort({ name: 1 });
+});
+
+tournamentSchema.static('findByExternalRef', function (bookmakerSlug, sportId, externalId) {
+  const query = {};
+  query[`externalRefs.${bookmakerSlug}.id`] = externalId;
+  query['sportId'] = sportId;
+  return this.findOne(query);
+});
+
+tournamentSchema.static('findBySport', function (sportId) {
+  return this.find({ sportId, isActive: true }).sort({ name: 1 });
+});
+
+tournamentSchema.static('findByCompetition', function (competitionId) {
+  return this.find({ competitionId, isActive: true }).sort({ name: 1 });
+});
+
+tournamentSchema.static('searchByName', function (query) {
+  return this.find({
+    name: { $regex: query, $options: 'i' }
+  }).sort({ name: 1 });
+});
+
+// Instance methods
+tournamentSchema.method('activate', async function () {
+  this.isActive = true;
+  return this.save();
+});
+
+tournamentSchema.method('deactivate', async function () {
+  this.isActive = false;
+  return this.save();
+});
+
+tournamentSchema.method('addExternalRef', async function (key, ref) {
+  if (!this.externalRefs || typeof this.externalRefs !== 'object') {
+    this.externalRefs = {};
+  }
+  const refs = this.externalRefs;
+  refs[key] = ref;
+  this.markModified('externalRefs');
+  return this.save();
+});
+
+tournamentSchema.method('removeExternalRef', async function (key) {
+  if (this.externalRefs && typeof this.externalRefs === 'object') {
+    const refs = this.externalRefs;
+    delete refs[key];
+    this.markModified('externalRefs');
+  }
+  return this.save();
+});
+
+tournamentSchema.method('activateExternalRef', async function (key) {
+  if (this.externalRefs && typeof this.externalRefs === 'object') {
+    const refs = this.externalRefs;
+    const ref = refs[key];
+    if (ref) {
+      ref.isActive = true;
+      refs[key] = ref;
+      this.markModified('externalRefs');
+      return this.save();
+    }
+  }
+  return this;
+});
+
+tournamentSchema.method('deactivateExternalRef', async function (key) {
+  if (this.externalRefs && typeof this.externalRefs === 'object') {
+    const refs = this.externalRefs;
+    const ref = refs[key];
+    if (ref) {
+      ref.isActive = false;
+      refs[key] = ref;
+      this.markModified('externalRefs');
+      return this.save();
+    }
+  }
+  return this;
+});
+
+tournamentSchema.method('addProviderRef', async function (key, ref) {
+  if (!this.providerRefs || typeof this.providerRefs !== 'object') {
+    this.providerRefs = {};
+  }
+  this.providerRefs[key] = ref;
+  this.markModified('providerRefs');
+  return this.save();
+});
+
+tournamentSchema.method('removeProviderRef', async function (key) {
+  if (this.providerRefs && typeof this.providerRefs === 'object') {
+    delete this.providerRefs[key];
+    this.markModified('providerRefs');
+  }
+  return this.save();
+});
+
+tournamentSchema.method('getProviderRef', function (key) {
+  return this.providerRefs?.[key] || null;
+});
+
+const Tournament = model('Tournament', tournamentSchema);
+
+module.exports = { Tournament };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crazy-odds-bet-shared",
-  "version": "1.0.45",
+  "version": "1.0.47",
   "description": "Shared MongoDB models and utilities for odds project",
   "main": "index.js",
   "exports": {