diff --git a/src/components/Splash/SplashRoot.tsx b/src/components/Splash/SplashRoot.tsx
index d4fcb14f32e46e74982c92b58c093e6040013b71..f799f40d1593f3b51d6aefddd4e68203dddf6fe2 100644
--- a/src/components/Splash/SplashRoot.tsx
+++ b/src/components/Splash/SplashRoot.tsx
@@ -79,6 +79,13 @@ const SplashRoot = ({
if (subscribed && resultBoss.result && resultBoss.profile) {
profile = resultBoss.profile
}
+ const resultQuiz = await initializationService.initQuizEntity(
+ profile.quizHash
+ )
+ if (subscribed && resultQuiz.result && resultQuiz.profile) {
+ profile = resultQuiz.profile
+ }
+
const resultChallengeEntity = await initializationService.initChallengeEntity(
profile.challengeHash
)
diff --git a/src/db/challengeEntity.json b/src/db/challengeEntity.json
index a0a47fecd78df364bf98895d3188e799320f3f76..fd5ebc5242a7d1e4c7a4e789ef720e19fa3e23b8 100644
--- a/src/db/challengeEntity.json
+++ b/src/db/challengeEntity.json
@@ -5,11 +5,13 @@
"description": "foobar",
"target": 15,
"relationships": {
+ "quiz": {
+ "data": { "_id": "QUIZ001", "_type": "com.grandlyon.ecolyo.quiz" }
+ },
"boss": {
"data": { "_id": "BOSS001", "_type": "com.grandlyon.ecolyo.boss" }
}
- },
- "quizType": "Culture Générale"
+ }
},
{
"_id": "CHALLENGE0002",
@@ -17,11 +19,13 @@
"description": "foobar",
"target": 15,
"relationships": {
+ "quiz": {
+ "data": { "_id": "QUIZ002", "_type": "com.grandlyon.ecolyo.quiz" }
+ },
"boss": {
"data": { "_id": "BOSS002", "_type": "com.grandlyon.ecolyo.boss" }
}
- },
- "quizType": "Culture Générale"
+ }
},
{
"_id": "CHALLENGE0003",
@@ -29,10 +33,12 @@
"description": "foobar",
"target": 15,
"relationships": {
+ "quiz": {
+ "data": { "_id": "QUIZ003", "_type": "com.grandlyon.ecolyo.quiz" }
+ },
"boss": {
"data": { "_id": "BOSS003", "_type": "com.grandlyon.ecolyo.boss" }
}
- },
- "quizType": "Culture Générale"
+ }
}
]
diff --git a/src/db/quizEntity.json b/src/db/quizEntity.json
new file mode 100644
index 0000000000000000000000000000000000000000..dafa2ab2c808ff4791bcca497066d162f9c1862a
--- /dev/null
+++ b/src/db/quizEntity.json
@@ -0,0 +1,239 @@
+[
+ {
+ "_id": "QUIZ001",
+ "questions": [
+ {
+ "questionLabel": "Quelle longueur faisait l’aqueduc du Gier pour acheminer l’eau sur Lyon à l’époque romaine ?",
+ "answers": [
+ { "answerLabel": "86 km", "isTrue": true },
+ {
+ "answerLabel": "78 km",
+ "isTrue": false
+ },
+ {
+ "answerLabel": "56 km",
+ "isTrue": false
+ }
+ ],
+ "explanation": "L’aqueduc du Gier est un des aqueducs antiques de Lyon desservant la ville antique de Lugdunum. Avec ses 86 km il est le plus long des quatre aqueducs ayant alimenté la ville en eau, et celui dont les structures sont le mieux conservées. Il doit son nom au fait qu'il puise aux sources du Gier, affluent du Rhône",
+ "source": "string"
+ },
+ {
+ "questionLabel": "En 1800 à Lyon, combien de points d'eau y avait-il par habitants ?",
+ "answers": [
+ {
+ "answerLabel": "1 point d’eau public pour 800 habitants.",
+ "isTrue": true
+ },
+ {
+ "answerLabel": "1 point d’eau public pour 400 habitants.",
+ "isTrue": false
+ },
+ {
+ "answerLabel": "1 point d’eau public pour 200 habitants.",
+ "isTrue": false
+ }
+ ],
+ "explanation": "string",
+ "source": "string"
+ },
+ {
+ "questionLabel": "Qui officialise la création de la Compagnie Générale des eaux ?",
+ "answers": [
+ { "answerLabel": "François Mitterrand", "isTrue": false },
+ {
+ "answerLabel": "Napoléon Ier",
+ "isTrue": true
+ },
+ {
+ "answerLabel": "Napoléon III",
+ "isTrue": false
+ }
+ ],
+ "explanation": "string",
+ "source": "string"
+ },
+ {
+ "questionLabel": "Quel ingénieur est à l’origine du projet d’alimentation en eau en 1856 ?",
+ "answers": [
+ { "answerLabel": "string", "isTrue": false },
+ {
+ "answerLabel": "string",
+ "isTrue": false
+ },
+ {
+ "answerLabel": "Aristide Dumont",
+ "isTrue": true
+ }
+ ],
+ "explanation": "string",
+ "source": "string"
+ }
+ ],
+ "customQuestion": {
+ "questionLabel": "Custom1",
+ "type": "Calculation",
+ "timeStep": 0,
+ "interval": 0,
+ "Period": {}
+ }
+ },
+ {
+ "_id": "QUIZ002",
+ "questions": [
+ {
+ "questionLabel": "Quelle longueur faisait l’aqueduc du Gier pour acheminer l’eau sur Lyon à l’époque romaine ?",
+ "answers": [
+ { "answerLabel": "86 km", "isTrue": true },
+ {
+ "answerLabel": "78 km",
+ "isTrue": false
+ },
+ {
+ "answerLabel": "56 km",
+ "isTrue": false
+ }
+ ],
+ "explanation": "L’aqueduc du Gier est un des aqueducs antiques de Lyon desservant la ville antique de Lugdunum. Avec ses 86 km il est le plus long des quatre aqueducs ayant alimenté la ville en eau, et celui dont les structures sont le mieux conservées. Il doit son nom au fait qu'il puise aux sources du Gier, affluent du Rhône",
+ "source": "string"
+ },
+ {
+ "questionLabel": "En 1800 à Lyon, combien de points d'eau y avait-il par habitants ?",
+ "answers": [
+ {
+ "answerLabel": "1 point d’eau public pour 800 habitants.",
+ "isTrue": true
+ },
+ {
+ "answerLabel": "1 point d’eau public pour 400 habitants.",
+ "isTrue": false
+ },
+ {
+ "answerLabel": "1 point d’eau public pour 200 habitants.",
+ "isTrue": false
+ }
+ ],
+ "explanation": "string",
+ "source": "string"
+ },
+ {
+ "questionLabel": "Qui officialise la création de la Compagnie Générale des eaux ?",
+ "answers": [
+ { "answerLabel": "François Mitterrand", "isTrue": false },
+ {
+ "answerLabel": "Napoléon Ier",
+ "isTrue": true
+ },
+ {
+ "answerLabel": "Napoléon III",
+ "isTrue": false
+ }
+ ],
+ "explanation": "string",
+ "source": "string"
+ },
+ {
+ "questionLabel": "Quel ingénieur est à l’origine du projet d’alimentation en eau en 1856 ?",
+ "answers": [
+ { "answerLabel": "string", "isTrue": false },
+ {
+ "answerLabel": "string",
+ "isTrue": false
+ },
+ {
+ "answerLabel": "Aristide Dumont",
+ "isTrue": true
+ }
+ ],
+ "explanation": "string",
+ "source": "string"
+ }
+ ],
+ "customQuestion": {
+ "questionLabel": "Custom1",
+ "type": "Calculation",
+ "timeStep": 0,
+ "interval": 0,
+ "Period": {}
+ }
+ },
+ {
+ "_id": "QUIZ003",
+ "questions": [
+ {
+ "questionLabel": "Quelle longueur faisait l’aqueduc du Gier pour acheminer l’eau sur Lyon à l’époque romaine ?",
+ "answers": [
+ { "answerLabel": "86 km", "isTrue": true },
+ {
+ "answerLabel": "78 km",
+ "isTrue": false
+ },
+ {
+ "answerLabel": "56 km",
+ "isTrue": false
+ }
+ ],
+ "explanation": "L’aqueduc du Gier est un des aqueducs antiques de Lyon desservant la ville antique de Lugdunum. Avec ses 86 km il est le plus long des quatre aqueducs ayant alimenté la ville en eau, et celui dont les structures sont le mieux conservées. Il doit son nom au fait qu'il puise aux sources du Gier, affluent du Rhône",
+ "source": "string"
+ },
+ {
+ "questionLabel": "En 1800 à Lyon, combien de points d'eau y avait-il par habitants ?",
+ "answers": [
+ {
+ "answerLabel": "1 point d’eau public pour 800 habitants.",
+ "isTrue": true
+ },
+ {
+ "answerLabel": "1 point d’eau public pour 400 habitants.",
+ "isTrue": false
+ },
+ {
+ "answerLabel": "1 point d’eau public pour 200 habitants.",
+ "isTrue": false
+ }
+ ],
+ "explanation": "string",
+ "source": "string"
+ },
+ {
+ "questionLabel": "Qui officialise la création de la Compagnie Générale des eaux ?",
+ "answers": [
+ { "answerLabel": "François Mitterrand", "isTrue": false },
+ {
+ "answerLabel": "Napoléon Ier",
+ "isTrue": true
+ },
+ {
+ "answerLabel": "Napoléon III",
+ "isTrue": false
+ }
+ ],
+ "explanation": "string",
+ "source": "string"
+ },
+ {
+ "questionLabel": "Quel ingénieur est à l’origine du projet d’alimentation en eau en 1856 ?",
+ "answers": [
+ { "answerLabel": "string", "isTrue": false },
+ {
+ "answerLabel": "string",
+ "isTrue": false
+ },
+ {
+ "answerLabel": "Aristide Dumont",
+ "isTrue": true
+ }
+ ],
+ "explanation": "string",
+ "source": "string"
+ }
+ ],
+ "customQuestion": {
+ "questionLabel": "Custom1",
+ "type": "Calculation",
+ "timeStep": 0,
+ "interval": 0,
+ "Period": {}
+ }
+ }
+]
diff --git a/src/doctypes/com-grandlyon-ecolyo-quiz.ts b/src/doctypes/com-grandlyon-ecolyo-quiz.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b715ba69bb340d83573ebf6f8beb5b58ef71c54c
--- /dev/null
+++ b/src/doctypes/com-grandlyon-ecolyo-quiz.ts
@@ -0,0 +1 @@
+export const QUIZ_DOCTYPE = 'com.grandlyon.ecolyo.quiz'
diff --git a/src/doctypes/index.ts b/src/doctypes/index.ts
index 5ef475cc72a729a46078a4154276c4a4086a123a..d843cb283d143c82a8538e052bf6c5c6b8548483 100644
--- a/src/doctypes/index.ts
+++ b/src/doctypes/index.ts
@@ -12,6 +12,7 @@ import { PROFILE_DOCTYPE } from './com-grandlyon-ecolyo-profile'
import { CHALLENGE_DOCTYPE } from './com-grandlyon-ecolyo-challenge'
import { USERCHALLENGE_DOCTYPE } from './com-grandlyon-ecolyo-userchallenge'
import { BOSS_DOCTYPE } from './com-grandlyon-ecolyo-boss'
+import { QUIZ_DOCTYPE } from './com-grandlyon-ecolyo-quiz'
// the documents schema, necessary for CozyClient
const doctypes = {
@@ -59,6 +60,10 @@ const doctypes = {
doctype: CHALLENGE_DOCTYPE,
attributes: {},
relationships: {
+ quiz: {
+ doctype: QUIZ_DOCTYPE,
+ type: 'has-one',
+ },
boss: {
doctype: BOSS_DOCTYPE,
type: 'has-one',
@@ -75,6 +80,11 @@ const doctypes = {
attributes: {},
relationships: {},
},
+ quiz: {
+ doctype: QUIZ_DOCTYPE,
+ attributes: {},
+ relationships: {},
+ },
}
export default doctypes
@@ -106,3 +116,4 @@ export * from './com-grandlyon-ecolyo-profile'
export * from './com-grandlyon-ecolyo-challenge'
export * from './com-grandlyon-ecolyo-userchallenge'
export * from './com-grandlyon-ecolyo-boss'
+export * from './com-grandlyon-ecolyo-quiz'
diff --git a/src/enum/quiz.enum.ts b/src/enum/quiz.enum.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c9ecd1ce60ca2fdd8d96c9e01566177c4a663b51
--- /dev/null
+++ b/src/enum/quiz.enum.ts
@@ -0,0 +1,9 @@
+export enum QuizState {
+ ONGOING = 0,
+ DONE = 1,
+}
+
+export enum CustomQuestionType {
+ DATA = 0,
+ CALCULATION = 1,
+}
diff --git a/src/models/challenge.model.ts b/src/models/challenge.model.ts
index 7711c0cb0d5da8216acfedd5e43170fdfd32bff1..96cd619d6393be461f1259db31631337b4bb0f7e 100644
--- a/src/models/challenge.model.ts
+++ b/src/models/challenge.model.ts
@@ -4,7 +4,7 @@ import {
} from 'enum/userChallenge.enum'
import { BossEntity, UserBoss, UserBossEntity } from 'models/boss.model'
import { DateTime } from 'luxon'
-import { Dataload } from 'models'
+import { Dataload, QuizEntity, UserQuiz } from 'models'
export interface ChallengeState {
userChallengeList: UserChallenge[]
@@ -17,7 +17,7 @@ export interface ChallengeEntity {
description: string
target: number
boss: BossEntity | null
- quizType: string
+ quizType: QuizEntity | null
}
export interface UserChallengeEntity {
@@ -31,7 +31,7 @@ export interface UserChallengeEntity {
success: UserChallengeSuccess
startDate: string | null
endingDate: string | null
- quiz: null
+ quiz: UserQuiz
}
export interface UserChallenge
@@ -40,5 +40,3 @@ export interface UserChallenge
endingDate: DateTime | null
boss: UserBoss
}
-
-// export interface Quiz {}
diff --git a/src/models/index.ts b/src/models/index.ts
index 0ce595eb820c10439b6e209ba592ae790622facd..e280553e272f969b8b2a7cf1b5df2d3e45e0c6eb 100644
--- a/src/models/index.ts
+++ b/src/models/index.ts
@@ -12,6 +12,7 @@ export * from './indicator.model'
export * from './konnector.model'
export * from './modal.model'
export * from './profile.model'
+export * from './quiz.model'
export * from './relation.model'
export * from './report.model'
export * from './timePeriod.model'
diff --git a/src/models/profile.model.ts b/src/models/profile.model.ts
index f47dd96ca6fd4b98d01223c966af81a885c00248..a3a14842f6ae294e768054a35d248b87e2961ca2 100644
--- a/src/models/profile.model.ts
+++ b/src/models/profile.model.ts
@@ -5,6 +5,7 @@ export interface Profile {
ecogestureHash: string
challengeHash: string
bossHash: string
+ quizHash: string
isFirstConnection: boolean
haveSeenFavoriteModal: boolean
haveSeenLastReport: boolean
diff --git a/src/models/quiz.model.ts b/src/models/quiz.model.ts
new file mode 100644
index 0000000000000000000000000000000000000000..99fb8152c74c1fa504a72584d18dfc7056a7e7b2
--- /dev/null
+++ b/src/models/quiz.model.ts
@@ -0,0 +1,38 @@
+import { CustomQuestionType, QuizState } from 'enum/quiz.enum'
+import { TimeStep } from 'enum/timeStep.enum'
+
+export interface Answer {
+ answerLabel: string
+ isTrue: boolean
+}
+
+export interface QuestionEntity {
+ questionLabel: string
+ answers: Answer[]
+ explanation: string
+ source: string
+}
+
+export interface UserQuestion extends QuestionEntity {
+ result: boolean
+}
+
+export interface CustomQuestionEntity {
+ questionLabel: string
+ type: CustomQuestionType
+ timeStep: TimeStep
+ interval: TimeStep
+ Period: {}
+}
+
+export interface QuizEntity {
+ id: string
+ questions: QuestionEntity[]
+ customQuestion: CustomQuestionEntity
+}
+
+export interface UserQuiz extends Omit<QuizEntity, 'questions'> {
+ questions: UserQuestion[]
+ state: QuizState
+ result: number
+}
diff --git a/src/services/challenge.service.ts b/src/services/challenge.service.ts
index 5ce53df8fc31bef90262ea9fac280902566fac8f..edbb6a15ed46eedc96b9504adf286301e7c3741e 100644
--- a/src/services/challenge.service.ts
+++ b/src/services/challenge.service.ts
@@ -1,25 +1,32 @@
import { Client, QueryDefinition, QueryResult, Q } from 'cozy-client'
+import { DateTime } from 'luxon'
import { CHALLENGE_DOCTYPE, USERCHALLENGE_DOCTYPE } from 'doctypes'
import {
ChallengeEntity,
UserChallenge,
UserChallengeEntity,
-} from 'models/challenge.model'
-import { BossEntity, UserBoss } from 'models/boss.model'
-
+ BossEntity,
+ UserBoss,
+ Datachart,
+ Dataload,
+ QuizEntity,
+ Relation,
+ TimePeriod,
+ UserQuiz,
+} from 'models'
import {
UserChallengeState,
UserChallengeSuccess,
} from 'enum/userChallenge.enum'
-import BossService from './boss.service'
import { UserChallengeUpdateFlag } from 'enum/userChallenge.enum'
-import { DateTime } from 'luxon'
-import { Datachart, Dataload, Relation, TimePeriod } from 'models'
-import { getRelationship } from 'utils/utils'
-import ConsumptionDataManager from './consumption.service'
import { TimeStep } from 'enum/timeStep.enum'
import { UserBossState } from 'enum/userBoss.enum'
+import BossService from 'services/boss.service'
+import QuizService from 'services/quiz.service'
+import ConsumptionDataManager from 'services/consumption.service'
+import { getRelationship } from 'utils/utils'
+
export default class ChallengeService {
private readonly _client: Client
@@ -60,10 +67,14 @@ export default class ChallengeService {
const userChallenge: UserChallenge = {
...userChallengeEntity,
startDate: userChallengeEntity.startDate
- ? DateTime.fromISO(userChallengeEntity.startDate, { zone: 'utc' })
+ ? DateTime.fromISO(userChallengeEntity.startDate, {
+ zone: 'utc',
+ })
: null,
endingDate: userChallengeEntity.endingDate
- ? DateTime.fromISO(userChallengeEntity.endingDate, { zone: 'utc' })
+ ? DateTime.fromISO(userChallengeEntity.endingDate, {
+ zone: 'utc',
+ })
: null,
boss: {
...userChallengeEntity.boss,
@@ -84,7 +95,8 @@ export default class ChallengeService {
*/
public parseChallengeEntityToUserChallenge(
challenge: ChallengeEntity,
- boss: UserBoss
+ boss: UserBoss,
+ quiz: UserQuiz
): UserChallenge {
const userChallenge: UserChallenge = {
id: challenge.id,
@@ -97,7 +109,7 @@ export default class ChallengeService {
success: UserChallengeSuccess.ONGOING,
startDate: null,
endingDate: null,
- quiz: null,
+ quiz: quiz,
}
return userChallenge
}
@@ -110,27 +122,42 @@ export default class ChallengeService {
const queryChallengeEntity: QueryDefinition = Q(CHALLENGE_DOCTYPE).include([
'boss',
])
+ const querySeasonEntityIncludeQuiz: QueryDefinition = Q(
+ CHALLENGE_DOCTYPE
+ ).include(['quiz'])
const {
data: challengeEntityList,
- included: bossEntityList,
+ included: bossEntities,
}: QueryResult<ChallengeEntity[], BossEntity[]> = await this._client.query(
queryChallengeEntity
)
-
+ const {
+ included: quizEntities,
+ }: QueryResult<ChallengeEntity[], QuizEntity[]> = await this._client.query(
+ querySeasonEntityIncludeQuiz
+ )
const userChallengeList: UserChallenge[] = await this.getAllUserChallengeEntities()
const bossService = new BossService(this._client)
+ const quizService = new QuizService(this._client)
let buildList: UserChallenge[] = []
if (challengeEntityList.length > 0 && userChallengeList.length === 0) {
challengeEntityList.forEach(async challenge => {
const bossEntityRelation: Relation = getRelationship(challenge, 'boss')
+ const quizEntityRelation: Relation = getRelationship(challenge, 'quiz')
const boss: UserBoss = bossService.getBossfromBossEntities(
- bossEntityList || [],
+ bossEntities || [],
bossEntityRelation._id
)
+ const quiz: UserQuiz = quizService.getUserQuizfromQuizEntities(
+ quizEntities || [],
+ quizEntityRelation._id
+ )
const userChallenge = this.parseChallengeEntityToUserChallenge(
challenge,
- boss
+ boss,
+ quiz
)
+
buildList.push(userChallenge)
})
buildList = this.unLockCurrentUserChallenge(buildList)
@@ -148,12 +175,20 @@ export default class ChallengeService {
challenge,
'boss'
)
+ const quizEntityRelation: Relation = getRelationship(
+ challenge,
+ 'quiz'
+ )
const boss: UserBoss = bossService.getBossfromBossEntities(
- bossEntityList || [],
+ bossEntities || [],
bossEntityRelation._id
)
+ const quiz: UserQuiz = quizService.getUserQuizfromQuizEntities(
+ quizEntities || [],
+ quizEntityRelation._id
+ )
buildList.push(
- this.parseChallengeEntityToUserChallenge(challenge, boss)
+ this.parseChallengeEntityToUserChallenge(challenge, boss, quiz)
)
}
})
diff --git a/src/services/initialization.service.ts b/src/services/initialization.service.ts
index 65b29741a1a95cffd3ba4905791be26a07947fb1..0d675b86866069126615d34fe281321cc5e8185c 100644
--- a/src/services/initialization.service.ts
+++ b/src/services/initialization.service.ts
@@ -16,6 +16,7 @@ import {
ENEDIS_HOUR_DOCTYPE,
CHALLENGE_DOCTYPE,
BOSS_DOCTYPE,
+ QUIZ_DOCTYPE,
} from 'doctypes'
import { FluidType } from 'enum/fluid.enum'
@@ -26,6 +27,7 @@ import ChallengeService from 'services/challenge.service'
import ecogestureData from 'db/ecogestureData.json'
import challengeEntityData from 'db/challengeEntity.json'
import bossEntityData from 'db/bossEntity.json'
+import quizEntityData from 'db/quizEntity.json'
import ProfileService from 'services/profile.service'
import profileData from 'db/profileData.json'
@@ -34,6 +36,7 @@ import KonnectorService from 'services/konnector.service'
import AccountService from 'services/account.service'
import FluidService from 'services/fluid.service'
import BossService from 'services/boss.service'
+import QuizService from 'services/quiz.service'
import { hashFile } from 'utils/hash'
import { getActualReportDate } from 'utils/date'
@@ -505,6 +508,111 @@ export default class InitializationService {
}
}
+ public async initQuizEntity(
+ hash: string
+ ): Promise<{
+ result: boolean
+ profile: Profile | null
+ }> {
+ const quizHash = hashFile(quizEntityData)
+ const quizService = new QuizService(this._client)
+ const profileService = new ProfileService(this._client)
+
+ // Populate data if none quizEntity exists
+ const loadedQuizEntity = await quizService.getAllQuizEntities()
+ if (
+ !loadedQuizEntity ||
+ (loadedQuizEntity && loadedQuizEntity.length === 0)
+ ) {
+ // Populate the doctype with data
+ try {
+ for (let i = 0; i <= quizEntityData.length - 1; i++) {
+ await this._client.create(QUIZ_DOCTYPE, quizEntityData[i])
+ }
+ // Check of created document
+ const checkCount = await quizService.getAllQuizEntities()
+ if (
+ !checkCount ||
+ (checkCount && checkCount.length !== quizEntityData.length)
+ ) {
+ throw new Error(
+ 'initQuizEntity: Created quiz type entities does not match'
+ )
+ }
+ // Update profil with the hash
+ const updatedProfile = await profileService.updateProfile({
+ quizHash: quizHash,
+ })
+ if (updatedProfile) {
+ console.log(
+ '%c Initialization: Quiz entities created',
+ 'background: #222; color: white'
+ )
+ return {
+ result: true,
+ profile: updatedProfile,
+ }
+ } else {
+ throw new Error('initQuizEntity: Profile not updated')
+ }
+ } catch (error) {
+ console.log('Initialization error: ', error)
+ throw error
+ }
+ }
+
+ // Update if the hash is not the same as the one from profile
+ if (hash !== quizHash) {
+ // Update the doctype
+ try {
+ // Deletion of all documents
+ await quizService.deleteAllQuizEntities()
+ // Population with the data
+ await Promise.all(
+ quizEntityData.map(async quizEntity => {
+ await this._client.create(QUIZ_DOCTYPE, quizEntity)
+ })
+ )
+ // Check of created document
+ const checkCount = await quizService.getAllQuizEntities()
+ if (
+ !checkCount ||
+ (checkCount && checkCount.length !== quizEntityData.length)
+ ) {
+ throw new Error(
+ 'initQuizEntity: Created quiz entities does not match'
+ )
+ }
+ // Update profil with the hash
+ const updatedProfile = await profileService.updateProfile({
+ quizHash: quizHash,
+ })
+ if (updatedProfile) {
+ console.log(
+ '%c Initialization: Quiz entities updated',
+ 'background: #222; color: white'
+ )
+ return {
+ result: true,
+ profile: updatedProfile,
+ }
+ } else {
+ throw new Error('initQuizEntity: Profile not updated')
+ }
+ } catch (error) {
+ console.log('Initialization error: ', error)
+ throw error
+ }
+ } else {
+ // Doctype already up to date
+ console.log(
+ '%c Initialization: Quiz Entity loaded',
+ 'background: #222; color: white'
+ )
+ return { result: true, profile: null }
+ }
+ }
+
public async initReport(
profile: Profile
): Promise<{
@@ -619,7 +727,10 @@ export default class InitializationService {
*/
public async initBossProgress(
userChallenge: UserChallenge
- ): Promise<{ updatedUserChallenge: UserChallenge; dataloads: Dataload[] }> {
+ ): Promise<{
+ updatedUserChallenge: UserChallenge
+ dataloads: Dataload[]
+ }> {
const challengeService = new ChallengeService(this._client)
const consumptionService = new ConsumptionDataManager(this._client)
try {
diff --git a/src/services/quiz.service.spec.ts b/src/services/quiz.service.spec.ts
new file mode 100644
index 0000000000000000000000000000000000000000..39be815ea990226b2d2b544f10874fb00e7a93b9
--- /dev/null
+++ b/src/services/quiz.service.spec.ts
@@ -0,0 +1,112 @@
+import { QueryResult } from 'cozy-client'
+import { UserQuiz, QuizEntity, UserQuestion, QuestionEntity } from 'models'
+import {
+ allQuizEntities,
+ quizEntity,
+ userQuiz,
+} from '../../test/__mocks__/quizData.mock'
+import mockClient from '../../test/__mocks__/client'
+import QuizService from './quiz.service'
+import { CustomQuestionType, QuizState } from 'enum/quiz.enum'
+
+describe('Quiz service', () => {
+ const quizService = new QuizService(mockClient)
+
+ describe('getAllQuizEntities method', () => {
+ it('should return all quiz entity', async () => {
+ const mockQueryResult: QueryResult<QuizEntity[]> = {
+ data: allQuizEntities,
+ bookmark: '',
+ next: false,
+ skip: 0,
+ }
+ mockClient.query.mockResolvedValueOnce(mockQueryResult)
+ const result = await quizService.getAllQuizEntities()
+ expect(result).toEqual(allQuizEntities)
+ })
+ })
+
+ describe('getQuizEntityById method', () => {
+ it('should return one quiz by id', async () => {
+ const mockQueryResult: QueryResult<QuizEntity[]> = {
+ data: [quizEntity],
+ bookmark: '',
+ next: false,
+ skip: 0,
+ }
+ const quizId = 'QUIZ001'
+ mockClient.query.mockResolvedValueOnce(mockQueryResult)
+ const result = await quizService.getQuizEntityById(quizId)
+ expect(result).toEqual(quizEntity)
+ })
+ })
+
+ describe('deleteAllQuizEntities method', () => {
+ it('should delete all quiz entities', async () => {
+ const mockQueryResult: QueryResult<QuizEntity[]> = {
+ data: allQuizEntities,
+ bookmark: '',
+ next: false,
+ skip: 0,
+ }
+ mockClient.query.mockResolvedValueOnce(mockQueryResult)
+
+ const result = await quizService.deleteAllQuizEntities()
+ expect(result).toBeTruthy()
+ })
+
+ it('should throw an error because destroy failed', async () => {
+ const mockQueryResult: QueryResult<QuizEntity[]> = {
+ data: allQuizEntities,
+ bookmark: '',
+ next: false,
+ skip: 0,
+ }
+ mockClient.query.mockResolvedValueOnce(mockQueryResult)
+ mockClient.destroy.mockRejectedValue(new Error())
+ try {
+ await quizService.deleteAllQuizEntities()
+ } catch (error) {
+ expect(error).toEqual(new Error())
+ }
+ })
+ })
+
+ describe('parseQuizEntityToUserQuiz method', () => {
+ it('should return the userQuiz from a quizEntity', () => {
+ const userQuestions: UserQuestion[] = quizEntity.questions.map(
+ (question: QuestionEntity) => {
+ return { ...question, result: false }
+ }
+ )
+ const mockUpdatedQuiz: UserQuiz = {
+ ...quizEntity,
+ questions: userQuestions,
+ customQuestion: {
+ questionLabel: 'Custom1',
+ type: CustomQuestionType.DATA,
+ timeStep: 0,
+ interval: 0,
+ Period: {},
+ },
+ state: QuizState.ONGOING,
+ result: 0,
+ }
+
+ const result = quizService.parseQuizEntityToUserQuiz(quizEntity)
+ expect(result).toEqual(mockUpdatedQuiz)
+ })
+ })
+
+ describe('getUserQuizfromQuizEntities method', () => {
+ it('should return the userQuiz from a quizEntity', () => {
+ const searchId = 'QUIZ001'
+
+ const result = quizService.getUserQuizfromQuizEntities(
+ allQuizEntities,
+ searchId
+ )
+ expect(result).toEqual(userQuiz)
+ })
+ })
+})
diff --git a/src/services/quiz.service.ts b/src/services/quiz.service.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cf2908eb57006f6bc905ebe7dac52326395f22e3
--- /dev/null
+++ b/src/services/quiz.service.ts
@@ -0,0 +1,130 @@
+import { Client, QueryDefinition, QueryResult, Q } from 'cozy-client'
+import { QUIZ_DOCTYPE } from 'doctypes'
+import { QuizState } from 'enum/quiz.enum'
+import { QuestionEntity, QuizEntity, UserQuestion, UserQuiz } from 'models'
+
+export default class QuizService {
+ private readonly _client: Client
+
+ constructor(_client: Client) {
+ this._client = _client
+ }
+
+ /**
+ * Retrieve all quiz entities from db
+ * @returns {QuizEntity[]}
+ */
+ public async getAllQuizEntities(): Promise<QuizEntity[]> {
+ const query: QueryDefinition = Q(QUIZ_DOCTYPE)
+ const { data: quizs }: QueryResult<QuizEntity[]> = await this._client.query(
+ query
+ )
+ return quizs
+ }
+
+ /**
+ * Retrieve quiz entities from db given the id
+ *
+ * @param {string} quizId - ID of the searched quiz
+ * @returns {QuizEntity}
+ */
+ public async getQuizEntityById(quizId: string): Promise<QuizEntity> {
+ const query: QueryDefinition = Q(QUIZ_DOCTYPE)
+ .where({ _id: quizId })
+ .limitBy(1)
+ const { data }: QueryResult<QuizEntity[]> = await this._client.query(query)
+ return data && data[0]
+ }
+
+ /**
+ * Delete all quiz entities from the db
+ * @returns {boolean} - true when deleted with success
+ * @throws {Error}
+ */
+ public async deleteAllQuizEntities(): Promise<boolean> {
+ try {
+ const quizzes = await this.getAllQuizEntities()
+ if (!quizzes) return true
+ for (let index = 0; index < quizzes.length; index++) {
+ await this._client.destroy(quizzes[index])
+ }
+ return true
+ } catch (err) {
+ console.log(err)
+ throw err
+ }
+ }
+
+ /**
+ * Return quiz created from quiz entity
+ * @param {QuizEntity[]} quizEntityList - userQuiz to update
+ * @param {string} searchId - userQuiz to update
+ * @returns {UserQuiz}
+ */
+ public getUserQuizfromQuizEntities(
+ quizEntityList: QuizEntity[],
+ searchId: string
+ ): UserQuiz {
+ let quiz: UserQuiz = {
+ id: '',
+ questions: [],
+ customQuestion: {
+ questionLabel: '',
+ type: 0,
+ timeStep: 0,
+ interval: 0,
+ Period: {},
+ },
+ state: QuizState.ONGOING,
+ result: 0,
+ }
+ if (quizEntityList.length > 0) {
+ const quizEntityIndex = quizEntityList.findIndex(
+ entity => entity.id === searchId
+ )
+ if (quizEntityIndex >= 0) {
+ const quizEntity: QuizEntity = quizEntityList[quizEntityIndex]
+ quiz = this.parseQuizEntityToUserQuiz(quizEntity)
+ }
+ }
+ return quiz
+ }
+
+ /**
+ * Return UserQuestion created from QuestionEntity
+ * @param {QuestionEntity}
+ * @returns {UserQuestion}
+ */
+ public parseQuestionEntityToQuestion(question: QuestionEntity): UserQuestion {
+ const userQuestion: UserQuestion = {
+ ...question,
+ result: false,
+ }
+ return userQuestion
+ }
+
+ /**
+ * Return UserQuiz created from QuizEntity
+ * @param {QuizEntity}
+ * @returns {UserQuiz}
+ */
+ public parseQuizEntityToUserQuiz(quiz: QuizEntity): UserQuiz {
+ const userQuestions: UserQuestion[] = []
+
+ quiz.questions.forEach(question => {
+ const userQuestion: UserQuestion = this.parseQuestionEntityToQuestion(
+ question
+ )
+ userQuestions.push(userQuestion)
+ })
+
+ const userQuiz: UserQuiz = {
+ id: quiz.id,
+ customQuestion: quiz.customQuestion,
+ questions: userQuestions,
+ state: QuizState.ONGOING,
+ result: 0,
+ }
+ return userQuiz
+ }
+}
diff --git a/test/__mocks__/quizData.mock.ts b/test/__mocks__/quizData.mock.ts
new file mode 100644
index 0000000000000000000000000000000000000000..18447e4f828290730a1ad0f706be7e6a2a64711a
--- /dev/null
+++ b/test/__mocks__/quizData.mock.ts
@@ -0,0 +1,230 @@
+import {
+ QuizEntity,
+ QuestionEntity,
+ CustomQuestionEntity,
+ UserQuiz,
+} from 'models'
+
+export const questionEntity: QuestionEntity = {
+ questionLabel:
+ 'Quelle longueur faisait l’aqueduc du Gier pour acheminer l’eau sur Lyon à l’époque romaine ?',
+ answers: [
+ { answerLabel: '86 km', isTrue: true },
+ {
+ answerLabel: '78 km',
+ isTrue: false,
+ },
+ {
+ answerLabel: '56 km',
+ isTrue: false,
+ },
+ ],
+ explanation:
+ "L’aqueduc du Gier est un des aqueducs antiques de Lyon desservant la ville antique de Lugdunum. Avec ses 86 km il est le plus long des quatre aqueducs ayant alimenté la ville en eau, et celui dont les structures sont le mieux conservées. Il doit son nom au fait qu'il puise aux sources du Gier, affluent du Rhône",
+ source: 'string',
+}
+export const customQuestionEntity: CustomQuestionEntity = {
+ questionLabel: 'Custom1',
+ type: 0,
+ timeStep: 0,
+ interval: 0,
+ Period: {},
+}
+
+export const questionEntities: QuestionEntity[] = [
+ {
+ questionLabel:
+ 'Quelle longueur faisait l’aqueduc du Gier pour acheminer l’eau sur Lyon à l’époque romaine ?',
+ answers: [
+ { answerLabel: '86 km', isTrue: true },
+ {
+ answerLabel: '78 km',
+ isTrue: false,
+ },
+ {
+ answerLabel: '56 km',
+ isTrue: false,
+ },
+ ],
+ explanation:
+ "L’aqueduc du Gier est un des aqueducs antiques de Lyon desservant la ville antique de Lugdunum. Avec ses 86 km il est le plus long des quatre aqueducs ayant alimenté la ville en eau, et celui dont les structures sont le mieux conservées. Il doit son nom au fait qu'il puise aux sources du Gier, affluent du Rhône",
+ source: 'string',
+ },
+ {
+ questionLabel:
+ "En 1800 à Lyon, combien de points d'eau y avait-il par habitants ?",
+ answers: [
+ {
+ answerLabel: '1 point d’eau public pour 800 habitants.',
+ isTrue: true,
+ },
+ {
+ answerLabel: '1 point d’eau public pour 400 habitants.',
+ isTrue: false,
+ },
+ {
+ answerLabel: '1 point d’eau public pour 200 habitants.',
+ isTrue: false,
+ },
+ ],
+ explanation: 'string',
+ source: 'string',
+ },
+ {
+ questionLabel:
+ 'Qui officialise la création de la Compagnie Générale des eaux ?',
+ answers: [
+ { answerLabel: 'François Mitterrand', isTrue: false },
+ {
+ answerLabel: 'Napoléon Ier',
+ isTrue: true,
+ },
+ {
+ answerLabel: 'Napoléon III',
+ isTrue: false,
+ },
+ ],
+ explanation: 'string',
+ source: 'string',
+ },
+ {
+ questionLabel:
+ 'Quel ingénieur est à l’origine du projet d’alimentation en eau en 1856 ?',
+ answers: [
+ { answerLabel: 'string', isTrue: false },
+ {
+ answerLabel: 'string',
+ isTrue: false,
+ },
+ {
+ answerLabel: 'Aristide Dumont',
+ isTrue: true,
+ },
+ ],
+ explanation: 'string',
+ source: 'string',
+ },
+ {
+ questionLabel:
+ "Quel type de pompe était utilisé à l'usine des eaux de Caluire jusqu'en 1910 ?",
+ answers: [
+ { answerLabel: 'Pompe de Cornouailles', isTrue: false },
+ {
+ answerLabel: 'Pompe à cordes',
+ isTrue: true,
+ },
+ {
+ answerLabel: 'Pompe à air',
+ isTrue: false,
+ },
+ ],
+ explanation:
+ "Mise en fonctionnement en 1856, 3 pompes à vapeur dites de Cornouailles produisent quelque 20 000 m3 d'eau par jour. Ces pompes mesurent 20 m de haut et 13 m de large pour un poids de 200 tonnes. Leur balancier de 35 tonnes s'actionne toutes les 6 secondes, permettant ainsi l'envoi de 600 m3 d'eau par heure.\nL'usine s'arrêta en 1910 et deux pompes furent démontées en 1938",
+ source: 'string',
+ },
+]
+
+export const quizEntity: QuizEntity = {
+ id: 'QUIZ001',
+ questions: questionEntities,
+ customQuestion: customQuestionEntity,
+}
+
+export const allQuizEntities: QuizEntity[] = [
+ {
+ id: 'QUIZ001',
+ questions: questionEntities,
+ customQuestion: customQuestionEntity,
+ },
+ {
+ id: 'QUIZ002',
+ questions: questionEntities,
+ customQuestion: customQuestionEntity,
+ },
+]
+
+export const userQuiz: UserQuiz = {
+ customQuestion: {
+ Period: {},
+ interval: 0,
+ questionLabel: 'Custom1',
+ timeStep: 0,
+ type: 0,
+ },
+ id: 'QUIZ001',
+ questions: [
+ {
+ answers: [
+ { answerLabel: '86 km', isTrue: true },
+ { answerLabel: '78 km', isTrue: false },
+ { answerLabel: '56 km', isTrue: false },
+ ],
+ explanation:
+ "L’aqueduc du Gier est un des aqueducs antiques de Lyon desservant la ville antique de Lugdunum. Avec ses 86 km il est le plus long des quatre aqueducs ayant alimenté la ville en eau, et celui dont les structures sont le mieux conservées. Il doit son nom au fait qu'il puise aux sources du Gier, affluent du Rhône",
+ questionLabel:
+ 'Quelle longueur faisait l’aqueduc du Gier pour acheminer l’eau sur Lyon à l’époque romaine ?',
+ result: false,
+ source: 'string',
+ },
+ {
+ answers: [
+ {
+ answerLabel: '1 point d’eau public pour 800 habitants.',
+ isTrue: true,
+ },
+ {
+ answerLabel: '1 point d’eau public pour 400 habitants.',
+ isTrue: false,
+ },
+ {
+ answerLabel: '1 point d’eau public pour 200 habitants.',
+ isTrue: false,
+ },
+ ],
+ explanation: 'string',
+ questionLabel:
+ "En 1800 à Lyon, combien de points d'eau y avait-il par habitants ?",
+ result: false,
+ source: 'string',
+ },
+ {
+ answers: [
+ { answerLabel: 'François Mitterrand', isTrue: false },
+ { answerLabel: 'Napoléon Ier', isTrue: true },
+ { answerLabel: 'Napoléon III', isTrue: false },
+ ],
+ explanation: 'string',
+ questionLabel:
+ 'Qui officialise la création de la Compagnie Générale des eaux ?',
+ result: false,
+ source: 'string',
+ },
+ {
+ answers: [
+ { answerLabel: 'string', isTrue: false },
+ { answerLabel: 'string', isTrue: false },
+ { answerLabel: 'Aristide Dumont', isTrue: true },
+ ],
+ explanation: 'string',
+ questionLabel:
+ 'Quel ingénieur est à l’origine du projet d’alimentation en eau en 1856 ?',
+ result: false,
+ source: 'string',
+ },
+ {
+ answers: [
+ { answerLabel: 'Pompe de Cornouailles', isTrue: false },
+ { answerLabel: 'Pompe à cordes', isTrue: true },
+ { answerLabel: 'Pompe à air', isTrue: false },
+ ],
+ explanation:
+ "Mise en fonctionnement en 1856, 3 pompes à vapeur dites de Cornouailles produisent quelque 20 000 m3 d'eau par jour. Ces pompes mesurent 20 m de haut et 13 m de large pour un poids de 200 tonnes. Leur balancier de 35 tonnes s'actionne toutes les 6 secondes, permettant ainsi l'envoi de 600 m3 d'eau par heure.\nL'usine s'arrêta en 1910 et deux pompes furent démontées en 1938",
+ questionLabel:
+ "Quel type de pompe était utilisé à l'usine des eaux de Caluire jusqu'en 1910 ?",
+ result: false,
+ source: 'string',
+ },
+ ],
+ result: 0,
+ state: 0,
+}