Initial commit

webservice/apps/RUG_template/static/RUG_template/javascript/javascript.js

@@ -0,0 +1,64 @@
+function csrfSafeMethod(method) {
+  // these HTTP methods do not require CSRF protection
+  return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method));
+}
+
+function init_password_toggles() {
+  jQuery('input[type="password"]').each(function(counter,value){
+    jQuery('<button type="button" class="password_toggle password_hidden icon" title="Toggle password" />').text('Toggle password').insertAfter(value);
+  });
+
+  jQuery('button.password_toggle').on('click',function(event){
+    event.preventDefault();
+    toggle_password(this);
+  });
+}
+
+function toggle_password(button) {
+  button = jQuery(button);
+  let password_field = button.prev('input');
+  let show = password_field.attr('type') == 'password';
+
+  password_field.attr('type',( show ? 'text' : 'password' ));
+  button.removeClass('password_hidden password_shown').addClass(( show ? 'password_shown' : 'password_hidden' ))
+}
+
+function human_sizes(value) {
+  const units = ['B','KB','MB','GB','TB','HB'];
+  const unit_value = 1000;
+
+  let counter = 0;
+  while (value / unit_value > 1) {
+    value /= unit_value;
+    counter++;
+  }
+  return value + '' + units[counter];
+}
+
+function label_required_fields() {
+  jQuery('input,textarea,select').filter('[required]:visible').each(function(counter,value){
+    let field = jQuery(value);
+    jQuery('label[for="' + field.attr('id') + '"]').append('<span class="required">*</span>');
+  });
+
+  /*
+  jQuery('select').each(function(counter,value){
+    let field = jQuery(value);
+    console.log(jQuery('label[for="' + field.attr('id') + '"]'));
+    jQuery('label[for="' + field.attr('id') + '"]').append('<span class="required">*</span>');
+  });
+  */
+}
+
+jQuery(function(){
+  jQuery.ajaxSetup({
+    beforeSend: function(xhr, settings) {
+        if (!csrfSafeMethod(settings.type) && !this.crossDomain) {
+            xhr.setRequestHeader("X-CSRFToken", Cookies.get('csrftoken'));
+        }
+      }
+  });
+
+  init_password_toggles();
+  label_required_fields();
+});

webservice/apps/RUG_template/static/RUG_template/javascript/jquery.formset.js

@@ -0,0 +1,252 @@
+/**
+ * https://raw.githubusercontent.com/elo80ka/django-dynamic-formset/master/src/jquery.formset.js
+ * jQuery Formset 1.5-pre
+ * @author Stanislaus Madueke (stan DOT madueke AT gmail DOT com)
+ * @requires jQuery 1.2.6 or later
+ *
+ * Copyright (c) 2009, Stanislaus Madueke
+ * All rights reserved.
+ *
+ * Licensed under the New BSD License
+ * See: http://www.opensource.org/licenses/bsd-license.php
+ */
+;(function($) {
+    $.fn.formset = function(opts)
+    {
+        var options = $.extend({}, $.fn.formset.defaults, opts),
+            flatExtraClasses = options.extraClasses.join(' '),
+            totalForms = $('#id_' + options.prefix + '-TOTAL_FORMS'),
+            maxForms = $('#id_' + options.prefix + '-MAX_NUM_FORMS'),
+            minForms = $('#id_' + options.prefix + '-MIN_NUM_FORMS'),
+            childElementSelector = 'input,select,textarea,label,div',
+            $$ = $(this),
+
+            applyExtraClasses = function(row, ndx) {
+                if (options.extraClasses) {
+                    row.removeClass(flatExtraClasses);
+                    row.addClass(options.extraClasses[ndx % options.extraClasses.length]);
+                }
+            },
+
+            updateElementIndex = function(elem, prefix, ndx) {
+                var idRegex = new RegExp(prefix + '-(\\d+|__prefix__)-'),
+                    replacement = prefix + '-' + ndx + '-';
+                if (elem.attr("for")) elem.attr("for", elem.attr("for").replace(idRegex, replacement));
+                if (elem.attr('id')) elem.attr('id', elem.attr('id').replace(idRegex, replacement));
+                if (elem.attr('name')) elem.attr('name', elem.attr('name').replace(idRegex, replacement));
+            },
+
+            hasChildElements = function(row) {
+                return row.find(childElementSelector).length > 0;
+            },
+
+            showAddButton = function() {
+                return maxForms.length == 0 ||   // For Django versions pre 1.2
+                    (maxForms.val() == '' || (maxForms.val() - totalForms.val() > 0));
+            },
+
+            /**
+            * Indicates whether delete link(s) can be displayed - when total forms > min forms
+            */
+            showDeleteLinks = function() {
+                return minForms.length == 0 ||   // For Django versions pre 1.7
+                    (minForms.val() == '' || (totalForms.val() - minForms.val() > 0));
+            },
+
+            insertDeleteLink = function(row) {
+                var delCssSelector = $.trim(options.deleteCssClass).replace(/\s+/g, '.'),
+                    addCssSelector = $.trim(options.addCssClass).replace(/\s+/g, '.');
+
+                var delButtonHTML = '<a class="' + options.deleteCssClass + '" href="javascript:void(0)">' + options.deleteText +'</a>';
+                if (options.deleteContainerClass) {
+                    // If we have a specific container for the remove button,
+                    // place it as the last child of that container:
+                    row.find('[class*="' + options.deleteContainerClass + '"]').append(delButtonHTML);
+                } else if (row.is('TR')) {
+                    // If the forms are laid out in table rows, insert
+                    // the remove button into the last table cell:
+                    row.children(':last').append(delButtonHTML);
+                } else if (row.is('UL') || row.is('OL')) {
+                    // If they're laid out as an ordered/unordered list,
+                    // insert an <li> after the last list item:
+                    row.append('<li>' + delButtonHTML + '</li>');
+                } else {
+                    // Otherwise, just insert the remove button as the
+                    // last child element of the form's container:
+                    row.append(delButtonHTML);
+                }
+
+                // Check if we're under the minimum number of forms - not to display delete link at rendering
+                if (!showDeleteLinks()){
+                    row.find('a.' + delCssSelector).hide();
+                }
+
+                row.find('a.' + delCssSelector).click(function() {
+                    var row = $(this).parents('.' + options.formCssClass),
+                        del = row.find('input:hidden[id $= "-DELETE"]'),
+                        buttonRow = row.siblings("a." + addCssSelector + ', .' + options.formCssClass + '-add'),
+                        forms;
+                    if (del.length) {
+                        // We're dealing with an inline formset.
+                        // Rather than remove this form from the DOM, we'll mark it as deleted
+                        // and hide it, then let Django handle the deleting:
+                        del.val('on');
+                        row.hide();
+                        forms = $('.' + options.formCssClass).not(':hidden');
+                        totalForms.val(forms.length);
+                    } else {
+                        row.remove();
+                        // Update the TOTAL_FORMS count:
+                        forms = $('.' + options.formCssClass).not('.formset-custom-template');
+                        totalForms.val(forms.length);
+                    }
+                    for (var i=0, formCount=forms.length; i<formCount; i++) {
+                        // Apply `extraClasses` to form rows so they're nicely alternating:
+                        applyExtraClasses(forms.eq(i), i);
+                        if (!del.length) {
+                            // Also update names and IDs for all child controls (if this isn't
+                            // a delete-able inline formset) so they remain in sequence:
+                            forms.eq(i).find(childElementSelector).each(function() {
+                                updateElementIndex($(this), options.prefix, i);
+                            });
+                        }
+                    }
+                    // Check if we've reached the minimum number of forms - hide all delete link(s)
+                    if (!showDeleteLinks()){
+                        $('a.' + delCssSelector).each(function(){$(this).hide();});
+                    }
+                    // Check if we need to show the add button:
+                    if (buttonRow.is(':hidden') && showAddButton()) buttonRow.show();
+                    // If a post-delete callback was provided, call it with the deleted form:
+                    if (options.removed) options.removed(row);
+                    return false;
+                });
+            };
+
+        $$.each(function(i) {
+            var row = $(this),
+                del = row.find('input:checkbox[id $= "-DELETE"]');
+            if (del.length) {
+                // If you specify "can_delete = True" when creating an inline formset,
+                // Django adds a checkbox to each form in the formset.
+                // Replace the default checkbox with a hidden field:
+                if (del.is(':checked')) {
+                    // If an inline formset containing deleted forms fails validation, make sure
+                    // we keep the forms hidden (thanks for the bug report and suggested fix Mike)
+                    del.before('<input type="hidden" name="' + del.attr('name') +'" id="' + del.attr('id') +'" value="on" />');
+                    row.hide();
+                } else {
+                    del.before('<input type="hidden" name="' + del.attr('name') +'" id="' + del.attr('id') +'" />');
+                }
+                // Hide any labels associated with the DELETE checkbox:
+                $('label[for="' + del.attr('id') + '"]').hide();
+                del.remove();
+            }
+            if (hasChildElements(row)) {
+                row.addClass(options.formCssClass);
+                if (row.is(':visible')) {
+                    insertDeleteLink(row);
+                    applyExtraClasses(row, i);
+                }
+            }
+        });
+
+        if ($$.length) {
+            var hideAddButton = !showAddButton(),
+                addButton, template;
+            if (options.formTemplate) {
+                // If a form template was specified, we'll clone it to generate new form instances:
+                template = (options.formTemplate instanceof $) ? options.formTemplate : $(options.formTemplate);
+                template.removeAttr('id').addClass(options.formCssClass + ' formset-custom-template');
+                template.find(childElementSelector).each(function() {
+                    updateElementIndex($(this), options.prefix, '__prefix__');
+                });
+                insertDeleteLink(template);
+            } else {
+                // Otherwise, use the last form in the formset; this works much better if you've got
+                // extra (>= 1) forms (thnaks to justhamade for pointing this out):
+                if (options.hideLastAddForm) $('.' + options.formCssClass + ':last').hide();
+                template = $('.' + options.formCssClass + ':last').clone(true).removeAttr('id');
+                template.find('input:hidden[id $= "-DELETE"]').remove();
+                // Clear all cloned fields, except those the user wants to keep (thanks to brunogola for the suggestion):
+                template.find(childElementSelector).not(options.keepFieldValues).each(function() {
+                    var elem = $(this);
+                    // If this is a checkbox or radiobutton, uncheck it.
+                    // This fixes Issue 1, reported by Wilson.Andrew.J:
+                    if (elem.is('input:checkbox') || elem.is('input:radio')) {
+                        elem.attr('checked', false);
+                    } else {
+                        elem.val('');
+                    }
+                });
+            }
+            // FIXME: Perhaps using $.data would be a better idea?
+            options.formTemplate = template;
+
+            var addButtonHTML = '<a class="' + options.addCssClass + '" href="javascript:void(0)">' + options.addText + '</a>';
+            if (options.addContainerClass) {
+                // If we have a specific container for the "add" button,
+                // place it as the last child of that container:
+                var addContainer = $('[class*="' + options.addContainerClass + '"');
+                addContainer.append(addButtonHTML);
+                addButton = addContainer.find('[class="' + options.addCssClass + '"]');
+            } else if ($$.is('TR')) {
+                // If forms are laid out as table rows, insert the
+                // "add" button in a new table row:
+                var numCols = $$.eq(0).children().length,   // This is a bit of an assumption :|
+                    buttonRow = $('<tr><td colspan="' + numCols + '">' + addButtonHTML + '</tr>').addClass(options.formCssClass + '-add');
+                $$.parent().append(buttonRow);
+                addButton = buttonRow.find('a');
+            } else {
+                // Otherwise, insert it immediately after the last form:
+                $$.filter(':last').after(addButtonHTML);
+                addButton = $$.filter(':last').next();
+            }
+
+            if (hideAddButton) addButton.hide();
+
+            addButton.click(function() {
+                var formCount = parseInt(totalForms.val()),
+                    row = options.formTemplate.clone(true).removeClass('formset-custom-template'),
+                    buttonRow = $($(this).parents('tr.' + options.formCssClass + '-add').get(0) || this),
+                    delCssSelector = $.trim(options.deleteCssClass).replace(/\s+/g, '.');
+                applyExtraClasses(row, formCount);
+                row.insertBefore(buttonRow).show();
+                row.find(childElementSelector).each(function() {
+                    updateElementIndex($(this), options.prefix, formCount);
+                });
+                totalForms.val(formCount + 1);
+                // Check if we're above the minimum allowed number of forms -> show all delete link(s)
+                if (showDeleteLinks()){
+                    $('a.' + delCssSelector).each(function(){$(this).show();});
+                }
+                // Check if we've exceeded the maximum allowed number of forms:
+                if (!showAddButton()) buttonRow.hide();
+                // If a post-add callback was supplied, call it with the added form:
+                if (options.added) options.added(row);
+                return false;
+            });
+        }
+
+        return $$;
+    };
+
+    /* Setup plugin defaults */
+    $.fn.formset.defaults = {
+        prefix: 'form',                  // The form prefix for your django formset
+        formTemplate: null,              // The jQuery selection cloned to generate new form instances
+        addText: 'add another',          // Text for the add link
+        deleteText: 'remove',            // Text for the delete link
+        addContainerClass: null,         // Container CSS class for the add link
+        deleteContainerClass: null,      // Container CSS class for the delete link
+        addCssClass: 'add-row',          // CSS class applied to the add link
+        deleteCssClass: 'delete-row',    // CSS class applied to the delete link
+        formCssClass: 'dynamic-form',    // CSS class applied to each form in a formset
+        extraClasses: [],                // Additional CSS classes, which will be applied to each form in turn
+        keepFieldValues: '',             // jQuery selector for fields whose values should be kept when the form is cloned
+        added: null,                     // Function called each time a new form is added
+        removed: null,                   // Function called each time a form is deleted
+        hideLastAddForm: false           // When set to true, hide last empty add form (becomes visible when clicking on add button)
+    };
+})(jQuery);
+

webservice/apps/RUG_template/static/RUG_template/javascript/konami.js

@@ -0,0 +1,151 @@
+/*
+ * Konami-JS ~
+ * :: Now with support for touch events and multiple instances for
+ * :: those situations that call for multiple easter eggs!
+ * Code: https://github.com/snaptortoise/konami-js
+ * Copyright (c) 2009 George Mandis (georgemandis.com, snaptortoise.com)
+ * Version: 1.6.2 (7/17/2018)
+ * Licensed under the MIT License (http://opensource.org/licenses/MIT)
+ * Tested in: Safari 4+, Google Chrome 4+, Firefox 3+, IE7+, Mobile Safari 2.2.1+ and Android
+ */
+
+var Konami = function (callback) {
+    var konami = {
+        addEvent: function (obj, type, fn, ref_obj) {
+            if (obj.addEventListener)
+                obj.addEventListener(type, fn, false);
+            else if (obj.attachEvent) {
+                // IE
+                obj["e" + type + fn] = fn;
+                obj[type + fn] = function () {
+                    obj["e" + type + fn](window.event, ref_obj);
+                }
+                obj.attachEvent("on" + type, obj[type + fn]);
+            }
+        },
+        removeEvent: function (obj, eventName, eventCallback) {
+            if (obj.removeEventListener) {
+                obj.removeEventListener(eventName, eventCallback);
+            } else if (obj.attachEvent) {
+                obj.detachEvent(eventName);
+            }
+        },
+        input: "",
+        pattern: "38384040373937396665",
+        keydownHandler: function (e, ref_obj) {
+            if (ref_obj) {
+                konami = ref_obj;
+            } // IE
+            konami.input += e ? e.keyCode : event.keyCode;
+            if (konami.input.length > konami.pattern.length) {
+                konami.input = konami.input.substr((konami.input.length - konami.pattern.length));
+            }
+            if (konami.input === konami.pattern) {
+                konami.code(konami._currentLink);
+                konami.input = '';
+                e.preventDefault();
+                return false;
+            }
+        },
+        load: function (link) {
+            this._currentLink = link;
+            this.addEvent(document, "keydown", this.keydownHandler, this);
+            this.iphone.load(link);
+        },
+        unload: function () {
+            this.removeEvent(document, 'keydown', this.keydownHandler);
+            this.iphone.unload();
+        },
+        code: function (link) {
+            window.location = link
+        },
+        iphone: {
+            start_x: 0,
+            start_y: 0,
+            stop_x: 0,
+            stop_y: 0,
+            tap: false,
+            capture: false,
+            orig_keys: "",
+            keys: ["UP", "UP", "DOWN", "DOWN", "LEFT", "RIGHT", "LEFT", "RIGHT", "TAP", "TAP"],
+            input: [],
+            code: function (link) {
+                konami.code(link);
+            },
+            touchmoveHandler: function (e) {
+                if (e.touches.length === 1 && konami.iphone.capture === true) {
+                    var touch = e.touches[0];
+                    konami.iphone.stop_x = touch.pageX;
+                    konami.iphone.stop_y = touch.pageY;
+                    konami.iphone.tap = false;
+                    konami.iphone.capture = false;
+                    konami.iphone.check_direction();
+                }
+            },
+            touchendHandler: function () {
+                konami.iphone.input.push(konami.iphone.check_direction());
+
+                if (konami.iphone.input.length > konami.iphone.keys.length) konami.iphone.input.shift();
+
+                if (konami.iphone.input.length === konami.iphone.keys.length) {
+                    var match = true;
+                    for (var i = 0; i < konami.iphone.keys.length; i++) {
+                        if (konami.iphone.input[i] !== konami.iphone.keys[i]) {
+                            match = false;
+                        }
+                    }
+                    if (match) {
+                        konami.iphone.code(konami._currentLink);
+                    }
+                }
+            },
+            touchstartHandler: function (e) {
+                konami.iphone.start_x = e.changedTouches[0].pageX;
+                konami.iphone.start_y = e.changedTouches[0].pageY;
+                konami.iphone.tap = true;
+                konami.iphone.capture = true;
+            },
+            load: function (link) {
+                this.orig_keys = this.keys;
+                konami.addEvent(document, "touchmove", this.touchmoveHandler);
+                konami.addEvent(document, "touchend", this.touchendHandler, false);
+                konami.addEvent(document, "touchstart", this.touchstartHandler);
+            },
+            unload: function () {
+                konami.removeEvent(document, 'touchmove', this.touchmoveHandler);
+                konami.removeEvent(document, 'touchend', this.touchendHandler);
+                konami.removeEvent(document, 'touchstart', this.touchstartHandler);
+            },
+            check_direction: function () {
+                x_magnitude = Math.abs(this.start_x - this.stop_x);
+                y_magnitude = Math.abs(this.start_y - this.stop_y);
+                x = ((this.start_x - this.stop_x) < 0) ? "RIGHT" : "LEFT";
+                y = ((this.start_y - this.stop_y) < 0) ? "DOWN" : "UP";
+                result = (x_magnitude > y_magnitude) ? x : y;
+                result = (this.tap === true) ? "TAP" : result;
+                return result;
+            }
+        }
+    }
+
+    typeof callback === "string" && konami.load(callback);
+    if (typeof callback === "function") {
+        konami.code = callback;
+        konami.load();
+    }
+
+    return konami;
+};
+
+
+if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {
+        module.exports = Konami;
+} else {
+        if (typeof define === 'function' && define.amd) {
+                define([], function() {
+                        return Konami;
+                });
+        } else {
+                window.Konami = Konami;
+        }
+}

webservice/apps/RUG_template/static/RUG_template/style/base.css

@@ -0,0 +1,155 @@
+.rug-wrapper {
+    max-width: 80% !important;
+}
+
+.rug-width-m-8-24 {
+    width: 25%;
+}
+
+.rug-panel--content {
+    max-width: none;
+}
+
+.rug-nav--main__item {
+    display: none;
+}
+
+.rug-nav--main__item:first-of-type,
+.rug-nav--main__item:last-of-type {
+    display: block;
+}
+
+.rug-breadcrumbs {
+    display: none;
+}
+
+p {
+    max-width: none;
+}
+
+table {
+    width: 100%;
+}
+
+table.stripe tr:nth-child(even) {
+    background-color: #f2f2f2;
+}
+
+table.stripe td {
+    white-space: nowrap;
+  overflow: hidden;
+}
+
+table.stripe td.empty {
+    text-align: center;
+}
+
+.pointer {
+    cursor: pointer;
+}
+
+form#new_schedule_form input:not([type=checkbox]) {
+    width: 100%
+}
+
+.text-danger {
+    color: #721c24;
+}
+
+.required {
+    color: red;
+}
+
+span.required {
+    margin-left: 0.2rem;
+}
+
+.alert-warning {
+    color: #856404;
+    background-color: #fff3cd;
+    border-color: #ffeeba;
+}
+
+.alert-success {
+    color: #155724;
+    background-color: #d4edda;
+    border-color: #c3e6cb;
+}
+.alert-danger {
+    color: #721c24;
+    background-color: #f8d7da;
+    border-color: #f5c6cb;
+}
+.form-control {
+    display: block;
+    width: 100%;
+    height: calc(1.5em + .75rem + 2px);
+    padding: .375rem .75rem;
+    font-size: 1rem;
+    font-weight: 400;
+    line-height: 1.5;
+    color: #495057;
+    background-color: #fff;
+    background-clip: padding-box;
+    border: 1px solid #ced4da;
+    border-radius: .25rem;
+    transition: border-color .15s ease-in-out,box-shadow .15s ease-in-out;
+}
+
+.icon {
+    height: 1rem;
+    width: auto;
+}
+
+h1 .icon {
+    height: 1.5rem;
+}
+
+
+/* Password toggles */
+input[readonly] {
+    border: none;
+    background-color: transparent;
+/*    width: 75px;*/
+  }
+
+  button.password_toggle {
+    width: 1.8rem;
+
+    overflow: hidden;
+    text-indent: -999%;
+    white-space: nowrap;
+    cursor: pointer;
+
+    background-color: transparent;
+    background-repeat: no-repeat;
+    background-size: auto 100%;
+    background-position: center;
+
+    margin-left: 0.2rem;
+    border: none;
+  }
+
+  button.password_toggle.password_hidden {
+    background-image: url('../images/eye-open.png');
+  }
+
+  button.password_toggle.password_shown {
+    background-image: url('../images/eye-closed.png');
+  }
+  /* End Password toggles */
+
+
+.add-row {
+    margin: 6px 0 0 0;
+    padding-left: 24px;
+    background: url('../images/plus-icon.png') no-repeat left center;
+    background-size: auto 80%;
+}
+.delete-row {
+    display:block;
+    margin: 6px 0 0 0;
+    padding-left: 20px;
+    background: url('../images/minus-icon.png') no-repeat left center;
+    background-size: auto 80%;
+}

webservice/apps/RUG_template/static/RUG_template/style/custom_admin.css

@@ -0,0 +1,8 @@
+img.i18n_flag {
+    width: 16px;
+    vertical-align: text-top;
+}
+
+form#language_form {
+    display: inline;
+}