@memori.ai/memori-react 7.4.1 → 7.4.2

package/src/helpers/statistics.ts

@@ -1,158 +1,4 @@
-import {
-  Stats,
-  GamificationLevel,
-  EventLog,
-  UsersLog,
-  Memori,
-  Invitation,
-} from '@memori.ai/memori-api-client/dist/types';
-import memoriApiClient from '@memori.ai/memori-api-client';
-
-const { deleteSession, getStatistics, initSession } = memoriApiClient();
-
-const conversionTable: { [key: string]: number } = {
-  totalReceivers: 0.2,
-  receiversWithMemories: 0.4,
-  totalMemories: 0.2,
-  publicMemories: 0.4,
-  memoriesWithMedia: 0.4,
-  totalQuestions: 0.2,
-  publicQuestions: 0.3,
-  questionsWithMoreThanOneAnswer: 0.4,
-  totalStories: 0.2,
-  publicStories: 0.4,
-  storiesWithDate: 0.5,
-  storiesWithPlace: 0.4,
-  storiesWithDateAndPlace: 0.6,
-  unansweredQuestions: 0,
-  successfulCorrelations: 0,
-  failedCorrelations: 0,
-};
-
-export const BADGES_MAP: Map<number, string> = new Map([
-  [0, '🆕'],
-  [10, '🐹'],
-  [20, '🐇'],
-  [30, '🐰'],
-  [40, '💡'],
-  [50, '🏆'],
-  [60, '🏅'],
-  [70, '🥉'],
-  [80, '🥈'],
-  [90, '🥇'],
-  [100, '🔥'],
-  [110, '🎓'],
-  [120, '🤖'],
-  [130, '👾'],
-  [150, '🌍'],
-  [180, '💜'],
-  [200, '💙'],
-  [250, '🧡'],
-  [300, '💚'],
-  [350, '💛'],
-  [400, '💖'],
-  [450, '💝'],
-  [500, '🖤'],
-  [550, '❤️'],
-  [600, '🧠'],
-]);
-
-export const getBadge = (points: number): string => {
-  const unlockedBadges = Array.from(BADGES_MAP.keys()).filter(
-    (k: number) => k <= points
-  );
-
-  if (unlockedBadges.length > 0) {
-    const lastBadge = unlockedBadges[unlockedBadges.length - 1];
-    return BADGES_MAP.get(lastBadge) as string;
-  }
-
-  return '';
-};
-
-export const getNextBadge = (
-  badge: string
-): { points: number; badge: string } | undefined => {
-  if (badge === '🆕') {
-    return { points: 10, badge: '🐹' };
-  }
-  let nextBadgePoints;
-  let nextBadge;
-
-  let currentSeen = false;
-  for (const [key, value] of BADGES_MAP) {
-    if (currentSeen) {
-      nextBadgePoints = key;
-      nextBadge = value;
-      break;
-    }
-
-    if (value === badge) {
-      currentSeen = true;
-    }
-  }
-
-  return nextBadge && nextBadgePoints
-    ? {
-        points: nextBadgePoints,
-        badge: nextBadge,
-      }
-    : undefined;
-};
-
-export const getPointsForBadge = (badge: string): number => {
-  let points = 0;
-
-  for (const [key, value] of BADGES_MAP) {
-    if (value === badge) {
-      points = key;
-      break;
-    }
-  }
-
-  return points;
-};
-
-export const getPointsFromStats = (stats: Stats): number => {
-  let points = 0;
-  Object.entries(stats).forEach(stat => {
-    if (stat[0] in conversionTable) {
-      points += stat[1] * conversionTable[stat[0]];
-    }
-  });
-  return Math.trunc(points);
-};
-
-export const getGamificationLevel = (points: number): GamificationLevel => {
-  const roundedPoints = Math.round(points);
-  const badge = getBadge(roundedPoints);
-  const pointsForCurrentBadge = getPointsForBadge(badge);
-  const nextBadge = getNextBadge(badge);
-
-  return {
-    points: roundedPoints,
-    badge,
-    pointsForCurrentBadge,
-    nextBadge,
-  };
-};
-
-export const getGamificationLevelByStats = (
-  stats: Stats
-): GamificationLevel => {
-  const floatPoints = getPointsFromStats(stats);
-  const points = Math.round(floatPoints);
-  const badge = getBadge(points);
-  const pointsForCurrentBadge = getPointsForBadge(badge);
-  const nextBadge = getNextBadge(badge);
-
-  return {
-    points,
-    badge,
-    pointsForCurrentBadge,
-    nextBadge,
-  };
-};
+import { EventLog, UsersLog } from '@memori.ai/memori-api-client/dist/types';
 
 const groupBy = <T>(array: T[], predicate: (v: T) => string) =>
   array.reduce((acc, value) => {
@@ -210,43 +56,3 @@ export const eventLogGroupUsersByDate = (eventLogs: EventLog[]): UsersLog[] => {
   });
   return userLogs;
 };
-
-export const getMemoriUnansQuestions = async (memori: Memori) => {
-  if (memori.privacyType === 'SECRET' || !memori.isGiver) return 0;
-  try {
-    if (!memori.giverTag && !!memori.receivedInvitations?.length) {
-      let giverInvitation = memori.receivedInvitations.find(
-        (i: Invitation) => i.type === 'GIVER' && i.state === 'ACCEPTED'
-      );
-
-      if (giverInvitation) {
-        memori.giverTag = giverInvitation.tag;
-        memori.giverPIN = giverInvitation.pin;
-      }
-    }
-
-    const { sessionID, currentState, ...response } = await initSession({
-      memoriID: memori.engineMemoriID ?? '',
-      password: memori.secretToken,
-      tag: memori.giverTag,
-      pin: memori.giverPIN,
-    });
-
-    if (response.resultCode !== 0 || !sessionID) {
-      return 0;
-    }
-
-    const { statistics, ...resp } = await getStatistics(sessionID);
-
-    await deleteSession(sessionID);
-
-    if (statistics && resp.resultCode === 0) {
-      return statistics.unansweredQuestions;
-    }
-
-    return 0;
-  } catch (e) {
-    console.log(e);
-    return 0;
-  }
-};

package/src/helpers/statistics.test.ts

@@ -1,213 +0,0 @@
-import { EventLog, Stats } from '@memori.ai/memori-api-client/dist/types';
-import {
-  getBadge,
-  getNextBadge,
-  getPointsForBadge,
-  getPointsFromStats,
-  getGamificationLevel,
-  eventLogGroupUsersByDate,
-  getGamificationLevelByStats,
-} from './statistics';
-
-export const stats: Stats = {
-  totalReceivers: 2,
-  receiversWithMemories: 1,
-  totalMemories: 50,
-  publicMemories: 30,
-  memoriesWithMedia: 25,
-  totalQuestions: 35,
-  publicQuestions: 30,
-  questionsWithMoreThanOneAnswer: 20,
-  totalStories: 15,
-  publicStories: 10,
-  storiesWithDate: 5,
-  storiesWithPlace: 3,
-  storiesWithDateAndPlace: 2,
-  unansweredQuestions: 10,
-  successfulCorrelations: 5,
-  failedCorrelations: 1,
-};
-
-export const eventLogs: EventLog[] = [
-  {
-    eventLogID: '28c9f4c8-d7d5-44c4-9f79-418944b03e82',
-    eventType: 'MemoriOpened',
-    ipAddress: '::ffff:10.11.12.14',
-    memoriID: '1afe57c6-1b69-4a61-96ea-52bf7b8d158e',
-    timestamp: '2022-04-15T15:00:27.534191',
-    userAgent: 'RestSharp/106.13.0.0',
-  },
-  {
-    eventLogID: '28c9f4c8-d7d5-44c4-9f79-418944b03e83',
-    eventType: 'MemoriOpened',
-    ipAddress: '::ffff:10.11.12.13',
-    memoriID: '1afe57c6-1b69-4a61-96ea-52bf7b8d158e',
-    timestamp: '2022-04-15T15:00:27.534191',
-    userAgent: 'RestSharp/106.13.0.0',
-  },
-  {
-    eventLogID: '28c9f4c8-d7d5-44c4-9f79-418944b03e84',
-    eventType: 'MemoriClosed',
-    ipAddress: '::ffff:10.11.12.13',
-    memoriID: '1afe57c6-1b69-4a61-96ea-52bf7b8d158e',
-    timestamp: '2022-04-15T15:10:27.534191',
-    userAgent: 'RestSharp/106.13.0.0',
-  },
-  {
-    eventLogID: '28c9f4c8-d7d5-44c4-9f79-418944b03e85',
-    eventType: 'MemoriOpened',
-    ipAddress: '::ffff:10.11.12.13',
-    memoriID: '1afe57c6-1b69-4a61-96ea-52bf7b8d158e',
-    timestamp: '2022-04-15T15:15:27.534191',
-    userAgent: 'RestSharp/106.13.0.0',
-  },
-  {
-    eventLogID: '28c9f4c8-d7d5-44c4-9f79-418944b03e86',
-    eventType: 'MemoriClosed',
-    ipAddress: '::ffff:10.11.12.13',
-    memoriID: '1afe57c6-1b69-4a61-96ea-52bf7b8d158e',
-    timestamp: '2022-04-15T15:20:27.534191',
-    userAgent: 'RestSharp/106.13.0.0',
-  },
-  {
-    eventLogID: '28c9f4c8-d7d5-44c4-9f79-418944b03e88',
-    eventType: 'MemoriClosed',
-    ipAddress: undefined,
-    memoriID: '1afe57c6-1b69-4a61-96ea-52bf7b8d158e',
-    timestamp: '2022-04-15T15:28:27.534191',
-    userAgent: 'RestSharp/106.13.0.0',
-  },
-];
-
-describe('getBadge', () => {
-  it('should return 🆕 badge for 0 points', () => {
-    expect(getBadge(0)).toBe('🆕');
-  });
-  it('should return 🐹 for 10 points', () => {
-    expect(getBadge(10)).toBe('🐹');
-  });
-  it('should return 🥇 for 99 points', () => {
-    expect(getBadge(99)).toBe('🥇');
-  });
-  it('should return 🥇 for 99.9 points with round', () => {
-    expect(getBadge(99.9)).toBe('🥇');
-  });
-  it('should return 🔥 for 100 points', () => {
-    expect(getBadge(100)).toBe('🔥');
-  });
-  it('should return 🔥 for 101 points', () => {
-    expect(getBadge(101)).toBe('🔥');
-  });
-  it('should return 🌎 for 150 points', () => {
-    expect(getBadge(150)).toBe('🌍');
-  });
-  it('should return 🧠 for 1000 points', () => {
-    expect(getBadge(1000)).toBe('🧠');
-  });
-});
-
-describe('getNextBadge', () => {
-  it('should return { points: 10, badge: "🐹" } for 🆕 badge', () => {
-    expect(getNextBadge('🆕')).toEqual({ points: 10, badge: '🐹' });
-  });
-  it('should return { points: 150, badge: "🌍" } for 👾', () => {
-    expect(getNextBadge('👾')).toEqual({ points: 150, badge: '🌍' });
-  });
-  it('should return { points: 600, badge: "🧠" } for ❤', () => {
-    expect(getNextBadge('❤️')).toEqual({ points: 600, badge: '🧠' });
-  });
-});
-
-describe('getPointsForBadge', () => {
-  it('should return 0 for "new" badge', () => {
-    expect(getPointsForBadge('🆕')).toBe(0);
-  });
-  it('should return 10 for 🐹', () => {
-    expect(getPointsForBadge('🐹')).toBe(10);
-  });
-  it('should return 150 for 🌎', () => {
-    expect(getPointsForBadge('🌍')).toBe(150);
-  });
-  it('should return 600 for 🧠', () => {
-    expect(getPointsForBadge('🧠')).toBe(600);
-  });
-});
-
-describe('getPointsFromStats', () => {
-  it('should return 0 for no stats', () => {
-    expect(getPointsFromStats({} as Stats)).toBe(0);
-  });
-  it('should return x for stats', () => {
-    expect(getPointsFromStats(stats)).toBe(68);
-  });
-});
-
-describe('getGamificationLevel', () => {
-  it('should return correct level for 0 points', () => {
-    expect(getGamificationLevel(0)).toEqual({
-      points: 0,
-      badge: '🆕',
-      pointsForCurrentBadge: 0,
-      nextBadge: { points: 10, badge: '🐹' },
-    });
-  });
-  it('should return correct level with 68 points', () => {
-    expect(getGamificationLevel(68.34)).toEqual({
-      points: 68,
-      badge: '🏅',
-      pointsForCurrentBadge: 60,
-      nextBadge: { points: 70, badge: '🥉' },
-    });
-  });
-  it('should return correct level with 100 points', () => {
-    expect(getGamificationLevel(100)).toEqual({
-      points: 100,
-      badge: '🔥',
-      pointsForCurrentBadge: 100,
-      nextBadge: { points: 110, badge: '🎓' },
-    });
-  });
-  it('should return correct level with 68 points and correct float round', () => {
-    expect(getGamificationLevel(67.84)).toEqual({
-      points: 68,
-      badge: '🏅',
-      pointsForCurrentBadge: 60,
-      nextBadge: { points: 70, badge: '🥉' },
-    });
-  });
-  it('should return correct level with 99.9 points', () => {
-    expect(getGamificationLevel(99.9)).toEqual({
-      points: 100,
-      badge: '🔥',
-      pointsForCurrentBadge: 100,
-      nextBadge: { points: 110, badge: '🎓' },
-    });
-  });
-  it('should return correct level with overflow 9999 points', () => {
-    expect(getGamificationLevel(9999)).toEqual({
-      points: 9999,
-      badge: '🧠',
-      pointsForCurrentBadge: 600,
-      nextBadge: undefined,
-    });
-  });
-});
-
-describe('getGamificationLevelByStats', () => {
-  it('should return correct level for no stats', () => {
-    expect(getGamificationLevelByStats({} as Stats)).toEqual({
-      points: 0,
-      badge: '🆕',
-      pointsForCurrentBadge: 0,
-      nextBadge: { points: 10, badge: '🐹' },
-    });
-  });
-  it('should return correct level for stats', () => {
-    expect(getGamificationLevelByStats(stats)).toEqual({
-      points: 68,
-      badge: '🏅',
-      pointsForCurrentBadge: 60,
-      nextBadge: { points: 70, badge: '🥉' },
-    });
-  });
-});