Sketches for Hallmark content

gistfile1.txt

/*
** Get published content
*/

getPublishedAssessmentByAssessmentId(assessmentId: number, hallmark: boolean): PublishedAssessment {
  let query: string = “SELECT TOP 1 * FROM a IN PublishedCourse.assessments WHERE a.assessment_Id = @assessmentId ORDER BY a.dateCreated"
  
  return db[hallmark ? 'hallmark' : 'client'].query(query)
}

// Same pattern for courses and lessons

getPublishedAssessmentById(id: number, autoUpgrade: boolean): PublishedAssessment {
  let hallmark: boolean = false
  let query1: string = “SELECT * FROM a IN PublishedCourse.assessments WHERE a.id = @id"
  
  let pa: PublishedAssessment = db['client'].query(query1)
 
  if (!pa) {
    hallmark = true
    pa = db['hallmark'].query(query1)
  }
  
  if (!autoUpgrade) { 
    return pa
  } else {
    let query2: string = “SELECT TOP 1 * FROM a IN PublishedCourse.assessments 
      WHERE a.assessment_Id = @pa.assessment_Id AND a.version.major = @pa.version.major ORDER BY a.dateCreated"
      
    let upgradedPa: PublishedAssessment = db[hallmark ? 'hallmark' : 'client'].query(query2)
      
    upgradedPa = mergePublishedIds(upgradedPa, pa) // upgradedPa needs published ids from pa
    
    return upgradedPa
  }

// Same pattern for courses and lessons

getPublishedCourses(includeHallmark: boolean, paginationParams: PaginationParams): PublishedCourseSummary[] {
  // This is not the most efficient, but documentDB querying doesn't support DISTINCT, and this is call is not
  // performance critical
  let allPublishedCourses: PublishedCourseSummary[] = db['client'].query('SELECT { "course_Id": pc.course_Id, "name": pc.name, "status": pc.status, "hallmark": false } FROM PublishedCourse pc ORDER BY ')
  
  if (includeHallmark) {
    allPublishedCourses.concat(db['hallmark'].query('SELECT { "course_Id": pc.course_Id, "name": pc.name, "status": pc.status, "hallmark": true } FROM PublishedCourse pc')
  }
  
  allPublishedCourses = filterLatestVersionOfEachCourse(allPublishedCourses)
  
  return paginate(allPubublishedCourses, paginationParams)
}

/*
** Publish / import content
*/
importPublishedCourse(publishedCourseFromSQL: PublishedCourseFromSQL): void {
  let publishedCourse : PublishedCourse = reshapePublishedCourseFromSQL(publishedCourseFromSQL)
  
  publishedCourse = setVersionForPublishedCourse(publishedCourse, false)
  
  updateHighestPublishedIds(publishedCourse)
  
  db['client'].publishedCourse.createDocument(publishedCourse)
}

publishCourse(course: Course, hallmark: boolean): void {
  let publishedCourseForDb : PublishedCours = reshapeCourseForDb(course)
   
  publishedCourse = setIdsForPublishedCourse(publishedCourse)
  publishedCourse = setVersionForPublishedCourse(publishedCourse, hallmark)
 
  db[hallmark ? 'hallmark' : 'client'].publishedCourse.createDocument(publishedCourse)
}

// Private functions
private getNextPublishedCourseId(): number {
  // There needs to be a central store for the latest id which doesn't allow concurrent updates
  // DocumentDB stored procs with transactions probably a good fit for this
  // Approach will be identical for assessments and lessons
}

private getVersion(publishedCourse: PublishedCourse, hallmark: boolean): Version {
  let lastPublishedCourse: PublishedCourse = getPublishedCourseByCourseId(publishedCourse.id, hallmark)
 
  if (!publishedCourse) { return { major: 0, minor: 0 } }
  
  let structureChanged: boolean = hasStructureChanged(publishedCourse, lastPublishedCourse)
  
  if (structureChanged) {
    return { major: lastPublishedCourse.version.major++, minor: 0 }
  } else {
    return { major: lastPublishedCourse.version.major, minor: lastPublishedCourse.version.minor++ }
  }  
}

private setIdsForPublishedCourse(publishedCourse: PublishedCourse): PublishedCourse {
  publishedCourse.id = getNextPublishedCourseId()
  
  publishedCourse.assessments.forEach((publishedAssessment: PublishedAssessment) => {
    publishedAssessment.id = getNextPublishedAssessmentId()
  })
  
  publishedCourse.lessons.forEach((publishedLesson: PublishedLesson) => {
    publishedLesson.id = getNextPublishedLessonId()
  })
  
  return publishedCourse
}

private setVersionForPublishedCourse(publishedCourse: PublishedCourse): PublishedCourse {
  let version: Version = getVersion(publishedCourse)
  
  publishedCourse.version = version

  publishedCourse.assessments.forEach((publishedAssessment: PublishedAssessment) => {
    publishedAssessment.version = version
  })

  publishedCourse.lessons.forEach((publishedLesson: PublishedLesson) => {
    publishedLesson.version = version
  })
  
  return publishedCourse
}