* restructure + xapi

src/js/xapi/polaris/verb/failed.spec.js

+const failedBuilder = require('./failed');
+
+describe('failed verb statement builder', () => {
+    it('should generate the verb portion of the statement', () => {
+        const failed = failedBuilder();
+
+        expect(failed.getStatement()).toEqual({
+            version: "1.0.3",
+            object: {
+                objectType: 'Activity',
+		definition: {
+                    type: 'http://adlnet.gov/expapi/activities/cmi.interaction'
+		}
+            },
+            verb: {
+                "id": "http://adlnet.gov/expapi/verbs/failed",
+                "display": {
+                    "en-US": "failed"
+                }
+            }
+        })
+    });
+});
+
+describe('result', () => {
+    it('should allow to define duration result', () => {
+	const score = {
+	    scaled: 0,
+	    raw: 0,
+	    min: 0,
+	    max: 278
+	}
+	const duration = "PT0H0M48S"
+	const progress = 100
+	const failed = failedBuilder()
+              .result(score, duration, progress);
+
+	expect(failed.getStatement()).toEqual({
+            version: "1.0.3",
+            object: {
+		objectType: 'Activity',
+		definition: {
+		    type: 'http://adlnet.gov/expapi/activities/cmi.interaction'
+		}
+            },
+            verb: {
+		"id": "http://adlnet.gov/expapi/verbs/failed",
+		"display": {
+                    "en-US": "failed"
+		}
+            },
+            result: {
+		score,
+		success: false,
+                completion: true,
+                duration,
+                extensions: {
+                    "https://w3id.org/xapi/cmi5/result/extensions/progress": progress
+		}
+	    }
+	})
+    })
+});

src/js/xapi/polaris/verb/initialized.js

+const statement = require('../../statement');
+const {cmi5} = require('../../profiles');
+
+const initialized = () => {
+    let state = {
+        ...cmi5.initialized,
+    };
+
+    return {
+        ...statement(state),
+    };
+};
+
+module.exports = initialized;

src/js/xapi/polaris/verb/initialized.spec.js

+const initializedBuilder = require('./initialized');
+
+describe('initialized verb statement builder', () => {
+    it('should generate the verb portion of the statement', () => {
+        const initialized = initializedBuilder();
+
+        expect(initialized.getStatement()).toEqual({
+            version: "1.0.3",
+            object: {
+                objectType: 'Activity',
+		definition: {
+                    type: 'http://adlnet.gov/expapi/activities/cmi.interaction'
+		},
+            },
+            verb: {
+                "id": "http://adlnet.gov/expapi/verbs/initialized",
+                "display": {
+                    "en-US": "initialized"
+                }
+            }
+        })
+    });
+});

src/js/xapi/polaris/verb/passed.js

+const statement = require('../../statement');
+const {cmi5} = require('../../profiles');
+
+const passed = () => {
+    let state = {};
+    const baseStatement = statement(cmi5.passed);
+
+    return {
+        ...baseStatement,
+        result(score, duration, progress) {
+            state = {
+                result: {
+		    "score": score,
+		    "success": true,
+                    "completion": true,
+                    "duration": duration,
+                    "extensions": {
+                        "https://w3id.org/xapi/cmi5/result/extensions/progress": progress
+                    }
+                }
+            };
+            return this;
+        },
+        getStatement() {
+            return {
+                ...baseStatement.getStatement(),
+                ...state,
+            }
+        }
+    };
+};
+
+module.exports = passed;

src/js/xapi/polaris/verb/passed.spec.js

+const passedBuilder = require('./passed');
+
+describe('passed verb statement builder', () => {
+    it('should generate the verb portion of the statement', () => {
+        const passed = passedBuilder();
+
+        expect(passed.getStatement()).toEqual({
+            version: "1.0.3",
+            object: {
+                objectType: 'Activity',
+		definition: {
+                    type: 'http://adlnet.gov/expapi/activities/cmi.interaction'
+		}
+            },
+            verb: {
+                "id": "http://adlnet.gov/expapi/verbs/passed",
+                "display": {
+                    "en-US": "passed"
+                }
+            }
+        })
+    });
+});
+
+describe('result', () => {
+    it('should allow to define duration result', () => {
+	const score = {
+	    scaled: 0,
+	    raw: 0,
+	    min: 0,
+	    max: 278
+	}
+	const duration = "PT0H0M48S"
+	const progress = 100
+	const passed = passedBuilder()
+              .result(score, duration, progress);
+
+	expect(passed.getStatement()).toEqual({
+            version: "1.0.3",
+            object: {
+		objectType: 'Activity',
+		definition: {
+		    type: 'http://adlnet.gov/expapi/activities/cmi.interaction'
+		}
+            },
+            verb: {
+		"id": "http://adlnet.gov/expapi/verbs/passed",
+		"display": {
+                    "en-US": "passed"
+		}
+            },
+            result: {
+		score,
+		success: true,
+                completion: true,
+                duration,
+                extensions: {
+                    "https://w3id.org/xapi/cmi5/result/extensions/progress": progress
+		}
+	    }
+	})
+    })
+});

src/js/xapi/polaris/verb/registered.js

+const statement = require('../../statement');
+const {cmi5} = require('../../profiles');
+
+const registered = () => {
+    let state = {
+        ...cmi5.registered,
+    };
+
+    return {
+        ...statement(state),
+    };
+};
+
+module.exports = registered;
\ No newline at end of file

src/js/xapi/polaris/verb/registered.spec.js

+const registeredBuilder = require('./registered');
+
+describe('registered verb statement builder', () => {
+    it('should generate the verb portion of the statement', () => {
+        const registered = registeredBuilder();
+
+	// console.log(JSON.stringify(registered.getStatement()));
+
+        expect(registered.getStatement()).toEqual({
+            version: "1.0.3",
+            object: {
+                objectType: 'Activity',
+		definition: {
+                    type: 'http://adlnet.gov/expapi/activities/cmi.interaction'
+		}
+            },
+            verb: {
+                "id": "http://adlnet.gov/expapi/verbs/registered",
+                "display": {
+                    "en-US": "registered"
+                }
+            }
+        })
+    });
+});

src/js/xapi/polaris/verb/resized.js

+const statement = require('../../statement');
+const { polaris} = require('../../profiles');
+
+const resized = () => {
+    let state = {};
+    const baseStatement = statement(polaris.resized);
+
+    return {
+        ...baseStatement,
+        getStatement() {
+            return {
+                ...baseStatement.getStatement(),
+                ...state,
+            }
+        }
+    };
+};
+
+module.exports = resized;
\ No newline at end of file

src/js/xapi/polaris/verb/terminated.js

+const statement = require('../../statement');
+const {cmi5} = require('../../profiles');
+
+const terminated = () => {
+    let state = {
+        ...cmi5.terminated,
+    };
+
+    return {
+        ...statement(state),
+    };
+};
+
+module.exports = terminated;

src/js/xapi/polaris/verb/terminated.spec.js

+const terminatedBuilder = require('./terminated');
+
+describe('terminated verb statement builder', () => {
+    it('should generate the verb portion of the statement', () => {
+        const terminated = terminatedBuilder();
+
+        expect(terminated.getStatement()).toEqual({
+            version: "1.0.3",
+            object: {
+                objectType: 'Activity',
+		definition: {
+                    type: 'http://adlnet.gov/expapi/activities/cmi.interaction'
+		}
+            },
+            verb: {
+                "id": "http://adlnet.gov/expapi/verbs/terminated",
+                "display": {
+                    "en-US": "terminated"
+                }
+            }
+        })
+    });
+});

src/js/xapi/profiles.js

+const verbs = require('./verbs');
+
+module.exports = {
+
+    polaris : {
+        resized: {
+            object: {
+                objectType: 'Activity',
+		definition: {
+                    type: 'http://polaris.io/xapi/activities/polaris.dashboard.widget'
+		}
+            },
+            verb: verbs.resize
+        },
+    },
+    cmi5: {
+        answered: {
+            object: {
+                objectType: 'Activity',
+		definition: {
+                    type: 'http://adlnet.gov/expapi/activities/cmi.interaction'
+		}
+            },
+            verb: verbs.answered
+        },
+        completed: {
+            object: {
+                objectType: 'Activity',
+		definition: {
+                    type: 'http://adlnet.gov/expapi/activities/cmi.interaction'
+		}
+            },
+            verb: verbs.completed
+        },
+        failed: {
+            object: {
+                objectType: 'Activity',
+		definition: {
+                    type: 'http://adlnet.gov/expapi/activities/cmi.interaction'
+		}
+            },
+            verb: verbs.failed
+        },
+        initialized: {
+            object: {
+                objectType: 'Activity',
+		definition: {
+                    type: 'http://adlnet.gov/expapi/activities/cmi.interaction'
+		}
+            },
+            verb: verbs.initialized
+        },
+        passed: {
+            object: {
+                objectType: 'Activity',
+		definition: {
+                    type: 'http://adlnet.gov/expapi/activities/cmi.interaction'
+		}
+            },
+            verb: verbs.passed
+        },
+        registered: {
+            object: {
+                objectType: 'Activity',
+		definition: {
+                    type: 'http://adlnet.gov/expapi/activities/cmi.interaction'
+		}
+            },
+            verb: verbs.registered
+        },
+        terminated: {
+            object: {
+                objectType: 'Activity',
+		definition: {
+                    type: 'http://adlnet.gov/expapi/activities/cmi.interaction'
+		}
+            },
+            verb: verbs.terminated
+        },
+    },
+    link: {
+        registered: {
+            object: {
+                objectType: 'Activity',
+		definition: {
+                    type: 'http://adlnet.gov/expapi/activities/link'
+		}
+            },
+            verb: verbs.registered,
+        },
+    },
+};

src/js/xapi/statement.js

+function addLocalizedField(state, field, locale, value) {
+    return {...state, [field]: {[locale]: value}}
+}
+
+const statement = (state) => {
+
+    return {
+        actor(actor) {
+            state = {
+                ...state,
+                actor: actor.getStatement(),
+            };
+
+            return this;
+        },
+        when(when){
+            state = {...state, timestamp: when};
+            return this;
+        },
+        activityId(id) {
+            state = {
+                ...state,
+                object: {
+                    ...state.object,
+                    id,
+                },
+            };
+
+            return this;
+        },
+        activityName({value, locale = 'en-US'}) {
+            state = {
+                ...state,
+                object: {
+                    ...state.object,
+                    definition: {
+                        ...addLocalizedField(state.object ? state.object.definition : {}, 'name', locale, value)
+                    },
+                },
+            };
+            return this;
+        },
+        activityDescription({value, locale = 'en-US'}) {
+            state = {
+                ...state,
+                object: {
+                    ...state.object,
+                    definition: {
+                        ...addLocalizedField(state.object ? state.object.definition : {}, 'description', locale, value)
+                    },
+                },
+            };
+            return this;
+        },
+	interactionType(type) {
+	    state = {
+		...state,
+                object: {
+                    ...state.object,
+		    definition: {
+			...state.object.definition,
+			interactionType: type
+		    }
+                }
+	    };
+	    return this;
+	},
+	correctResponsesPattern(responsesArray) {
+	    state = {
+		...state,
+                object: {
+                    ...state.object,
+		    definition: {
+			...state.object.definition,
+			correctResponsesPattern: [responsesArray]
+		    }
+                }
+	    };
+	    return this;
+	},
+	choices(choicesArray) {
+	    state = {
+		...state,
+                object: {
+                    ...state.object,
+		    definition: {
+			...state.object.definition,
+			choices: choicesArray
+		    }
+                }
+	    };
+	    return this;
+	},
+        authority({name, IFI}) {
+            state = {
+                ...state,
+                authority: {
+                    objectType: 'Agent',
+                    [IFI.key]: IFI.getStatement(),
+                    name
+                }
+            };
+
+            return this;
+        },
+        getStatement() {
+            return {
+                version: '1.0.0',
+                ...state
+            };
+        }
+    };
+};
+
+module.exports = statement;

src/js/xapi/statement.spec.js

+const StatementFactory = require('./statement');
+
+describe('statement builder', () => {
+    it('should allow to define an actor', () => {
+        const mockActor = {
+            getStatement() {
+                return {foo: 'bar'}
+            }
+        };
+
+        const statement = StatementFactory({})
+            .actor(mockActor);
+
+        expect(statement.getStatement()).toEqual({
+            version: '1.0.3',
+            actor: {foo: 'bar'}
+        });
+    });
+    it('should allow to define a timestamp', () => {
+        const statement = StatementFactory({})
+            .when(new Date('2020-01-01'));
+
+        expect(statement.getStatement()).toEqual({
+            version: '1.0.3',
+            timestamp: new Date('2020-01-01T00:00:00.000Z')
+        })
+    });
+    it('should allow to define the authority', () => {
+        const name = 'Learning Record Provider';
+        const IFI = {
+            key: 'account',
+            getStatement() {
+                return {
+                    name: 'username',
+                    homePage: 'http://www.example.com/learning-record-provider'
+                };
+            }
+        };
+
+        const statement = StatementFactory({})
+            .authority({name, IFI});
+
+        expect(statement.getStatement()).toEqual({
+            version: '1.0.3',
+            authority: {
+                objectType: 'Agent',
+                account: {
+                    name: 'username',
+                    homePage: 'http://www.example.com/learning-record-provider'
+                },
+                name: "Learning Record Provider"
+            }
+        })
+
+    });
+    describe('activity details', () => {
+        it('should allow to define id', () => {
+            const statement = StatementFactory({})
+                .activityId('http://www.example.com/activity-id');
+
+            expect(statement.getStatement()).toEqual({
+                version: '1.0.3',
+                object: {
+                    id: 'http://www.example.com/activity-id',
+                }
+            })
+        });
+        describe('defaulting to en-US', () => {
+            it('should allow to define description', () => {
+                const statement = StatementFactory({})
+                    .activityDescription({value: 'foo description'});
+
+                expect(statement.getStatement()).toEqual({
+                    version: '1.0.3',
+                    object: {
+                        definition: {
+                            description: {
+                                'en-US': 'foo description',
+                            }
+                        },
+                    }
+                })
+            });
+            it('should allow to define name', () => {
+                const statement = StatementFactory({})
+                    .activityName({value: 'foo name'});
+
+                expect(statement.getStatement()).toEqual({
+                    version: '1.0.3',
+                    object: {
+                        definition: {
+                            name: {
+                                'en-US': 'foo name',
+                            }
+                        },
+                    }
+                })
+            });
+        });
+    });
+});

src/js/xapi/verbs.js

+module.exports = {
+    "answered": {
+        "id": "http://adlnet.gov/expapi/verbs/answered",
+        "display": {
+            "en-US": "answered",
+        }
+    },
+    "attempted": {
+        "id": "http://adlnet.gov/expapi/verbs/attempted",
+        "display": {
+            "en-US": "attempted",
+        }
+    },
+    "attended": {
+        "id": "http://adlnet.gov/expapi/verbs/attended",
+        "display": {
+            "en-US": "attended",
+        }
+    },
+    "commented": {
+        "id": "http://adlnet.gov/expapi/verbs/commented",
+        "display": {
+            "en-US": "commented",
+        }
+    },
+    "completed": {
+        "id": "http://adlnet.gov/expapi/verbs/completed",
+        "display": {
+            "en-US": "completed",
+        }
+    },
+    "failed": {
+        "id": "http://adlnet.gov/expapi/verbs/failed",
+        "display": {
+            "en-US": "failed",
+        }
+    },
+    "initialized": {
+        "id": "http://adlnet.gov/expapi/verbs/initialized",
+        "display": {
+            "en-US": "initialized",
+        }
+    },
+    "interacted": {
+        "id": "http://adlnet.gov/expapi/verbs/interacted",
+        "display": {
+            "en-US": "interacted",
+        }
+    },
+    "launched": {
+        "id": "http://adlnet.gov/expapi/verbs/launched",
+        "display": {
+            "en-US": "launched",
+        }
+    },
+    "mastered": {
+        "id": "http://adlnet.gov/expapi/verbs/mastered",
+        "display": {
+            "en-US": "mastered",
+        }
+    },
+    "passed": {
+        "id": "http://adlnet.gov/expapi/verbs/passed",
+        "display": {
+            "en-US": "passed",
+        }
+    },
+    "progressed": {
+        "id": "http://adlnet.gov/expapi/verbs/progressed",
+        "display": {
+            "en-US": "progressed",
+        }
+    },
+    "registered": {
+        "id": "http://adlnet.gov/expapi/verbs/registered",
+        "display": {
+            "en-US": "registered",
+        }
+    },
+    "resumed": {
+        "id": "http://adlnet.gov/expapi/verbs/resumed",
+        "display": {
+            "en-US": "resumed",
+        }
+    },
+    "scored": {
+        "id": "http://adlnet.gov/expapi/verbs/scored",
+        "display": {
+            "en-US": "scored",
+        }
+    },
+    "shared": {
+        "id": "http://adlnet.gov/expapi/verbs/shared",
+        "display": {
+            "en-US": "shared",
+        }
+    },
+    "suspended": {
+        "id": "http://adlnet.gov/expapi/verbs/suspended",
+        "display": {
+            "en-US": "suspended",
+        }
+    },
+    "terminated": {
+        "id": "http://adlnet.gov/expapi/verbs/terminated",
+        "display": {
+            "en-US": "terminated",
+        }
+    },
+    "voided": {
+        "id": "http://adlnet.gov/expapi/verbs/voided",
+        "display": {
+            "en-US": "voided",
+        }
+    },
+    "resize": {
+        "id": "http://polaris.io/xapi/verbs/polaris.dashboard.resize",
+        "display": {
+            "en-US": "resize",
+        }
+    },
+    "drag": {
+        "id": "http://polaris.io/xapi/verbs/polaris.dashboard.drag",
+        "display": {
+            "en-US": "drag",
+        }
+    },
+    "add": {
+        "id": "http://polaris.io/xapi/verbs/polaris.dashboard.add",
+        "display": {
+            "en-US": "add",
+        }
+    },
+    "evaluate": {
+        "id": "http://polaris.io/xapi/verbs/polaris.dashboard.evaluate",
+        "display": {
+            "en-US": "evaluate",
+        }
+    },
+};
\ No newline at end of file