import { Mongo } from 'meteor/mongo';
import { Random } from 'meteor/random';
import { ioSchema } from 'apollo-mantra/server';
declare global {
export const Exercises = new Mongo.Collection<Cs.Collections.IExerciseDAO>('exercises');
export const Questions = new Mongo.Collection<Cs.Collections.IQuestionDAO>('questions');
export const Possibilities = new Mongo.Collection<Cs.Collections.IQuestionPossibilitiesDAO>('possibilities');
export const Solutions = new Mongo.Collection<Cs.Collections.ISolutionDAO>('solutions');
const schema = `
${ioSchema(`Exercise$Input {
_id: String
name: String
instructions: String
group: String
questions: [Question$Input]
}`)}
${ioSchema(`Question$Input {
_id: String
description: String
question: String
expectedAnswer: String
validation: String
control: String
possibilities: [Possibility$Input]
points: Float
}`)}
${ioSchema(`Possibility$Input {
question: String
answer: String
}`)}
type Solution {
_id: String
userId: String
user: String
semesterId: String
practicalId: String
exerciseId: String
questionId: String
userQuestion: String
expectedAnswer: String
userAnswer: String
mark: Float
created: Date
modified: Date
finished: Boolean
tutorComment: String
}
`;
const queryText = `
exercise(id: String, userId: String): Exercise
practicalSolutions(semesterId: String, practicalId: String, userId: String): [Solution]
markingSolutions(semesterId: String, practicalId: String, lastModification: Date, userId: String): [Solution]
`;
const queries = {
exercise(root: any, { id }: any, { user, userId }: Apollo.IApolloContext): Cs.Collections.IExerciseDAO {
if (!user) {
return null;
}
return Exercises.findOne({ _id: id });
},
markingSolutions(root: any, { semesterId, practicalId, lastModification }: any, { user }: Apollo.IApolloContext): Cs.Collections.ISolutionDAO[] {
if (!user || user.roles.indexOf('tutor') === -1) {
return [];
}
console.log(lastModification);
return Solutions.find({ semesterId, practicalId, modified: { $gt: lastModification } }).fetch();
},
practicalSolutions(root: any, { semesterId, practicalId }: any, { userId, user }: Apollo.IApolloContext): Cs.Collections.ISolutionDAO[] {
const options = { fields: { expectedAnswer: 0 } };
return Solutions.find({ userId, semesterId, practicalId }, options).fetch();
}
};
const mutationText = `
mark(solutionIds: [String]!, comments: [String]!, marks: [Float]!): Boolean
save(exercise: ExerciseInput): Boolean
`;
interface IActionAnswer {
solutionIds: string[];
userAnswers: string[];
finished: boolean;
}
interface IActionMark {
solutionIds: string[];
comments: string[];
marks: number[];
}
interface IActionSave {
exercise: Cs.Entities.IExercise;
}
const mutations = {
mark(root: any, { solutionIds, comments, marks }: IActionMark, { user, userId }: Apollo.IApolloContext) {
if (!user.roles.find((r) => r === 'tutor')) {
return;
}
let total = 0;
for (let i = 0; i < solutionIds.length; i++) {
let cm = marks[i] ? marks[i] : 0;
Solutions.update({ _id: solutionIds[i] }, {
$set: {
mark: cm,
tutorComment: comments[i]
}
});
}
},
save(root: any, { exercise }: IActionSave, { user }: Apollo.IApolloContext) {
if (!user.roles.find((r) => r === 'tutor')) {
return;
}
Exercises.update({ _id: exercise._id }, {
$set: {
name: exercise.name,
instructions: exercise.instructions,
group: exercise.group,
questions: exercise.questions.map((e) => e._id)
}
});
for (let question of exercise.questions) {
Questions.upsert({ _id: question._id }, { $set: question });
}
}
};
const resolvers = {
Exercise: {
questions(exercise: Cs.Collections.IExerciseDAO, params: any, { user }: Apollo.IApolloContext): Cs.Collections.IQuestionDAO[] {
let options = {};
if (!user.roles || user.roles.indexOf('tutor') === -1) {
options = { fields: { expectedAnswer: 0, validation: 0, possibilities: 0 } };
}
return Questions.find({ _id: { $in: exercise.questions } }, options).fetch();
}
},
Question: {
possibilities(question: Cs.Collections.IQuestionDAO): Cs.Collections.IQuestionPossibilityDAO[] {
if (question.possibilitiesGroupId) {
return Possibilities.findOne({ _id: question.possibilitiesGroupId }).possibilities;
} else {
return null;
}
}
}
};
const definition: IApolloDefinition = {
schema,
resolvers,
queries,
queryText,
mutationText,
mutations
};
export default definition;