/Gradebook/Scripts/app/class.result.list.js

/// <reference path="../zepto.min.js" />

/// <reference path="../knockout-2.2.1.debug.js" />

/// <reference path="../underscore-ko-1.2.2.js" />

/// <reference path="../underscore.js" />

/// <reference path="class.subject.js" />

/// <reference path="task.js" />

/// <reference path="task.type.js" />

/// <reference path="main.js" />

/// <reference path="url.helper.js" />

/// <reference path="results.js" />

/// <reference path="task.filter.js" />



function ClassResultList() {

    var self = this;



    // Data

    self.items = ko.observableArray();

    self.taskTypes = ko.observableArray(TaskType.defaultValues);

    self.students = ko.observableArray();



    self.chosenInterval = ko.observable(TaskFilter.overallItem);

    self.chosenTaskType = ko.observable(TaskType.all);

    self.chosenIntervalType = ko.computed(function () {

        return self.chosenInterval().type;

    });



    self.classes = ko.observableArray();

    self.classSubject = ko.observable();

    self.classIndex = function () {

        return self.classes.indexOf(self.classSubject);

    };



    // Display

    self.showPercents = ko.observable(false);



    // Properties

    self.isEmpty = ko.computed(function () {

        var items = self.items();

        return _.isNull(items) || _.isEmpty(items);

    });

    self.hasNext = ko.computed(function () {

        return self.classIndex() + 1 < self.classes().length;

    });

    self.hasPrev = ko.computed(function () {

        return self.classIndex() - 1 >= 0;

    });

    self.columns = ko.computed(function () {

        if (self.isEmpty()) return [];



        return self.items()[0].results();

    });

    self.hasTasks = ko.computed(function () {

        return !self.isEmpty() && self.columns().length > 0;

    });



    // Computed data

    self.averageRate = ko.computed(function () {

        var items = self.items();

        if (self.isEmpty()) return null;



        var count = 0;

        var sum = _.reduce(items, function (memo, item) {

            var rate = item.rate();

            if (rate) {

                count++;

                return memo + rate;

            }

            return memo;

        }, 0);



        return count > 0 ? Math.round(sum * 100 / count) / 100 : null;

    });



    // Load/save data

    self.load = function () {

        var classSubject = self.classSubject();



        if (classSubject == null) {

            self.items.removeAll();

            return;

        }



        var url = UrlHelper.getUrl("students", {

            code: classSubject.id

        });



        $.getJSON(url, function (data) {

            var mappedData = $.map(data, function (item) {

                return new Student(item);

            });

            self.students(mappedData);

        });



        url = UrlHelper.getUrl("results", {

            code: classSubject.id

        });



        $.getJSON(url, function (data) {

            var items = _.map(self.students(), function(student) {

                return new StudentResult(data, student);

            });

            self.items(items);

            self.updateFilters();

        });

    };

    self.save = function () {

        $.ajax({

            type: 'POST',

            url: 'api/grades/list',

            contentType: 'application/json',

            data: JSON.stringify(self.getGrades())

        });

    };

    self.preload = function () {

        var classSubject = self.classSubject();



        if (classSubject == null) return;



        var url = UrlHelper.getUrl("taskTypes", {

            code: classSubject.id

        });



        $.getJSON(url, function (data) {

            var mappedData = $.map(data, function (item) {

                return new TaskType(item);

            });

            self.updateTypeFilter(mappedData);

        });



        $.getJSON(UrlHelper.resources.classSubjects, function (data) {

            var mappedData = $.map(data, function (item) {

                return new ClassSubject(item);

            });

            self.classes(mappedData);

        });

    };



    // Behaviours

    self.next = function () {

        if (!hasNext) return;

        var index = self.classIndex() + 1;

        self.goToClass(index);

    };

    self.prev = function () {

        if (!hasPrev) return;

        var index = self.classIndex() - 1;

        self.goToClass(index);

    };

    self.goToClass = function (index) {

        var item = self.classes()[index];

        self.classSubject(item);

    };



    // Subscriptions

    self.classSubject.subscribe(function () {

        self.preload();

        self.load();

    });

    self.chosenInterval.subscribe(function (value) {

        if (value.type != TaskFilter.options.term) {

            self.chosenTaskType(TaskType.assessments);

        }

        var items = self.items();

        if (items) {

            _.each(items, function (item) {

                item.intervalFilter(value);

            });

        }

    });

    self.chosenTaskType.subscribe(function (value) {

        var items = self.items();

        if (items) {

            _.each(items, function (item) {

                item.typeFilter(value);

            });

        }

    });



    // Functions

    self.getRank = function (classResult) {

        var items = self.items();

        if (_.isNull(items) || _.isEmpty(items) || classResult == undefined) return 0;



        var studentRate = classResult.rate();

        if (!studentRate) return 0;



        var rates = _.map(items, function (item) {

            return item.rate();

        });



        rates = _.sortBy(rates, function (num) { return -num; });



        return _.indexOf(rates, studentRate) + 1;

    };

    self.getAverageResult = function (id, type) {

        var items = self.items();



        if (self.isEmpty() || type == null || id == null) return null;



        var count = 0;

        var sum = _.reduce(items, function (memo, item) {

            var result = item.getByType(type, id);

            if (result) {

                var value = result.result();

                if (value) {

                    count++;

                    return memo + value;

                }

            }

            return memo;

        }, 0);



        return count > 0 ? Math.round(sum * 100 / count) / 100 : null;

    };

    self.getAverageRate = function (id, type) {

        var items = self.items();



        if (self.isEmpty() || type == null || id == null) return null;



        var count = 0;

        var sum = _.reduce(items, function (memo, item) {

            var result = item.getByType(type, id);

            if (result) {

                var rate = result.rate();

                if (rate) {

                    count++;

                    return memo + rate;

                }

            }

            return memo;

        }, 0);



        return count > 0 ? Math.round(sum * 100 / count) / 100 : null;

    };

    self.allDone = function (taskId) {

        var items = self.items();

        if (_.isNull(items) || _.isEmpty(items)) return false;



        return _.all(items, function (item) {

            var result = item.getByType("Task", taskId);

            if (result != null) {

                return result.result() > 0;

            }

            return false;

        });

    };

    self.getGrades = function () {

        if (self.isEmpty()) return null;



        return _.reduce(self.items(), function (memo, item) {

            return _.union(memo, item.getGrades());

        }, []);

    };

    self.updateFilters = function() {

        var items = self.items();

        var interval = self.chosenInterval();

        var type = self.chosenTaskType();

        if (items) {

            _.each(items, function (item) {

                item.intervalFilter(interval);

                item.typeFilter(type);

            });

        }

    };

    self.updateTypeFilter = function (data) {

        var selectedType = self.chosenTaskType();



        self.taskTypes.remove(function(item) {

            return _.all(data, function(type) {

                return item.id > 0 && type.id != item.id;

            })

        })

        var newTypes = _.filter(data, function(type) {

            return _.all(self.taskTypes(), function(item) {

                return item.id != type.id;

            })

        })

        ko.utils.arrayPushAll(self.taskTypes(), newTypes);

        self.taskTypes.valueHasMutated();



        var newSelectedType = _.find(self.taskTypes(), function(item) {

            return item.name == selectedType.name;

        });



        if (newSelectedType) {

            self.chosenTaskType(newSelectedType);

        }

    }



    self.sortDirection = true;

    self.sortItems = function (task) {

        if (self.isEmpty()) return;



        var ascSort = function (left, right) {

            return left == right ? 0 : (left < right ? -1 : 1);

        };

        var descSort = function (left, right) {

            return left == right ? 0 : (left > right ? -1 : 1);

        };



        self.items.sort(function (left, right) {

            var leftValue = left.getTaskResult(task);

            var rightValue = right.getTaskResult(task);



            return self.sortDirection ? ascSort(leftValue, rightValue) : descSort(leftValue, rightValue);

        });



        self.sortDirection = !self.sortDirection;

    };

}