Untie CourseInstance creation from prepaids, tie them to classrooms instead

app/schemas/models/course_instance.schema.coffee

@@ -1,14 +1,20 @@
 c = require './../schemas'
 
-CourseInstanceSchema = c.object {title: 'Course Instance'}
+CourseInstanceSchema = c.object {
+  title: 'Course Instance'
+  required: [
+    'courseID', 'classroomID', 'members', 'ownerID', 'aceConfig'
+  ]
+}
 
 _.extend CourseInstanceSchema.properties,
   courseID: c.objectId()
-  description: {type: 'string'}
+  classroomID: c.objectId()
+  description: {type: 'string'} # deprecated in favor of classrooms?
   members: c.array {title: 'Members'}, c.objectId()
-  name: {type: 'string'}
+  name: {type: 'string'} # deprecated in favor of classrooms?
   ownerID: c.objectId()
-  prepaidID: c.objectId()
+  prepaidID: c.objectId() # deprecated
   aceConfig:
     language: {type: 'string', 'enum': ['python', 'javascript']}
 

server/courses/CourseInstance.coffee

@@ -3,15 +3,24 @@ config = require '../../server_config'
 plugins = require '../plugins/plugins'
 jsonSchema = require '../../app/schemas/models/course_instance.schema'
 
-CourseInstanceSchema = new mongoose.Schema {}, {strict: false, minimize: false, read:config.mongo.readpref}
+CourseInstanceSchema = new mongoose.Schema {
+  ownerID: mongoose.Schema.Types.ObjectId
+  courseID: mongoose.Schema.Types.ObjectId
+  classroomID: mongoose.Schema.Types.ObjectId
+  prepaidID: mongoose.Schema.Types.ObjectId
+  members: [mongoose.Schema.Types.ObjectId]
+}, {strict: false, minimize: false, read:config.mongo.readpref}
 
 CourseInstanceSchema.statics.privateProperties = []
 CourseInstanceSchema.statics.editableProperties = [
   'description'
-  'members'
   'name'
   'aceConfig'
 ]
+CourseInstanceSchema.statics.postEditableProperties = [
+  'courseID'
+  'classroomID'
+]
 
 CourseInstanceSchema.statics.jsonSchema = jsonSchema
 

server/courses/course_instance_handler.coffee

@@ -1,6 +1,7 @@
 async = require 'async'
 Handler = require '../commons/Handler'
 Campaign = require '../campaigns/Campaign'
+Classroom = require '../classrooms/Classroom'
 Course = require './Course'
 CourseInstance = require './CourseInstance'
 LevelSession = require '../levels/sessions/LevelSession'
@@ -36,57 +37,25 @@ CourseInstanceHandler = class CourseInstanceHandler extends Handler
     return @inviteStudents(req, res, args[0]) if relationship is 'invite_students'
     return @redeemPrepaidCodeAPI(req, res) if args[1] is 'redeem_prepaid'
     super arguments...
-
-  createAPI: (req, res) ->
-    return @sendUnauthorizedError(res) if not req.user?
-    return @sendUnauthorizedError(res) if req.user.isAnonymous() and not (req.body.hourOfCode and req.body.courseID is '560f1a9f22961295f9427742')
-
-    # Required Input
-    seats = req.body.seats
-    unless seats > 0
-      @logError(req.user, 'Course create API missing required seats count')
-      return @sendBadInputError(res, 'Missing required seats count')
-    # Optional - unspecified means create instances for all courses
-    courseID = req.body.courseID
-    # Optional
-    name = req.body.name
-    aceConfig = req.body.aceConfig or {}
-    # Optional - as long as course(s) are all free
-    stripeToken = req.body.stripe?.token
-
-    query = if courseID? then {_id: courseID} else {}
-    Course.find query, (err, courses) =>
-      if err
-        @logError(user, "Find courses error: #{JSON.stringify(err)}")
-        return done(err)
-
-      PrepaidHandler.purchasePrepaidCourse req.user, courses, seats, new Date().getTime(), stripeToken, (err, prepaid) =>
-        if err
-          @logError(req.user, err)
-          return @sendBadInputError(res, err) if err is 'Missing required Stripe token'
-          return @sendDatabaseError(res, err)
-
-        courseInstances = []
-        makeCreateInstanceFn = (course, name, prepaid, aceConfig) =>
-          (done) =>
-            @createInstance req, course, name, prepaid, aceConfig, (err, newInstance)=>
-              courseInstances.push newInstance unless err
-              done(err)
-        tasks = (makeCreateInstanceFn(course, name, prepaid, aceConfig) for course in courses)
-        async.parallel tasks, (err, results) =>
-          return @sendDatabaseError(res, err) if err
-          @sendCreated(res, courseInstances)
-
-  createInstance: (req, course, name, prepaid, aceConfig, done) =>
-    courseInstance = new CourseInstance
-      courseID: course.get('_id')
-      members: [req.user.get('_id')]
-      name: name
+    
+  post: (req, res) ->
+    return @sendBadInputError(res, 'No classroomID') unless req.body.classroomID
+    return @sendBadInputError(res, 'No courseID') unless req.body.courseID
+    Classroom.findById req.body.classroomID, (err, classroom) =>
+      return @sendDatabaseError(res, err) if err
+      return @sendNotFoundError(res, 'Classroom not found') unless classroom
+      Course.findById req.body.courseID, (err, course) =>
+        return @sendDatabaseError(res, err) if err
+        return @sendNotFoundError(res, 'Course not found') unless course
+        super(req, res)
+  
+  makeNewInstance: (req) ->
+    doc = new CourseInstance({
+      members: []
       ownerID: req.user.get('_id')
-      prepaidID: prepaid.get('_id')
-      aceConfig: aceConfig
-    courseInstance.save (err, newInstance) =>
-      done(err, newInstance)
+    })
+    doc.set('aceConfig', {}) # constructor will ignore empty objects
+    return doc
 
   getLevelSessionsAPI: (req, res, courseInstanceID) ->
     CourseInstance.findById courseInstanceID, (err, courseInstance) =>

test/server/functional/course_instance.spec.coffee

@@ -2,353 +2,48 @@ async = require 'async'
 config = require '../../../server_config'
 require '../common'
 stripe = require('stripe')(config.stripe.secretKey)
+init = require '../init'
 
-# TODO: add permissiosn tests
+describe 'POST /db/course_instance', ->
 
-describe 'CourseInstance', ->
-  courseInstanceCreateURL = getURL('/db/course_instance/-/create')
-  courseInstanceRedeemURL = getURL('/db/course_instance/-/redeem_prepaid')
-  userURL = getURL('/db/user')
-
-  createCourseInstances = (user, courseID, seats, token, done) ->
-    name = createName 'course instance '
-    requestBody =
-      courseID: courseID
-      name: name
-      seats: seats
-      stripe:
-        token: token
-    request.post {uri: courseInstanceCreateURL, json: requestBody }, (err, res) ->
-      expect(err).toBeNull()
-      expect(res.statusCode).toBe(201)
-      CourseInstance.find {name: name}, (err, courseInstances) ->
-        expect(err).toBeNull()
-
-        makeCourseInstanceVerifyFn = (courseInstance) ->
-          (done) ->
-            expect(courseInstance.get('name')).toEqual(name)
-            expect(courseInstance.get('ownerID')).toEqual(user.get('_id'))
-            expect(courseInstance.get('members')).toContain(user.get('_id'))
-            query = {$and: [{creator: user.get('_id')}]}
-            query.$and.push {'properties.courseIDs': {$in: [courseID]}} if courseID
-            Prepaid.find query, (err, prepaids) ->
-              expect(err).toBeNull()
-              return done(err) if err
-              expect(prepaids?.length).toEqual(1)
-              return done() unless prepaids?.length > 0
-              expect(prepaids[0].get('type')).toEqual('course')
-              expect(prepaids[0].get('maxRedeemers')).toEqual(seats) if seats
-
-              # TODO: verify Payment
-
-              done(err)
-
-        tasks = []
-        for courseInstance in courseInstances
-          tasks.push makeCourseInstanceVerifyFn(courseInstance)
-        async.parallel tasks, (err) =>
-          return done(err) if err
-          done(err, courseInstances)
-
-  it 'Clear database', (done) ->
-    clearModels [User, Course, CourseInstance, Prepaid], (err) ->
-      throw err if err
+  beforeEach (done) -> clearModels([CourseInstance, Course, User, Classroom], done)
+  beforeEach (done) -> loginJoe (@joe) => done()
+  beforeEach init.course()
+  beforeEach init.classroom()
+  
+  it 'creates a CourseInstance', (done) ->
+    test = @
+    url = getURL('/db/course_instance')
+    data = {
+      name: 'Some Name'
+      courseID: test.course.id
+      classroomID: test.classroom.id
+    }
+    request.post {uri: url, json: data}, (err, res, body) ->
+      expect(res.statusCode).toBe(200)
+      expect(body.classroomID).toBeDefined()
+      done()
+      
+  it 'fails if the Course does not exist', (done) ->
+    test = @
+    url = getURL('/db/course_instance')
+    data = {
+      name: 'Some Name'
+      courseID: '123456789012345678901234'
+      classroomID: test.classroom.id
+    }
+    request.post {uri: url, json: data}, (err, res, body) ->
+      expect(res.statusCode).toBe(404)
       done()
 
-  describe 'Single courses', ->
-    it 'Create for free course 1 seat', (done) ->
-      stripe.tokens.create {
-        card: { number: '4242424242424242', exp_month: 12, exp_year: 2020, cvc: '123' }
-      }, (err, token) ->
-        loginNewUser (user1) ->
-          createCourse 0, (err, course) ->
-            expect(err).toBeNull()
-            return done(err) if err
-            createCourseInstances user1, course.get('_id'), 1, token.id, (err, courseInstances) ->
-              expect(err).toBeNull()
-              return done(err) if err
-              expect(courseInstances.length).toEqual(1)
-              done()
-
-    it 'Create for free course no seats', (done) ->
-      stripe.tokens.create {
-        card: { number: '4242424242424242', exp_month: 12, exp_year: 2020, cvc: '123' }
-      }, (err, token) ->
-        loginNewUser (user1) ->
-          createCourse 0, (err, course) ->
-            expect(err).toBeNull()
-            return done(err) if err
-            name = createName 'course instance '
-            requestBody =
-              courseID: course.get('_id')
-              name: createName('course instance ')
-            request.post {uri: courseInstanceCreateURL, json: requestBody }, (err, res) ->
-              expect(err).toBeNull()
-              expect(res.statusCode).toBe(422)
-              done()
-
-    it 'Create for free course no token', (done) ->
-      loginNewUser (user1) ->
-        createCourse 0, (err, course) ->
-          expect(err).toBeNull()
-          return done(err) if err
-          createCourseInstances user1, course.get('_id'), 2, null, (err, courseInstances) ->
-            expect(err).toBeNull()
-            return done(err) if err
-            expect(courseInstances.length).toEqual(1)
-            done()
-
-    it 'Create for paid course 1 seat', (done) ->
-      stripe.tokens.create {
-        card: { number: '4242424242424242', exp_month: 12, exp_year: 2020, cvc: '123' }
-      }, (err, token) ->
-        loginNewUser (user1) ->
-          createCourse 7000, (err, course) ->
-            expect(err).toBeNull()
-            return done(err) if err
-            createCourseInstances user1, course.get('_id'), 1, token.id, (err, courseInstances) ->
-              expect(err).toBeNull()
-              return done(err) if err
-              expect(courseInstances.length).toEqual(1)
-              Prepaid.findById courseInstances[0].get('prepaidID'), (err, prepaid) ->
-                expect(err).toBeNull()
-                return done(err) if err
-                expect(prepaid.get('maxRedeemers')).toEqual(1)
-                expect(prepaid.get('properties')?.courseIDs).toEqual([course.get('_id')])
-                done()
-
-    it 'Create for paid course 50 seats', (done) ->
-      stripe.tokens.create {
-        card: { number: '4242424242424242', exp_month: 12, exp_year: 2020, cvc: '123' }
-      }, (err, token) ->
-        loginNewUser (user1) ->
-          createCourse 7000, (err, course) ->
-            expect(err).toBeNull()
-            return done(err) if err
-            createCourseInstances user1, course.get('_id'), 50, token.id, (err, courseInstances) ->
-              expect(err).toBeNull()
-              return done(err) if err
-              expect(courseInstances.length).toEqual(1)
-              Prepaid.findById courseInstances[0].get('prepaidID'), (err, prepaid) ->
-                expect(err).toBeNull()
-                return done(err) if err
-                expect(prepaid.get('maxRedeemers')).toEqual(50)
-                expect(prepaid.get('properties')?.courseIDs).toEqual([course.get('_id')])
-                done()
-
-    it 'Create for paid course no token', (done) ->
-      loginNewUser (user1) ->
-        createCourse 7000, (err, course) ->
-          expect(err).toBeNull()
-          return done(err) if err
-          name = createName 'course instance '
-          requestBody =
-            courseID: course.get('_id')
-            name: createName('course instance ')
-            seats: 1
-          request.post {uri: courseInstanceCreateURL, json: requestBody }, (err, res) ->
-            expect(err).toBeNull()
-            expect(res.statusCode).toBe(422)
-            done()
-
-    it 'Create for paid course -1 seats', (done) ->
-      stripe.tokens.create {
-        card: { number: '4242424242424242', exp_month: 12, exp_year: 2020, cvc: '123' }
-      }, (err, token) ->
-        loginNewUser (user1) ->
-          createCourse 7000, (err, course) ->
-            expect(err).toBeNull()
-            return done(err) if err
-            name = createName 'course instance '
-            requestBody =
-              courseID: course.get('_id')
-              name: createName('course instance ')
-              seats: -1
-            request.post {uri: courseInstanceCreateURL, json: requestBody }, (err, res) ->
-              expect(err).toBeNull()
-              expect(res.statusCode).toBe(422)
-              done()
-
-  describe 'All Courses', ->
-    it 'Create for 50 seats', (done) ->
-      stripe.tokens.create {
-        card: { number: '4242424242424242', exp_month: 12, exp_year: 2020, cvc: '123' }
-      }, (err, token) ->
-        loginNewUser (user1) ->
-          createCourse 7000, (err, course1) ->
-            expect(err).toBeNull()
-            return done(err) if err
-            createCourse 7000, (err, course2) ->
-              expect(err).toBeNull()
-              return done(err) if err
-              createCourseInstances user1, null, 50, token.id, (err, courseInstances) ->
-                expect(err).toBeNull()
-                return done(err) if err
-                Course.find {}, (err, courses) ->
-                  expect(err).toBeNull()
-                  return done(err) if err
-                  expect(courseInstances.length).toEqual(courses.length)
-                  Prepaid.find creator: user1.get('_id'), (err, prepaids) ->
-                    expect(err).toBeNull()
-                    return done(err) if err
-                    expect(prepaids.length).toEqual(1)
-                    return done('no prepaids found') unless prepaids?.length > 0
-                    prepaid = prepaids[0]
-                    expect(prepaid.get('maxRedeemers')).toEqual(50)
-                    expect(prepaid.get('properties')?.courseIDs?.length).toEqual(courses.length)
-                    done()
-
-  describe 'Invite to course', ->
-    it 'takes a list of emails and sends invites', (done) ->
-      stripe.tokens.create {
-        card: { number: '4242424242424242', exp_month: 12, exp_year: 2020, cvc: '123' }
-      }, (err, token) ->
-        loginNewUser (user1) ->
-          createCourse 0, (err, course) ->
-            expect(err).toBeNull()
-            return done(err) if err
-            createCourseInstances user1, course.get('_id'), 1, token.id, (err, courseInstances) ->
-              expect(err).toBeNull()
-              return done(err) if err
-              expect(courseInstances.length).toEqual(1)
-              inviteStudentsURL = getURL("/db/course_instance/#{courseInstances[0]._id}/invite_students")
-              requestBody = {
-                emails: ['test@test.com']
-              }
-              request.post { uri: inviteStudentsURL, json: requestBody }, (err, res) ->
-                expect(err).toBeNull()
-                expect(res.statusCode).toBe(200)
-                done()
-
-  describe 'Redeem prepaid code', ->
-
-    it 'Redeem prepaid code for an instance of max 2', (done) ->
-      stripe.tokens.create {
-        card: { number: '4242424242424242', exp_month: 12, exp_year: 2020, cvc: '123' }
-      }, (err, token) ->
-        loginNewUser (user1) ->
-          createCourse 0, (err, course) ->
-            expect(err).toBeNull()
-            return done(err) if err
-            createCourseInstances user1, course.get('_id'), 2, token.id, (err, courseInstances) ->
-              expect(err).toBeNull()
-              return done(err) if err
-              expect(courseInstances.length).toEqual(1)
-              Prepaid.findById courseInstances[0].get('prepaidID'), (err, prepaid) ->
-                expect(err).toBeNull()
-                return done(err) if err
-                loginNewUser (user2) ->
-                  request.post {uri: courseInstanceRedeemURL, json: {prepaidCode: prepaid.get('code')} }, (err, res) ->
-                    expect(err).toBeNull()
-                    expect(res.statusCode).toBe(200)
-
-                    # Check prepaid
-                    Prepaid.findById prepaid.id, (err, prepaid) ->
-                      expect(err).toBeNull()
-                      return done(err) if err
-                      expect(prepaid.get('redeemers')?.length).toEqual(1)
-                      expect(prepaid.get('redeemers')[0].date).toBeLessThan(new Date())
-                      expect(prepaid.get('redeemers')[0].userID).toEqual(user2.get('_id'))
-
-                      # Check course instance
-                      CourseInstance.findById courseInstances[0].id, (err, courseInstance) ->
-                        expect(err).toBeNull()
-                        return done(err) if err
-                        members = courseInstance.get('members')
-                        expect(members?.length).toEqual(2)
-                        # TODO: must be a better way to check membership
-                        usersFound = 0
-                        for memberID in members
-                          usersFound++ if memberID.equals(user1.get('_id'))
-                          usersFound++ if memberID.equals(user2.get('_id'))
-                        expect(usersFound).toEqual(2)
-                        done()
-
-    it 'Redeem full prepaid code for on instance of max 1', (done) ->
-      stripe.tokens.create {
-        card: { number: '4242424242424242', exp_month: 12, exp_year: 2020, cvc: '123' }
-      }, (err, token) ->
-        loginNewUser (user1) ->
-          createCourse 0, (err, course) ->
-            expect(err).toBeNull()
-            return done(err) if err
-            createCourseInstances user1, course.get('_id'), 1, token.id, (err, courseInstances) ->
-              expect(err).toBeNull()
-              return done(err) if err
-              expect(courseInstances.length).toEqual(1)
-              Prepaid.findById courseInstances[0].get('prepaidID'), (err, prepaid) ->
-                expect(err).toBeNull()
-                return done(err) if err
-                loginNewUser (user2) ->
-                  request.post {uri: courseInstanceRedeemURL, json: {prepaidCode: prepaid.get('code')} }, (err, res) ->
-                    expect(err).toBeNull()
-                    expect(res.statusCode).toBe(200)
-                    loginNewUser (user3) ->
-                      request.post {uri: courseInstanceRedeemURL, json: {prepaidCode: prepaid.get('code')} }, (err, res) ->
-                        expect(err).toBeNull()
-                        expect(res.statusCode).toBe(403)
-                        done()
-
-    it 'Redeem 50 count course prepaid codes 51 times, in parallel', (done) ->
-      stripe.tokens.create {
-        card: { number: '4242424242424242', exp_month: 12, exp_year: 2020, cvc: '123' }
-      }, (err, token) ->
-        seatCount = 50
-        loginNewUser (user1) ->
-          createCourse 0, (err, course) ->
-            expect(err).toBeNull()
-            return done(err) if err
-            createCourseInstances user1, course.get('_id'), seatCount, token.id, (err, courseInstances) ->
-              expect(err).toBeNull()
-              return done(err) if err
-              expect(courseInstances.length).toEqual(1)
-              Prepaid.findById courseInstances[0].get('prepaidID'), (err, prepaid) ->
-                expect(err).toBeNull()
-                return done(err) if err
-
-                forbiddenResults = 0
-                makeRedeemCall = ->
-                  (callback) ->
-                    loginNewUser (user2) ->
-                      request.post {uri: courseInstanceRedeemURL, json: {prepaidCode: prepaid.get('code')} }, (err, res) ->
-                        expect(err).toBeNull()
-                        if res.statusCode is 403
-                          forbiddenResults++
-                        else
-                          expect(res.statusCode).toBe(200)
-                        callback err
-                tasks = (makeRedeemCall() for i in [1..seatCount+1])
-                async.parallel tasks, (err, results) ->
-                  expect(err?).toEqual(false)
-                  expect(forbiddenResults).toEqual(1)
-                  Prepaid.findById courseInstances[0].get('prepaidID'), (err, prepaid) ->
-                    expect(err).toBeNull()
-                    return done(err) if err
-                    expect(prepaid.get('redeemers')?.length).toEqual(prepaid.get('maxRedeemers'))
-                    done()
-
-    it 'Redeem prepaid code twice', (done) ->
-      stripe.tokens.create {
-        card: { number: '4242424242424242', exp_month: 12, exp_year: 2020, cvc: '123' }
-      }, (err, token) ->
-        loginNewUser (user1) ->
-          createCourse 0, (err, course) ->
-            expect(err).toBeNull()
-            return done(err) if err
-            createCourseInstances user1, course.get('_id'), 2, token.id, (err, courseInstances) ->
-              expect(err).toBeNull()
-              return done(err) if err
-              expect(courseInstances.length).toEqual(1)
-              Prepaid.findById courseInstances[0].get('prepaidID'), (err, prepaid) ->
-                expect(err).toBeNull()
-                return done(err) if err
-                loginNewUser (user2) ->
-                  # Redeem once
-                  request.post {uri: courseInstanceRedeemURL, json: {prepaidCode: prepaid.get('code')} }, (err, res) ->
-                    expect(err).toBeNull()
-                    expect(res.statusCode).toBe(200)
-                    # Redeem twice
-                    request.post {uri: courseInstanceRedeemURL, json: {prepaidCode: prepaid.get('code')} }, (err, res) ->
-                      expect(err).toBeNull()
-                      expect(res.statusCode).toBe(200)
-                      done()
+  it 'fails if the Classroom does not exist', (done) ->
+    test = @
+    url = getURL('/db/course_instance')
+    data = {
+      name: 'Some Name'
+      courseID: test.course.id
+      classroomID: '123456789012345678901234'
+    }
+    request.post {uri: url, json: data}, (err, res, body) ->
+      expect(res.statusCode).toBe(404)
+      done()

test/server/init.coffee

@@ -0,0 +1,34 @@
+
+module.exports.course = (properties) ->
+  properties ?= {}
+  _.defaults(properties, {
+    name: 'Unnamed course'
+    campaignID: ObjectId("55b29efd1cd6abe8ce07db0d")
+    concepts: ['basic_syntax', 'arguments', 'while_loops', 'strings', 'variables']
+    description: "Learn basic syntax, while loops, and the CodeCombat environment."
+    screenshot: "/images/pages/courses/101_info.png"
+  })
+  
+  return (done) ->
+    test = @
+    course = new Course(properties)
+    course.save (err, course) ->
+      expect(err).toBeNull()
+      test.course = course
+      done()
+
+      
+module.exports.classroom = (properties) ->
+  properties = {}
+  _.defaults(properties, {
+    name: 'Unnamed classroom'
+  })
+  
+  return (done) ->
+    test = @
+    classroom = new Classroom(properties)
+    classroom.save (err, classroom) ->
+      expect(err).toBeNull()
+      test.classroom = classroom
+      done()
+