gaku_core 0.0.1

data/db/seeds.rb

@@ -0,0 +1,5 @@
+# Loads seed data out of default dir
+default_path = File.join(File.dirname(__FILE__), 'default')
+  
+Rake::Task['db:load_dir'].reenable
+Rake::Task['db:load_dir'].invoke(default_path)

data/lib/gaku/app_responder.rb

@@ -0,0 +1,6 @@
+module Gaku
+  class AppResponder < ActionController::Responder
+    include Responders::FlashResponder
+    include Responders::HttpCacheResponder
+  end
+end

data/lib/gaku/class_name_detector.rb

@@ -0,0 +1,23 @@
+module Gaku::ClassNameDetector
+
+  def class_name
+    "Gaku::#{controller_name.classify}"
+  end
+
+  def class_name_minus_enrollment
+    "Gaku::#{controller_name.classify.split('Enrollment').first}"
+  end
+
+  def class_name_underscored
+    controller_name.classify.split('Enrollment').first.underscore
+  end
+
+  def class_name_underscored_plural
+    class_name_underscored.pluralize
+  end
+
+  def enrollment_param
+    "#{controller_name.classify.split('Enrollment').first.underscore}_id"
+  end
+
+end

data/lib/gaku/core.rb

@@ -0,0 +1,45 @@
+require 'rails/all'
+require 'rails/generators'
+require 'rails-i18n'
+require 'slim'
+require 'eco'
+require 'paperclip'
+require 'ransack'
+require 'jquery-rails'
+require 'jquery-ui-rails'
+require 'jquery-minicolors-rails'
+require 'momentjs-rails'
+require 'underscore-rails'
+require 'turbolinks'
+require 'devise'
+require 'cancan'
+require 'responders'
+require 'inherited_resources'
+require 'draper'
+require 'kaminari'
+require 'rails4_client_side_validations'
+require 'sidekiq/web'
+require 'paper_trail'
+require 'globalize3'
+require 'thinreports-rails'
+require 'bootstrap-sass'
+require 'bootstrap-datepicker-rails'
+require 'nested_form'
+require 'gaku_helpers'
+require 'gaku_forms'
+require 'gaku_nested_forms'
+
+module Gaku
+
+  module Core
+  end
+
+  def self.config(&block)
+    yield(Gaku::Config)
+  end
+end
+
+require 'gaku/core/version'
+require 'gaku/core/engine'
+require 'gaku/core/console_colors'
+require 'generators/gaku/dummy/dummy_generator'

data/lib/gaku/core/console_colors.rb

@@ -0,0 +1,22 @@
+class String
+  # colorization
+  def colorize(color_code)
+    "\e[#{color_code}m#{self}\e[0m"
+  end
+
+  def red
+    colorize(31)
+  end
+
+  def green
+    colorize(32)
+  end
+
+  def yellow
+    colorize(33)
+  end
+
+  def pink
+    colorize(35)
+  end
+end

data/lib/gaku/core/engine.rb

@@ -0,0 +1,45 @@
+module Gaku
+  module Core
+    class Engine < ::Rails::Engine
+      isolate_namespace Gaku
+      engine_name 'gaku'
+
+      config.autoload_paths += %W(#{config.root}/lib)
+
+      config.to_prepare do
+        GakuController.helper(GakuHelper)
+      end
+
+      def self.activate
+      end
+
+      config.to_prepare &method(:activate).to_proc
+
+      config.after_initialize do
+      end
+
+      # We need to reload the routes here due to how Gaku sets them up.
+      # The different facets of Gaku  append/prepend routes to Core
+      # *after* Core has been loaded.
+      #
+      # So we wait until after initialization is complete to do one final reload.
+      # This then makes the appended/prepended routes available to the application.
+      config.after_initialize do
+        Rails.application.routes_reloader.reload!
+      end
+
+      # sets the manifests / assets to be precompiled, even when initialize_on_precompile is false
+      initializer 'gaku.assets.precompile', group: :all do |app|
+        app.config.assets.precompile += %w[
+          gaku/all.*
+        ]
+      end
+
+      # filter sensitive information during logging
+      initializer 'gaku.params.filter' do |app|
+        app.config.filter_parameters += [:password, :password_confirmation, :number]
+      end
+
+    end
+  end
+end

data/lib/gaku/core/url_helpers.rb

@@ -0,0 +1,5 @@
+module Gaku::Core::UrlHelpers
+  def gaku
+    Gaku::Core::Engine.routes.url_helpers
+  end
+end

data/lib/gaku/core/version.rb

@@ -0,0 +1,5 @@
+module Gaku
+  def self.version
+    '0.0.1'
+  end
+end

data/lib/gaku/exporters/roster_exporter.rb

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+require 'roo'
+require 'GenSheet'
+
+module Gaku
+  module Exporters
+    class RosterExporter
+      @format
+      @template
+      @workbook
+
+      def initialize(options = {})
+        @format = options[:format] || '.xls'
+        #TODO fix with paperclip
+        @template = options[:template] || 'assets/templates/roster.xls'
+        load_template(@template)
+      end
+
+      def load_template(template)
+        begin
+          @workbook = Roo::Spreadsheet.open(@template)
+        rescue
+          @workbook = Roo::Spreadsheet.new
+        end
+      end
+
+      def export_all
+
+      end
+
+      def export(records = {})
+      end
+    end
+  end
+
+end

data/lib/gaku/grading/calculations.rb

@@ -0,0 +1,279 @@
+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