@sparted/shared-library 1.9.3 → 1.9.5

package/src/business/campaign/__tests__/find-next-available-date.test.ts

@@ -0,0 +1,82 @@
+import { findNextAvailableDate } from '../live-campaign';
+
+describe('findNextAvailableDate', () => {
+  it('should return the current date if it is enabled and not disabled', () => {
+    const currentDate = new Date('2024-04-22'); // Monday
+    const enabledWeekDays = [1, 2, 3, 4, 5]; // Monday to Friday
+    const disabledDates: Date[] = [];
+
+    const result = findNextAvailableDate(currentDate, enabledWeekDays, disabledDates);
+    expect(result).toEqual(currentDate);
+  });
+
+  it('should skip the current date if it is not an enabled weekday', () => {
+    const currentDate = new Date('2024-04-27'); // Saturday
+    const enabledWeekDays = [1, 2, 3, 4, 5]; // Monday to Friday
+    const disabledDates: Date[] = [];
+
+    const expectedDate = new Date('2024-04-29'); // Next Monday
+    const result = findNextAvailableDate(currentDate, enabledWeekDays, disabledDates);
+    expect(result).toEqual(expectedDate);
+  });
+
+  it('should skip the current date if it is disabled', () => {
+    const currentDate = new Date('2024-04-22'); // Monday
+    const enabledWeekDays = [1, 2, 3, 4, 5];
+    const disabledDates = [new Date('2024-04-22')];
+
+    const expectedDate = new Date('2024-04-23'); // Thuesday
+    const result = findNextAvailableDate(currentDate, enabledWeekDays, disabledDates);
+    expect(result).toEqual(expectedDate);
+  });
+
+  it('should recurse until a valid date is found', () => {
+    const currentDate = new Date('2024-04-26'); // Friday
+    const enabledWeekDays = [1, 2, 3, 4, 5]; // Monday to Friday
+    const disabledDates = [
+      new Date('2024-04-26'), // Friday
+      new Date('2024-04-29'), // Monday next
+    ];
+
+    const expectedDate = new Date('2024-04-30'); // Thuesday
+    const result = findNextAvailableDate(currentDate, enabledWeekDays, disabledDates);
+    expect(result).toEqual(expectedDate);
+  });
+
+  it('should return current date if it is the end date and valid', () => {
+    const currentDate = new Date('2024-04-30'); // Thuesday
+    const enabledWeekDays = [1, 2, 3, 4, 5];
+    const disabledDates: Date[] = [];
+
+    const result = findNextAvailableDate(currentDate, enabledWeekDays, disabledDates);
+    expect(result).toEqual(currentDate);
+  });
+
+  it('should return current date if currentDate is after endDate', () => {
+    const currentDate = new Date('2024-05-01'); // Wednesday
+    const enabledWeekDays = [1, 2, 3, 4, 5];
+    const disabledDates: Date[] = [];
+
+    const result = findNextAvailableDate(currentDate, enabledWeekDays, disabledDates);
+    expect(result).toEqual(currentDate);
+  });
+
+  it('should handle empty enabledWeekDays by treating no days as enabled', () => {
+    const currentDate = new Date('2024-04-22'); // Monday
+
+    const enabledWeekDays: number[] = []; // No days enabled
+    const disabledDates: Date[] = [];
+
+    const result = findNextAvailableDate(currentDate, enabledWeekDays, disabledDates);
+    expect(result).toBeNull();
+  });
+
+  it('should handle empty disabledDates', () => {
+    const currentDate = new Date('2024-04-22'); // Monday
+    const enabledWeekDays = [1, 2, 3, 4, 5];
+    const disabledDates: Date[] = [];
+
+    const result = findNextAvailableDate(currentDate, enabledWeekDays, disabledDates);
+    expect(result).toEqual(currentDate);
+  });
+});

package/src/business/campaign/__tests__/get-calendar-dession-dates-from-campaign.test.ts

@@ -0,0 +1,123 @@
+import { CampaignDetails } from '../../types';
+import { getCalendarSessionDatesFromCampaign } from '../live-campaign';
+
+describe('getCalendarSessionDatesFromCampaign', () => {
+  const formatDate = (date: Date): string => {
+    const year = date.getFullYear();
+    const month = `0${date.getMonth() + 1}`.slice(-2);
+    const day = `0${date.getDate()}`.slice(-2);
+    return `${year}-${month}-${day}`;
+  };
+
+  it('should generate the correct number of session dates', () => {
+    const campaign: Partial<CampaignDetails> = {
+      launchDate: '2024-04-22',
+      enabledWeekDays: [1, 2, 3, 4, 5],
+      disabledDates: [],
+      nbSessions: 5,
+    };
+
+    const result = getCalendarSessionDatesFromCampaign(campaign as CampaignDetails);
+    expect(Object.keys(result)).toHaveLength(5);
+  });
+
+  it('should correctly assign session dates considering enabledWeekDays and disabledDates', () => {
+    const campaign: Partial<CampaignDetails> = {
+      launchDate: '2024-04-22',
+      enabledWeekDays: [1, 3, 5],
+      disabledDates: [new Date('2024-04-25')],
+      nbSessions: 3,
+    };
+
+    const result = getCalendarSessionDatesFromCampaign(campaign as CampaignDetails);
+
+    expect(formatDate(result[1])).toBe('2024-04-22');
+    expect(formatDate(result[2])).toBe('2024-04-24');
+    expect(formatDate(result[3])).toBe('2024-04-26');
+  });
+
+  it('should skip disabled dates and enabledWeekDays accordingly', () => {
+    const campaign: Partial<CampaignDetails> = {
+      launchDate: '2024-04-22',
+      enabledWeekDays: [2, 4],
+      disabledDates: [new Date('2024-04-23'), new Date('2024-04-25')],
+      nbSessions: 2,
+    };
+
+    const result = getCalendarSessionDatesFromCampaign(campaign as CampaignDetails);
+
+    expect(formatDate(result[1])).toBe('2024-04-30');
+    expect(formatDate(result[2])).toBe('2024-05-02');
+  });
+
+  it('should handle campaigns with no disabled dates', () => {
+    const campaign: Partial<CampaignDetails> = {
+      launchDate: '2024-04-22',
+      enabledWeekDays: [1, 2, 3, 4, 5],
+      disabledDates: [],
+      nbSessions: 3,
+    };
+
+    const result = getCalendarSessionDatesFromCampaign(campaign as CampaignDetails);
+
+    expect(formatDate(result[1])).toBe('2024-04-22');
+    expect(formatDate(result[2])).toBe('2024-04-23');
+    expect(formatDate(result[3])).toBe('2024-04-24');
+  });
+
+  it('should handle campaigns where nbSessions is zero', () => {
+    const campaign: Partial<CampaignDetails> = {
+      launchDate: '2024-04-22',
+      enabledWeekDays: [1, 2, 3, 4, 5],
+      disabledDates: [],
+      nbSessions: 0,
+    };
+
+    const result = getCalendarSessionDatesFromCampaign(campaign as CampaignDetails);
+    expect(Object.keys(result)).toHaveLength(0);
+  });
+
+  it('should correctly handle multiple disabled dates and enabledWeekDays', () => {
+    const campaign: Partial<CampaignDetails> = {
+      launchDate: '2024-04-22',
+      enabledWeekDays: [1, 3, 5],
+      disabledDates: [new Date('2024-04-22'), new Date('2024-04-24'), new Date('2024-04-26')],
+      nbSessions: 3,
+    };
+
+    const result = getCalendarSessionDatesFromCampaign(campaign as CampaignDetails);
+
+    expect(formatDate(result[1])).toBe('2024-04-29');
+    expect(formatDate(result[2])).toBe('2024-05-01');
+    expect(formatDate(result[3])).toBe('2024-05-03');
+  });
+
+  it('should correctly handle extra days', () => {
+    const campaign: Partial<CampaignDetails> & { extraDays: number } = {
+      launchDate: '2024-11-27',
+      enabledWeekDays: [1, 2, 3, 4, 5],
+      disabledDates: [new Date('2025-03-11')],
+      nbSessions: 2,
+      extraDays: 100,
+    };
+
+    const result = getCalendarSessionDatesFromCampaign(campaign as CampaignDetails & { extraDays: number });
+
+    expect(formatDate(result[1])).toBe('2024-11-27');
+    expect(formatDate(result[102])).toBe('2025-04-18');
+    expect(Object.keys(result)).toHaveLength(102);
+
+    // Verify that none of the disabled dates are included in the result
+    const disabledDateFormatted = formatDate(new Date('2025-03-11'));
+    Object.values(result).forEach((date) => {
+      expect(formatDate(date)).not.toBe(disabledDateFormatted);
+    });
+
+    // Verify that all dates fall on enabled weekdays
+    const { enabledWeekDays } = campaign;
+    Object.values(result).forEach((date) => {
+      const day = date.getDay();
+      expect(enabledWeekDays).toContain(day);
+    });
+  });
+});

package/src/business/campaign/index.ts

@@ -0,0 +1 @@
+export * from './live-campaign';

package/src/business/campaign/live-campaign.ts

@@ -0,0 +1,133 @@
+import { addDays, isSameDate } from '../../date';
+import { CampaignDetails, LiveCampaign } from '../types';
+
+export const computeIntenseCalendar = (card: LiveCampaign): Date[] => {
+  const { details } = card;
+
+  const startDate = new Date(details.utcStartDate);
+  const endDate = new Date(details.utcEndDate);
+
+  const calculateIntenseCalendarAux = (date: Date, calendar: Date[]): Date[] => {
+    if (date > endDate) {
+      return calendar;
+    }
+
+    const jsDay = date.getDay();
+    const day = jsDay === 0 ? 7 : jsDay;
+
+    if (details.enabledWeekDays.includes(day) && !details.disabledDates.includes(date.toISOString().slice(0, 10))) {
+      calendar.push(new Date(date));
+    }
+
+    date.setDate(date.getDate() + 1);
+
+    return calculateIntenseCalendarAux(date, calendar);
+  };
+
+  return calculateIntenseCalendarAux(startDate, []);
+};
+
+export const computeCurrentSession = (card: LiveCampaign, forceComputeCalendar?: boolean): number => {
+  const { details, achievement } = card;
+
+  if (details.type === 'flexible' && !forceComputeCalendar) {
+    return Math.min(achievement.lastSessionPlayed + 1, details.sessionCount);
+  }
+
+  const today = new Date();
+
+  if (today <= new Date(details.utcStartDate)) {
+    return 1;
+  }
+
+  if (today >= new Date(details.utcEndDate)) {
+    return details.sessionCount;
+  }
+
+  const calendar = computeIntenseCalendar(card);
+
+  const todayDate = today.toISOString().slice(0, 10);
+  const currentSession = calendar.findIndex((date) => date.toISOString().slice(0, 10) >= todayDate);
+
+  if (currentSession === -1) {
+    throw new Error('Current session not found');
+  }
+
+  return Math.min(currentSession + 1, details.sessionCount);
+};
+
+export const checkTodayPlayable = (card: LiveCampaign): boolean => {
+  const today = new Date();
+
+  const { details } = card;
+
+  const startDate = new Date(details.utcStartDate);
+  const endDate = new Date(details.utcEndDate);
+
+  if (today < startDate || today > endDate) {
+    return false;
+  }
+
+  const jsDay = today.getDay();
+  const day = jsDay === 0 ? 7 : jsDay;
+
+  if (!details.enabledWeekDays.includes(day)) {
+    return false;
+  }
+
+  if (details.disabledDates.includes(today.toISOString().slice(0, 10))) {
+    return false;
+  }
+
+  return true;
+};
+
+export const findNextAvailableDate = (
+  currentDate: Date,
+  enabledWeekDays: number[],
+  disabledDates: Date[],
+): Date | null => {
+  if (enabledWeekDays.length === 0) return null;
+  const dayofDate = currentDate.getDay();
+  const isEnabledDay = enabledWeekDays.includes(dayofDate === 0 ? 7 : dayofDate);
+  const isDisabledDate = disabledDates.some((d) => isSameDate(d, currentDate));
+
+  if (isEnabledDay && !isDisabledDate) {
+    return currentDate;
+  }
+
+  return findNextAvailableDate(addDays(currentDate, 1), enabledWeekDays, disabledDates);
+};
+
+type GetCalendarSessionDatesFromCampaignProps = Pick<
+  CampaignDetails,
+  'launchDate' | 'enabledWeekDays' | 'disabledDates' | 'nbSessions'
+> & {
+  extraDays?: number;
+};
+
+export const getCalendarSessionDatesFromCampaign = ({
+  launchDate,
+  enabledWeekDays,
+  disabledDates,
+  nbSessions,
+  extraDays = 0,
+}: GetCalendarSessionDatesFromCampaignProps): Record<number, Date> => {
+  const sessionCount = nbSessions + extraDays;
+
+  const calendarDatesBySession = Array.from({ length: sessionCount }).reduce((acc: Record<number, Date>, _, index) => {
+    const session = index + 1;
+    const lastDate = session > 1 ? addDays(new Date(acc[session - 1]), 1) : new Date(launchDate);
+
+    const nextSessionDate = findNextAvailableDate(lastDate, enabledWeekDays, disabledDates);
+
+    if (!nextSessionDate) return acc;
+
+    return {
+      ...acc,
+      [session]: nextSessionDate,
+    };
+  }, {});
+
+  return calendarDatesBySession;
+};

package/src/business/course/index.ts

@@ -0,0 +1 @@
+export * from './microknowledge-max-lengths';

package/src/business/course/microknowledge-max-lengths.ts

@@ -0,0 +1,12 @@
+export const MICROKNOWLEDGE_MAX_LENGTHS = {
+  IMAGE: {
+    MAX_TITLE_LENGTH: 40,
+    MAX_CONTENT_LENGTH: 500,
+  },
+  VIDEO: {
+    MAX_TITLE_LENGTH: 40,
+  },
+  CHAPTER: {
+    MAX_TITLE_LENGTH: 40,
+  },
+};

package/src/business/index.ts

@@ -0,0 +1,4 @@
+export * from './campaign';
+export * from './course';
+export * from './picture-spot';
+export * from './types';

package/src/business/picture-spot/index.ts

@@ -0,0 +1,3 @@
+import { PictureSpot } from '../types';
+
+export const getQuestions = (content: PictureSpot) => content.items?.map(({ question }) => question);

package/src/business/types/achievement.ts

@@ -0,0 +1,41 @@
+import type { MultilingualLabel } from './multilingual';
+import type { PlayerProfile } from './player';
+import type { Image } from './media';
+
+export type CampaignRanking = {
+  activityId: number;
+  playerProfile: PlayerProfile;
+  rank: number;
+  score: number;
+  numberSessionsPlayed: number;
+  lastPlayed: string;
+  favorite: boolean;
+};
+
+export type CampaignTeamRanking = {
+  activityId: number;
+  team: {
+    ambassadorId: number;
+    teamName: string | null;
+    ambassadorFirstName: string;
+    ambassadorLastName: string;
+  };
+  rank: number;
+  score: number;
+  image: Image | null;
+};
+
+export type MostFailedQuestion = {
+  title: MultilingualLabel;
+  correctAnswerRate: number;
+};
+
+export type CampaignStats = {
+  participationRate: number;
+  exposureRate: number;
+  masteryRate: number;
+  correctAnswerRate: number;
+  mostFailed: MostFailedQuestion[];
+  nbQuestions: number;
+  nbActivePlayers: number;
+};

package/src/business/types/activity.ts

@@ -0,0 +1,64 @@
+import type { AudienceInformation, Segment } from './audience';
+import type { BreakingNewsActivity } from './breaking-news';
+import type { Campaign } from './campaign';
+import type { Media } from './media';
+import type { LanguageCode, MultilingualLabel } from './multilingual';
+import type { EventSummary } from './user-engagement';
+
+export type ActivityAudience = {
+  groupId: number;
+  type: 'all' | 'segmentation' | 'magic-code' | 'email-list';
+  segments: Segment[];
+};
+
+export type ActivityStatus = (typeof ACTIVITY_STATUS)[number];
+
+export type SharedActivityMetadata = {
+  status: ActivityStatus;
+  languages?: LanguageCode[];
+  audiences?: ActivityAudience[];
+  userEngagement?: {
+    viewCount?: number;
+    likeCount?: number;
+  };
+};
+
+export type CampaignActivity = SharedActivityMetadata & Campaign;
+
+export type Activity = CampaignActivity | BreakingNewsActivity;
+
+export type BoActivityCardDetails = {
+  identifier: string;
+  cover: Media;
+  title: MultilingualLabel;
+  utcStartDate: string;
+  utcEndDate?: string;
+};
+
+export type BoActivityCard = {
+  id: number;
+  type: 'campaign' | 'breaking-news';
+  status: ActivityStatus;
+  details: BoActivityCardDetails;
+  language: LanguageCode[];
+  eventSummary: EventSummary;
+  audience: AudienceInformation;
+  audienceGroupNames: string[];
+};
+
+export const ACTIVITY_STATUS = [
+  'draft',
+  'inactive',
+  'archived',
+  'upcoming',
+  'live',
+  'celebration',
+  'finished',
+] as const;
+
+export const isActivityCampaign = (activity: unknown): activity is CampaignActivity =>
+  typeof activity === 'object' && activity !== null && 'type' in activity && activity.type === 'campaign';
+
+export const isActivityBreakingNews = (
+  activity: CampaignActivity | BreakingNewsActivity,
+): activity is BreakingNewsActivity => activity.type === 'breaking-news';

package/src/business/types/audience.ts

@@ -0,0 +1,23 @@
+export type Segment = {
+  id: number;
+  label: string;
+  dimensionId: number;
+};
+
+export type AudienceType = 'all' | 'segmentation' | 'magic-code' | 'email-list' | 'audience';
+
+export type AudienceInformation =
+  | {
+      type: 'all';
+    }
+  | {
+      type: 'segmentation';
+      segments: Segment[];
+    }
+  | {
+      type: 'magic-code';
+      code: string;
+    }
+  | {
+      type: 'email-list';
+    };

package/src/business/types/battle.ts

@@ -0,0 +1,17 @@
+import type { PlayerProfile } from './player';
+
+export type BattleStatus = 'ready-to-play' | 'awaiting-opponent' | 'watch-result' | 'finished' | 'declined';
+export type BattleWinningStatus = 'winner' | 'loser' | 'draw';
+
+export type BattleSummary = {
+  id: number;
+  player: PlayerProfile;
+  opponent: PlayerProfile;
+  isChallenged: boolean;
+  status: BattleStatus;
+  totalScores: {
+    player: number;
+    opponent: number;
+  };
+  winningStatus?: BattleWinningStatus;
+};

package/src/business/types/breaking-news.ts

@@ -0,0 +1,43 @@
+import type { Media } from './media';
+import type { MultilingualLabel } from './multilingual';
+import type { UserEngagement } from './user-engagement';
+
+export type BreakingNewsActivity = {
+  informations: {
+    name: MultilingualLabel;
+    description: MultilingualLabel;
+    isLongText: boolean;
+    text?: MultilingualLabel;
+    coverMedia?: Media;
+  };
+  notification: {
+    isRecurringNotification: boolean;
+    isNotificationActive: boolean;
+    notificationTime: string;
+  };
+  scheduling: {
+    startDate: string;
+    endDate: string;
+  };
+  userEngagement: UserEngagement;
+  id: number;
+  type: 'breaking-news';
+};
+
+export type BreakingNewsCardDetails = {
+  id: number;
+  coverMedia?: {
+    type: 'image' | 'video';
+    url: string;
+  };
+  name: MultilingualLabel;
+  description: MultilingualLabel;
+  text?: MultilingualLabel;
+  utcStartDate: string;
+  isRecurringNotification: boolean;
+};
+
+export type BreakingNewsCard = {
+  details: BreakingNewsCardDetails;
+  userEngagement: UserEngagement;
+};