gaku_core 0.1.1 → 0.2.0

data/app/models/gaku/class_group_course_enrollment.rb

@@ -1,17 +0,0 @@
-module Gaku
-  class ClassGroupCourseEnrollment < ActiveRecord::Base
-
-    belongs_to :class_group
-    belongs_to :course
-
-    validates :class_group_id, presence: true
-
-    validates :course_id,
-              presence: true,
-              uniqueness: {
-                            scope: :class_group_id,
-                            message: I18n.t(:'class_group.already_enrolled')
-                          }
-
-  end
-end

data/app/models/gaku/class_group_enrollment.rb

@@ -1,31 +0,0 @@
-module Gaku
-  class ClassGroupEnrollment < ActiveRecord::Base
-
-    belongs_to :class_group
-    belongs_to :student
-    has_many :school_roles, as: :school_rolable
-
-    validates :class_group, presence: true
-
-    validates :student,
-              presence: true,
-              uniqueness: {
-                            scope: :class_group_id,
-                            message: I18n.t(:'class_group.already_enrolled')
-                          }
-
-    after_save :save_student_class_and_number
-
-    def class_and_number
-      "#{class_group} - ##{seat_number}"
-    end
-
-    private
-
-    def save_student_class_and_number
-      student.update_attribute(:class_and_number, class_and_number) if student
-    end
-
-
-  end
-end

data/app/models/gaku/course_enrollment.rb

@@ -1,23 +0,0 @@
-module Gaku
-  class CourseEnrollment < ActiveRecord::Base
-
-    belongs_to :student, counter_cache: :courses_count
-    belongs_to :course,  counter_cache: :students_count
-
-    validates :course_id, presence: true
-
-    validates :student_id,
-              presence: true,
-              uniqueness: {
-                            scope: :course_id,
-                            message: I18n.t(:'course.already_enrolled')
-                          }
-    def code_with_syllabus_name
-      course.decorate.code_with_syllabus_name if course
-    end
-
-    def course_id
-      course.id if course
-    end
-  end
-end

data/app/models/gaku/disposal.rb

@@ -1,45 +0,0 @@
-module Gaku
-  class Disposal
-
-    def self.students
-      Student.deleted
-    end
-
-    def self.teachers
-      Teacher.deleted
-    end
-
-    def self.guardians
-      Guardian.deleted
-    end
-
-    def self.exams
-      Exam.deleted
-    end
-
-    def self.course_groups
-      CourseGroup.deleted
-    end
-
-    def self.attachments
-      Attachment.includes(:attachable).deleted
-    end
-
-    def self.student_addresses
-      Address.includes(:addressable, :country).deleted.students
-    end
-
-    def self.teacher_addresses
-      Address.includes(:addressable, :country).deleted.teachers
-    end
-
-    def self.student_contacts
-      Contact.includes(:contactable, :contact_type).deleted.students
-    end
-
-    def self.teacher_contacts
-      Contact.includes(:contactable, :contact_type).deleted.teachers
-    end
-
-  end
-end

data/app/models/gaku/extracurricular_activity_enrollment.rb

@@ -1,15 +0,0 @@
-module Gaku
-  class ExtracurricularActivityEnrollment < ActiveRecord::Base
-    belongs_to :extracurricular_activity
-    belongs_to :student
-    has_many :school_roles, as: :school_rolable
-
-    validates :student_id,
-              presence: true,
-              uniqueness: {
-                            scope: :extracurricular_activity_id,
-                            message: I18n.t(:'extracurricular_activity.already_enrolled')
-                          }
-    validates :extracurricular_activity_id, presence: true
-  end
-end

data/app/models/gaku/semester_class_group.rb

@@ -1,21 +0,0 @@
-module Gaku
-  class SemesterClassGroup < ActiveRecord::Base
-
-    belongs_to :semester
-    belongs_to :class_group
-
-    validates :class_group_id, presence: true
-
-    validates :semester_id,
-              presence: true,
-              uniqueness: {
-                            scope: :class_group_id,
-                            message: I18n.t(:'semester_class_group.uniqueness')
-                          }
-
-    def self.group_by_semester
-      all.includes([:semester, :class_group]).group_by(&:semester_id)
-    end
-
-  end
-end

data/app/models/gaku/semester_course.rb

@@ -1,21 +0,0 @@
-module Gaku
-  class SemesterCourse < ActiveRecord::Base
-
-    belongs_to :semester
-    belongs_to :course
-
-    validates :course_id, presence: true
-
-    validates :semester_id,
-              presence: true,
-              uniqueness: {
-                            scope: :course_id,
-                            message: I18n.t(:'semester_course.uniqueness')
-                          }
-
-    def self.group_by_semester
-      all.includes([:semester, :course]).group_by(&:semester_id)
-    end
-
-  end
-end

data/lib/gaku/grading/calculations.rb

@@ -1,279 +0,0 @@
-module Gaku::Grading::Calculations
-
-  def self.included(base)
-    base.send(:include, InstanceMethods)
-  end
-
-  module InstanceMethods
-    def calculate_totals
-      @student_total_scores = Hash.new { |hash,key| hash[key] = {} }
-      @student_total_weights = Hash.new { |hash,key| hash[key] = {} }
-      @completion = Hash.new { |hash,key| hash[key] = {} }
-      @exam_averages = Hash.new []
-      @exam_weight_averages = Hash.new []
-      @weighting_score = true
-      @student_portion_attendance = Hash.new { |hash,key| hash[key] = {} }
-      @students.each do |student|
-        @exams.each do |exam|
-          caluculate_completion(exam)
-          @student_total_scores[student.id][exam.id] = 0.0
-          @student_total_weights[student.id][exam.id] = 0.0
-          exam.exam_portions.each do |portion|
-            if have_portion_score?(student, portion)
-              add_to_student_total_score(student, exam, portion)
-              add_to_student_total_weight(student,exam, portion) if exam.use_weighting
-              add_to_portion_attendance(student, exam, portion)
-            else
-              score = create_new_portion_score(student,portion)
-              add_to_portion_attendance(student, exam, portion, score)
-            end
-          end
-        end
-      end
-    end
-
-    def add_to_portion_attendance(student, exam, portion, score = nil)
-      score ||= portion.student_score(student)
-      @student_portion_attendance[student.id][score.id] = [score.attendances.last.try(:id), score.attendances.last.try(:attendance_type).try(:color_code)]
-    end
-
-    def calculate_exam_averages
-      @students.each do |student|
-        @exams.each do |exam|
-          add_to_exam_averages(exam, student)
-          add_to_weight_averages(exam, student) if exam.use_weighting
-        end
-      end
-    end
-
-    def calculate_deviation
-      @deviation = Hash.new { |hash,key| hash[key] = {} }
-      @standard_deviation = 0.0
-      @deviation_member = 0.0
-      @exams.each do |exam|
-        @students.each do |student|
-          if exam.use_weighting
-            add_to_weighted_standard_deviation(exam, student)
-          else
-            add_to_standard_deviation(exam, student)
-          end
-        end
-        standard_deviation(@standard_deviation)
-
-        @students.each do |student|
-          @deviation[student.id][exam.id] = 0.0
-          add_to_deviation_member(exam, student)
-          add_to_deviation(exam, student)
-        end
-      end
-    end
-
-    def calculate_rank_and_grade
-      @grades = Hash.new { |hash,key| hash[key] = {} }
-      @scores = []
-
-      populate_student_scores
-
-
-      # WIP Grade Calculation -----↓
-
-      # @grading_method = GradingMethod.find(exam.grading_method_id)
-      # puts "@grading_method-------------"
-      # puts @grading_method.name
-      # eval @grading_method.method
-      grading_method = 1
-
-      grade_calculate(grading_method)
-
-      # Rank Calculation -----↓
-      rank_calculate
-    end
-
-    private
-
-      def caluculate_completion(exam)
-        total ||= exam.total_records(@students)
-        ungraded ||= exam.ungraded(@students)
-
-        @completion[exam.id][:completion_percentage] = exam.completion(@students)
-        @completion[exam.id][:total] = total
-        @completion[exam.id][:graded] = total - ungraded
-        @completion[exam.id][:ungraded] = ungraded
-      end
-
-
-      def fix_digit(num, digit_num)
-        fix_num = 10 ** digit_num
-        fixed_num = num * fix_num
-        fixed_num.nan? ? 0 : fixed_num.truncate.to_f / fix_num.to_f
-      end
-
-      def create_new_portion_score(student, portion)
-        Gaku::ExamPortionScore.create(student: student, exam_portion: portion)
-      end
-
-      def add_to_student_total_score(student,exam, portion)
-        @student_total_scores[student.id][exam.id] += student.exam_portion_scores.where(exam_portion_id: portion.id).first.score.to_f
-      end
-
-      def have_portion_score?(student, portion)
-        student.exam_portion_scores.where(exam_portion_id: portion.id).first.present?
-      end
-
-      def add_to_student_total_weight(student,exam, portion)
-        @student_total_weights[student.id][exam.id] +=  (portion.weight.to_f / 100) * student.exam_portion_scores.where(exam_portion_id: portion.id).first.score.to_f
-      end
-
-      def calculate_array_total(array_data)
-        total = 0
-        array_data.each do |num|
-          total += num
-        end
-        total
-      end
-
-      def add_to_exam_averages(exam, student)
-        @exam_averages[exam.id].push @student_total_scores[student.id][exam.id]
-        if @exam_averages[exam.id].length == @students.length
-          total = calculate_array_total @exam_averages[exam.id]
-          @exam_averages[exam.id] = fix_digit(total / @students.length, 1)
-        end
-      end
-
-      def add_to_weight_averages(exam, student)
-        @exam_weight_averages[exam.id] += [@student_total_weights[student.id][exam.id]]
-        if @exam_weight_averages[exam.id].length == @students.length
-          total = calculate_array_total @exam_weight_averages[exam.id]
-          @exam_weight_averages[exam.id] = fix_digit(total / @students.length, 1)
-        end
-      end
-
-      def add_to_weighted_standard_deviation(exam, student)
-        @standard_deviation += (@student_total_weights[student.id][exam.id] - @exam_weight_averages[exam.id]) ** 2
-      end
-
-      def add_to_standard_deviation(exam, student)
-        @standard_deviation += fix_digit((@student_total_scores[student.id][exam.id] - @exam_averages[exam.id]) ** 2, 2)
-      end
-
-      def standard_deviation(standard_deviation)
-        @standard_deviation = fix_digit(Math.sqrt(standard_deviation / @students.length), 4)
-      end
-
-      def add_to_deviation_member(exam, student)
-        if exam.use_weighting
-          @deviation_member = (@student_total_weights[student.id][exam.id] - @exam_weight_averages[exam.id]) / @standard_deviation
-        else
-          @deviation_member = (@student_total_scores[student.id][exam.id] - @exam_averages[exam.id]) / @standard_deviation
-        end
-      end
-
-      def add_to_deviation(exam, student)
-        @deviation[student.id][exam.id] = @deviation_member.nan? ? 50 : fix_digit(@deviation_member * 10 + 50, 4)
-      end
-
-      def populate_student_scores
-        @exams.each do |exam|
-          if exam.use_weighting
-            @students.each do |student|
-              @scores.push [@student_total_weights[student.id][exam.id], student.id]
-            end
-          else
-            @students.each do |student|
-              @scores.push [@student_total_scores[student.id][exam.id], student.id]
-            end
-          end
-        @scores.sort!.reverse!
-      end
-
-      def grade_calculate(grading_method)
-        @gradePoint = 10
-        @grade_levels_deviation = [10000000000, 66, 62, 58, 55, 59, 45, 37, 0]
-        @grade_levels_percent = [5, 5, 10, 10, 30, 10, 100]
-
-        @exams.each do |exam|
-          case grading_method
-          when 1
-            grading_method_one(exam)
-          when 2
-            grading_method_two(exam)
-          end
-        end
-      end
-
-      def grading_method_one(exam)
-        @grade_levels_deviation.each_with_index do |glevel, i|
-          @students.each do |student|
-            if @grade_levels_deviation[i] > @deviation[student.id][exam.id] && @grade_levels_deviation[i+1] <= @deviation[student.id][exam.id]
-              @grades[exam.id][student.id] = @gradePoint
-            end
-          end
-          @gradePoint -= 1
-        end
-      end
-
-      def grading_method_two(exam)
-        scoresMem = @scores.clone
-        gradeNums = []
-        @grade_levels_percent.each do |glevel|
-          gradeNums.push((@students.length * (glevel.to_f / 100)).ceil)
-        end
-        gradeNums.each do |gnum|
-          i = 0
-          while i < gnum && scoresMem.length != 0
-            @grades[exam.id][scoresMem.shift[1]] = gradePoint
-            i += 1
-          end
-          @gradePoint -= 1
-        end
-      end
-
-      def rank_calculate
-        @rank_point = 5
-        @ranks = Hash.new { |hash,key| hash[key] = {} }
-        rank_levels = [15, 20]
-        @exams.each do |exam|
-          initial_student_rank(exam)
-          rank_nums = rank_nums(rank_levels)
-          rank_score(exam,rank_nums)
-          rank(exam)
-        end
-      end
-
-      def rank_nums(rank_levels)
-        rank_nums = []
-        rank_levels.each {|rlevel| rank_nums.push((@students.length * (rlevel.to_f / 100)).ceil)}
-        rank_nums
-      end
-
-      def initial_student_rank(exam)
-          @students.each {|student| @ranks[exam.id][student.id] = 3 }
-      end
-
-      def rank_score(exam,rank_nums)
-        rank_nums.each do |rnum|
-          i = 0
-          while i < rnum && @scores.length != 0
-            scoreMem = @scores.shift
-            @ranks[exam.id][scoreMem[1]] = @rank_point
-            rnum += 1 if @scores.length != 0 && scoreMem[0] == @scores[0][0]
-            i += 1
-          end
-         @rank_point -= 1
-        end
-      end
-
-      def rank(exam)
-        @scores.each do |score|
-          if @grades[exam.id][score[1]] == 3
-            @ranks[exam.id][score[1]] = 2
-          elsif @grades[exam.id][score[1]] < 3
-            @ranks[exam.id][score[1]] = 1
-          end
-        end
-      end
-    end
-
-  end
-
-end