cafe-grader-web Commit - r751:01b657de42d9

cafe-grader-web

Commit `r751:01b657de42d9` public

parent | child

Description:

start update to 5.2

Commit status:

[Not Reviewed]

References:

algo

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r751:01b657de42d9 - Thu, 04 Jul 2019 09:13:44 - 29 files changed: 765 inserted, 140 deleted

app/views/announcements/new.html.haml created 644 ¶ +14

@@ -0,0 +1,14
	1	+ %h1 New announcement
	2	+ = error_messages_for :announcement
	3	+ = simple_form_for(@announcement) do \|f\|
	4	+ .row
	5	+ .col-md-6
	6	+ = f.input :title
	7	+ = f.input :notes, label: 'Notes (shown internally, used to organize announcements)'
	8	+ = f.input :body
	9	+ = f.input :author
	10	+ = f.input :published
	11	+ = f.input :frontpage, label: 'Display in the front page only?'
	12	+ = f.input :contest_only, label: 'Display in contest only?'
	13	+ = f.button :submit, "Create", class: 'btn btn-primary'
	14	+ = link_to 'Back', announcements_path, class: 'btn btn-default'

app/views/announcements/show.html.haml created 644 ¶ +24

@@ -0,0 +1,24
	1	+ %p
	2	+ %b Author:
	3	+ = h @announcement.author
	4	+ %p
	5	+ %b Title:
	6	+ = h @announcement.title
	7	+ %p
	8	+ %b Notes:
	9	+ = h @announcement.notes
	10	+ %p
	11	+ %b Body:
	12	+ = h markdown(@announcement.body)
	13	+ %p
	14	+ %b Published:
	15	+ = h @announcement.published
	16	+ %p
	17	+ %b Show on front page:
	18	+ = h @announcement.frontpage
	19	+ %p
	20	+ %b Show only in contest:
	21	+ = h @announcement.contest_only
	22	+ = link_to 'Edit', edit_announcement_path(@announcement)
	23	+ \|
	24	+ = link_to 'Back', announcements_path

config/initializers/simple_form.rb created 644 ¶ +179

@@ -0,0 +1,179
	1	+ # frozen_string_literal: true
	2	+ #
	3	+ # Uncomment this and change the path if necessary to include your own
	4	+ # components.
	5	+ # See https://github.com/plataformatec/simple_form#custom-components to know
	6	+ # more about custom components.
	7	+ # Dir[Rails.root.join('lib/components/*/.rb')].each { \|f\| require f }
	8	+ #
	9	+ # Use this setup block to configure all options available in SimpleForm.
	10	+ SimpleForm.setup do \|config\|
	11	+ # Wrappers are used by the form builder to generate a
	12	+ # complete input. You can remove any component from the
	13	+ # wrapper, change the order or even add your own to the
	14	+ # stack. The options given below are used to wrap the
	15	+ # whole input.
	16	+ config.wrappers :default, class: :input,
	17	+ hint_class: :field_with_hint, error_class: :field_with_errors, valid_class: :field_without_errors do \|b\|
	18	+ ## Extensions enabled by default
	19	+ # Any of these extensions can be disabled for a
	20	+ # given input by passing: `f.input EXTENSION_NAME => false`.
	21	+ # You can make any of these extensions optional by
	22	+ # renaming `b.use` to `b.optional`.
	23	+
	24	+ # Determines whether to use HTML5 (:email, :url, ...)
	25	+ # and required attributes
	26	+ b.use :html5
	27	+
	28	+ # Calculates placeholders automatically from I18n
	29	+ # You can also pass a string as f.input placeholder: "Placeholder"
	30	+ b.use :placeholder
	31	+
	32	+ ## Optional extensions
	33	+ # They are disabled unless you pass `f.input EXTENSION_NAME => true`
	34	+ # to the input. If so, they will retrieve the values from the model
	35	+ # if any exists. If you want to enable any of those
	36	+ # extensions by default, you can change `b.optional` to `b.use`.
	37	+
	38	+ # Calculates maxlength from length validations for string inputs
	39	+ # and/or database column lengths
	40	+ b.optional :maxlength
	41	+
	42	+ # Calculate minlength from length validations for string inputs
	43	+ b.optional :minlength
	44	+
	45	+ # Calculates pattern from format validations for string inputs
	46	+ b.optional :pattern
	47	+
	48	+ # Calculates min and max from length validations for numeric inputs
	49	+ b.optional :min_max
	50	+
	51	+ # Calculates readonly automatically from readonly attributes
	52	+ b.optional :readonly
	53	+
	54	+ ## Inputs
	55	+ # b.use :input, class: 'input', error_class: 'is-invalid', valid_class: 'is-valid'
	56	+ b.use :label_input
	57	+ b.use :hint, wrap_with: { tag: :span, class: :hint }
	58	+ b.use :error, wrap_with: { tag: :span, class: :error }
	59	+
	60	+ ## full_messages_for
	61	+ # If you want to display the full error message for the attribute, you can
	62	+ # use the component :full_error, like:
	63	+ #
	64	+ # b.use :full_error, wrap_with: { tag: :span, class: :error }
	65	+ end
	66	+
	67	+ # The default wrapper to be used by the FormBuilder.
	68	+ config.default_wrapper = :default
	69	+
	70	+ # Define the way to render check boxes / radio buttons with labels.
	71	+ # Defaults to :nested for bootstrap config.
	72	+ # inline: input + label
	73	+ # nested: label > input
	74	+ config.boolean_style = :nested
	75	+
	76	+ # Default class for buttons
	77	+ config.button_class = 'btn'
	78	+
	79	+ # Method used to tidy up errors. Specify any Rails Array method.
	80	+ # :first lists the first message for each field.
	81	+ # Use :to_sentence to list all errors for each field.
	82	+ # config.error_method = :first
	83	+
	84	+ # Default tag used for error notification helper.
	85	+ config.error_notification_tag = :div
	86	+
	87	+ # CSS class to add for error notification helper.
	88	+ config.error_notification_class = 'error_notification'
	89	+
	90	+ # Series of attempts to detect a default label method for collection.
	91	+ # config.collection_label_methods = [ :to_label, :name, :title, :to_s ]
	92	+
	93	+ # Series of attempts to detect a default value method for collection.
	94	+ # config.collection_value_methods = [ :id, :to_s ]
	95	+
	96	+ # You can wrap a collection of radio/check boxes in a pre-defined tag, defaulting to none.
	97	+ # config.collection_wrapper_tag = nil
	98	+
	99	+ # You can define the class to use on all collection wrappers. Defaulting to none.
	100	+ # config.collection_wrapper_class = nil
	101	+
	102	+ # You can wrap each item in a collection of radio/check boxes with a tag,
	103	+ # defaulting to :span.
	104	+ # config.item_wrapper_tag = :span
	105	+
	106	+ # You can define a class to use in all item wrappers. Defaulting to none.
	107	+ # config.item_wrapper_class = nil
	108	+
	109	+ # How the label text should be generated altogether with the required text.
	110	+ # config.label_text = lambda { \|label, required, explicit_label\| "#{required} #{label}" }
	111	+
	112	+ # You can define the class to use on all labels. Default is nil.
	113	+ # config.label_class = nil
	114	+
	115	+ # You can define the default class to be used on forms. Can be overriden
	116	+ # with `html: { :class }`. Defaulting to none.
	117	+ # config.default_form_class = nil
	118	+
	119	+ # You can define which elements should obtain additional classes
	120	+ # config.generate_additional_classes_for = [:wrapper, :label, :input]
	121	+
	122	+ # Whether attributes are required by default (or not). Default is true.
	123	+ # config.required_by_default = true
	124	+
	125	+ # Tell browsers whether to use the native HTML5 validations (novalidate form option).
	126	+ # These validations are enabled in SimpleForm's internal config but disabled by default
	127	+ # in this configuration, which is recommended due to some quirks from different browsers.
	128	+ # To stop SimpleForm from generating the novalidate option, enabling the HTML5 validations,
	129	+ # change this configuration to true.
	130	+ config.browser_validations = false
	131	+
	132	+ # Collection of methods to detect if a file type was given.
	133	+ # config.file_methods = [ :mounted_as, :file?, :public_filename, :attached? ]
	134	+
	135	+ # Custom mappings for input types. This should be a hash containing a regexp
	136	+ # to match as key, and the input type that will be used when the field name
	137	+ # matches the regexp as value.
	138	+ # config.input_mappings = { /count/ => :integer }
	139	+
	140	+ # Custom wrappers for input types. This should be a hash containing an input
	141	+ # type as key and the wrapper that will be used for all inputs with specified type.
	142	+ # config.wrapper_mappings = { string: :prepend }
	143	+
	144	+ # Namespaces where SimpleForm should look for custom input classes that
	145	+ # override default inputs.
	146	+ # config.custom_inputs_namespaces << "CustomInputs"
	147	+
	148	+ # Default priority for time_zone inputs.
	149	+ # config.time_zone_priority = nil
	150	+
	151	+ # Default priority for country inputs.
	152	+ # config.country_priority = nil
	153	+
	154	+ # When false, do not use translations for labels.
	155	+ # config.translate_labels = true
	156	+
	157	+ # Automatically discover new inputs in Rails' autoload path.
	158	+ # config.inputs_discovery = true
	159	+
	160	+ # Cache SimpleForm inputs discovery
	161	+ # config.cache_discovery = !Rails.env.development?
	162	+
	163	+ # Default class for inputs
	164	+ # config.input_class = nil
	165	+
	166	+ # Define the default class of the input wrapper of the boolean input.
	167	+ config.boolean_label_class = 'checkbox'
	168	+
	169	+ # Defines if the default input wrapper class should be included in radio
	170	+ # collection wrappers.
	171	+ # config.include_default_input_wrapper_class = true
	172	+
	173	+ # Defines which i18n scope will be used in Simple Form.
	174	+ # config.i18n_scope = 'simple_form'
	175	+
	176	+ # Defines validation classes to the input_field. By default it's nil.
	177	+ # config.input_field_valid_class = 'is-valid'
	178	+ # config.input_field_error_class = 'is-invalid'
	179	+ end

config/initializers/simple_form_bootstrap.rb created 644 ¶ +439

@@ -0,0 +1,439
	1	+ # frozen_string_literal: true
	2	+
	3	+ # Please do not make direct changes to this file!
	4	+ # This generator is maintained by the community around simple_form-bootstrap:
	5	+ # https://github.com/rafaelfranca/simple_form-bootstrap
	6	+ # All future development, tests, and organization should happen there.
	7	+ # Background history: https://github.com/plataformatec/simple_form/issues/1561
	8	+
	9	+ # Uncomment this and change the path if necessary to include your own
	10	+ # components.
	11	+ # See https://github.com/plataformatec/simple_form#custom-components
	12	+ # to know more about custom components.
	13	+ # Dir[Rails.root.join('lib/components/*/.rb')].each { \|f\| require f }
	14	+
	15	+ # Use this setup block to configure all options available in SimpleForm.
	16	+ SimpleForm.setup do \|config\|
	17	+ # Default class for buttons
	18	+ config.button_class = 'btn'
	19	+
	20	+ # Define the default class of the input wrapper of the boolean input.
	21	+ config.boolean_label_class = 'form-check-label'
	22	+
	23	+ # How the label text should be generated altogether with the required text.
	24	+ config.label_text = lambda { \|label, required, explicit_label\| "#{label} #{required}" }
	25	+
	26	+ # Define the way to render check boxes / radio buttons with labels.
	27	+ config.boolean_style = :inline
	28	+
	29	+ # You can wrap each item in a collection of radio/check boxes with a tag
	30	+ config.item_wrapper_tag = :div
	31	+
	32	+ # Defines if the default input wrapper class should be included in radio
	33	+ # collection wrappers.
	34	+ config.include_default_input_wrapper_class = false
	35	+
	36	+ # CSS class to add for error notification helper.
	37	+ config.error_notification_class = 'alert alert-danger'
	38	+
	39	+ # Method used to tidy up errors. Specify any Rails Array method.
	40	+ # :first lists the first message for each field.
	41	+ # :to_sentence to list all errors for each field.
	42	+ config.error_method = :to_sentence
	43	+
	44	+ # add validation classes to `input_field`
	45	+ config.input_field_error_class = 'is-invalid'
	46	+ config.input_field_valid_class = 'is-valid'
	47	+
	48	+
	49	+ # vertical forms
	50	+ #
	51	+ # vertical default_wrapper
	52	+ config.wrappers :vertical_form, tag: 'div', class: 'form-group', error_class: 'form-group-invalid', valid_class: 'form-group-valid' do \|b\|
	53	+ b.use :html5
	54	+ b.use :placeholder
	55	+ b.optional :maxlength
	56	+ b.optional :minlength
	57	+ b.optional :pattern
	58	+ b.optional :min_max
	59	+ b.optional :readonly
	60	+ b.use :label, class: 'form-control-label'
	61	+ b.use :input, class: 'form-control', error_class: 'is-invalid', valid_class: 'is-valid'
	62	+ b.use :full_error, wrap_with: { tag: 'div', class: 'invalid-feedback' }
	63	+ b.use :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
	64	+ end
	65	+
	66	+ # vertical input for boolean
	67	+ config.wrappers :vertical_boolean, tag: 'fieldset', class: 'form-group', error_class: 'form-group-invalid', valid_class: 'form-group-valid' do \|b\|
	68	+ b.use :html5
	69	+ b.optional :readonly
	70	+ b.wrapper :form_check_wrapper, tag: 'div', class: 'form-check' do \|bb\|
	71	+ bb.use :input, class: 'form-check-input', error_class: 'is-invalid', valid_class: 'is-valid'
	72	+ bb.use :label, class: 'form-check-label'
	73	+ bb.use :full_error, wrap_with: { tag: 'div', class: 'invalid-feedback' }
	74	+ bb.use :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
	75	+ end
	76	+ end
	77	+
	78	+ # vertical input for radio buttons and check boxes
	79	+ config.wrappers :vertical_collection, item_wrapper_class: 'form-check', tag: 'fieldset', class: 'form-group', error_class: 'form-group-invalid', valid_class: 'form-group-valid' do \|b\|
	80	+ b.use :html5
	81	+ b.optional :readonly
	82	+ b.wrapper :legend_tag, tag: 'legend', class: 'col-form-label pt-0' do \|ba\|
	83	+ ba.use :label_text
	84	+ end
	85	+ b.use :input, class: 'form-check-input', error_class: 'is-invalid', valid_class: 'is-valid'
	86	+ b.use :full_error, wrap_with: { tag: 'div', class: 'invalid-feedback d-block' }
	87	+ b.use :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
	88	+ end
	89	+
	90	+ # vertical input for inline radio buttons and check boxes
	91	+ config.wrappers :vertical_collection_inline, item_wrapper_class: 'form-check form-check-inline', tag: 'fieldset', class: 'form-group', error_class: 'form-group-invalid', valid_class: 'form-group-valid' do \|b\|
	92	+ b.use :html5
	93	+ b.optional :readonly
	94	+ b.wrapper :legend_tag, tag: 'legend', class: 'col-form-label pt-0' do \|ba\|
	95	+ ba.use :label_text
	96	+ end
	97	+ b.use :input, class: 'form-check-input', error_class: 'is-invalid', valid_class: 'is-valid'
	98	+ b.use :full_error, wrap_with: { tag: 'div', class: 'invalid-feedback d-block' }
	99	+ b.use :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
	100	+ end
	101	+
	102	+ # vertical file input
	103	+ config.wrappers :vertical_file, tag: 'div', class: 'form-group', error_class: 'form-group-invalid', valid_class: 'form-group-valid' do \|b\|
	104	+ b.use :html5
	105	+ b.use :placeholder
	106	+ b.optional :maxlength
	107	+ b.optional :minlength
	108	+ b.optional :readonly
	109	+ b.use :label
	110	+ b.use :input, class: 'form-control-file', error_class: 'is-invalid', valid_class: 'is-valid'
	111	+ b.use :full_error, wrap_with: { tag: 'div', class: 'invalid-feedback d-block' }
	112	+ b.use :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
	113	+ end
	114	+
	115	+ # vertical multi select
	116	+ config.wrappers :vertical_multi_select, tag: 'div', class: 'form-group', error_class: 'form-group-invalid', valid_class: 'form-group-valid' do \|b\|
	117	+ b.use :html5
	118	+ b.optional :readonly
	119	+ b.use :label, class: 'form-control-label'
	120	+ b.wrapper tag: 'div', class: 'd-flex flex-row justify-content-between align-items-center' do \|ba\|
	121	+ ba.use :input, class: 'form-control mx-1', error_class: 'is-invalid', valid_class: 'is-valid'
	122	+ end
	123	+ b.use :full_error, wrap_with: { tag: 'div', class: 'invalid-feedback d-block' }
	124	+ b.use :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
	125	+ end
	126	+
	127	+ # vertical range input
	128	+ config.wrappers :vertical_range, tag: 'div', class: 'form-group', error_class: 'form-group-invalid', valid_class: 'form-group-valid' do \|b\|
	129	+ b.use :html5
	130	+ b.use :placeholder
	131	+ b.optional :readonly
	132	+ b.optional :step
	133	+ b.use :label
	134	+ b.use :input, class: 'form-control-range', error_class: 'is-invalid', valid_class: 'is-valid'
	135	+ b.use :full_error, wrap_with: { tag: 'div', class: 'invalid-feedback d-block' }
	136	+ b.use :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
	137	+ end
	138	+
	139	+
	140	+ # horizontal forms
	141	+ #
	142	+ # horizontal default_wrapper
	143	+ config.wrappers :horizontal_form, tag: 'div', class: 'form-group row', error_class: 'form-group-invalid', valid_class: 'form-group-valid' do \|b\|
	144	+ b.use :html5
	145	+ b.use :placeholder
	146	+ b.optional :maxlength
	147	+ b.optional :minlength
	148	+ b.optional :pattern
	149	+ b.optional :min_max
	150	+ b.optional :readonly
	151	+ b.use :label, class: 'col-sm-3 col-form-label'
	152	+ b.wrapper :grid_wrapper, tag: 'div', class: 'col-sm-9' do \|ba\|
	153	+ ba.use :input, class: 'form-control', error_class: 'is-invalid', valid_class: 'is-valid'
	154	+ ba.use :full_error, wrap_with: { tag: 'div', class: 'invalid-feedback' }
	155	+ ba.use :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
	156	+ end
	157	+ end
	158	+
	159	+ # horizontal input for boolean
	160	+ config.wrappers :horizontal_boolean, tag: 'div', class: 'form-group row', error_class: 'form-group-invalid', valid_class: 'form-group-valid' do \|b\|
	161	+ b.use :html5
	162	+ b.optional :readonly
	163	+ b.wrapper tag: 'label', class: 'col-sm-3' do \|ba\|
	164	+ ba.use :label_text
	165	+ end
	166	+ b.wrapper :grid_wrapper, tag: 'div', class: 'col-sm-9' do \|wr\|
	167	+ wr.wrapper :form_check_wrapper, tag: 'div', class: 'form-check' do \|bb\|
	168	+ bb.use :input, class: 'form-check-input', error_class: 'is-invalid', valid_class: 'is-valid'
	169	+ bb.use :label, class: 'form-check-label'
	170	+ bb.use :full_error, wrap_with: { tag: 'div', class: 'invalid-feedback d-block' }
	171	+ bb.use :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
	172	+ end
	173	+ end
	174	+ end
	175	+
	176	+ # horizontal input for radio buttons and check boxes
	177	+ config.wrappers :horizontal_collection, item_wrapper_class: 'form-check', tag: 'div', class: 'form-group row', error_class: 'form-group-invalid', valid_class: 'form-group-valid' do \|b\|
	178	+ b.use :html5
	179	+ b.optional :readonly
	180	+ b.use :label, class: 'col-sm-3 form-control-label'
	181	+ b.wrapper :grid_wrapper, tag: 'div', class: 'col-sm-9' do \|ba\|
	182	+ ba.use :input, class: 'form-check-input', error_class: 'is-invalid', valid_class: 'is-valid'
	183	+ ba.use :full_error, wrap_with: { tag: 'div', class: 'invalid-feedback d-block' }
	184	+ ba.use :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
	185	+ end
	186	+ end
	187	+
	188	+ # horizontal input for inline radio buttons and check boxes
	189	+ config.wrappers :horizontal_collection_inline, item_wrapper_class: 'form-check form-check-inline', tag: 'div', class: 'form-group row', error_class: 'form-group-invalid', valid_class: 'form-group-valid' do \|b\|
	190	+ b.use :html5
	191	+ b.optional :readonly
	192	+ b.use :label, class: 'col-sm-3 form-control-label'
	193	+ b.wrapper :grid_wrapper, tag: 'div', class: 'col-sm-9' do \|ba\|
	194	+ ba.use :input, class: 'form-check-input', error_class: 'is-invalid', valid_class: 'is-valid'
	195	+ ba.use :full_error, wrap_with: { tag: 'div', class: 'invalid-feedback d-block' }
	196	+ ba.use :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
	197	+ end
	198	+ end
	199	+
	200	+ # horizontal file input
	201	+ config.wrappers :horizontal_file, tag: 'div', class: 'form-group row', error_class: 'form-group-invalid', valid_class: 'form-group-valid' do \|b\|
	202	+ b.use :html5
	203	+ b.use :placeholder
	204	+ b.optional :maxlength
	205	+ b.optional :minlength
	206	+ b.optional :readonly
	207	+ b.use :label, class: 'col-sm-3 form-control-label'
	208	+ b.wrapper :grid_wrapper, tag: 'div', class: 'col-sm-9' do \|ba\|
	209	+ ba.use :input, error_class: 'is-invalid', valid_class: 'is-valid'
	210	+ ba.use :full_error, wrap_with: { tag: 'div', class: 'invalid-feedback d-block' }
	211	+ ba.use :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
	212	+ end
	213	+ end
	214	+
	215	+ # horizontal multi select
	216	+ config.wrappers :horizontal_multi_select, tag: 'div', class: 'form-group row', error_class: 'form-group-invalid', valid_class: 'form-group-valid' do \|b\|
	217	+ b.use :html5
	218	+ b.optional :readonly
	219	+ b.use :label, class: 'col-sm-3 control-label'
	220	+ b.wrapper :grid_wrapper, tag: 'div', class: 'col-sm-9' do \|ba\|
	221	+ ba.wrapper tag: 'div', class: 'd-flex flex-row justify-content-between align-items-center' do \|bb\|
	222	+ bb.use :input, class: 'form-control mx-1', error_class: 'is-invalid', valid_class: 'is-valid'
	223	+ end
	224	+ ba.use :full_error, wrap_with: { tag: 'div', class: 'invalid-feedback d-block' }
	225	+ ba.use :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
	226	+ end
	227	+ end
	228	+
	229	+ # horizontal range input
	230	+ config.wrappers :horizontal_range, tag: 'div', class: 'form-group row', error_class: 'form-group-invalid', valid_class: 'form-group-valid' do \|b\|
	231	+ b.use :html5
	232	+ b.use :placeholder
	233	+ b.optional :readonly
	234	+ b.optional :step
	235	+ b.use :label, class: 'col-sm-3 form-control-label'
	236	+ b.wrapper :grid_wrapper, tag: 'div', class: 'col-sm-9' do \|ba\|
	237	+ ba.use :input, class: 'form-control-range', error_class: 'is-invalid', valid_class: 'is-valid'
	238	+ ba.use :full_error, wrap_with: { tag: 'div', class: 'invalid-feedback d-block' }
	239	+ ba.use :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
	240	+ end
	241	+ end
	242	+
	243	+
	244	+ # inline forms
	245	+ #
	246	+ # inline default_wrapper
	247	+ config.wrappers :inline_form, tag: 'span', error_class: 'form-group-invalid', valid_class: 'form-group-valid' do \|b\|
	248	+ b.use :html5
	249	+ b.use :placeholder
	250	+ b.optional :maxlength
	251	+ b.optional :minlength
	252	+ b.optional :pattern
	253	+ b.optional :min_max
	254	+ b.optional :readonly
	255	+ b.use :label, class: 'sr-only'
	256	+
	257	+ b.use :input, class: 'form-control', error_class: 'is-invalid', valid_class: 'is-valid'
	258	+ b.use :error, wrap_with: { tag: 'div', class: 'invalid-feedback' }
	259	+ b.optional :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
	260	+ end
	261	+
	262	+ # inline input for boolean
	263	+ config.wrappers :inline_boolean, tag: 'span', class: 'form-check flex-wrap justify-content-start mr-sm-2', error_class: 'form-group-invalid', valid_class: 'form-group-valid' do \|b\|
	264	+ b.use :html5
	265	+ b.optional :readonly
	266	+ b.use :input, class: 'form-check-input', error_class: 'is-invalid', valid_class: 'is-valid'
	267	+ b.use :label, class: 'form-check-label'
	268	+ b.use :error, wrap_with: { tag: 'div', class: 'invalid-feedback' }
	269	+ b.optional :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
	270	+ end
	271	+
	272	+
	273	+ # bootstrap custom forms
	274	+ #
	275	+ # custom input for boolean
	276	+ config.wrappers :custom_boolean, tag: 'fieldset', class: 'form-group', error_class: 'form-group-invalid', valid_class: 'form-group-valid' do \|b\|
	277	+ b.use :html5
	278	+ b.optional :readonly
	279	+ b.wrapper :form_check_wrapper, tag: 'div', class: 'custom-control custom-checkbox' do \|bb\|
	280	+ bb.use :input, class: 'custom-control-input', error_class: 'is-invalid', valid_class: 'is-valid'
	281	+ bb.use :label, class: 'custom-control-label'
	282	+ bb.use :full_error, wrap_with: { tag: 'div', class: 'invalid-feedback' }
	283	+ bb.use :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
	284	+ end
	285	+ end
	286	+
	287	+ config.wrappers :custom_boolean_switch, tag: 'fieldset', class: 'form-group', error_class: 'form-group-invalid', valid_class: 'form-group-valid' do \|b\|
	288	+ b.use :html5
	289	+ b.optional :readonly
	290	+ b.wrapper :form_check_wrapper, tag: 'div', class: 'custom-control custom-checkbox-switch' do \|bb\|
	291	+ bb.use :input, class: 'custom-control-input', error_class: 'is-invalid', valid_class: 'is-valid'
	292	+ bb.use :label, class: 'custom-control-label'
	293	+ bb.use :full_error, wrap_with: { tag: 'div', class: 'invalid-feedback' }
	294	+ bb.use :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
	295	+ end
	296	+ end
	297	+
	298	+ # custom input for radio buttons and check boxes
	299	+ config.wrappers :custom_collection, item_wrapper_class: 'custom-control', tag: 'fieldset', class: 'form-group', error_class: 'form-group-invalid', valid_class: 'form-group-valid' do \|b\|
	300	+ b.use :html5
	301	+ b.optional :readonly
	302	+ b.wrapper :legend_tag, tag: 'legend', class: 'col-form-label pt-0' do \|ba\|
	303	+ ba.use :label_text
	304	+ end
	305	+ b.use :input, class: 'custom-control-input', error_class: 'is-invalid', valid_class: 'is-valid'
	306	+ b.use :full_error, wrap_with: { tag: 'div', class: 'invalid-feedback d-block' }
	307	+ b.use :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
	308	+ end
	309	+
	310	+ # custom input for inline radio buttons and check boxes
	311	+ config.wrappers :custom_collection_inline, item_wrapper_class: 'custom-control custom-control-inline', tag: 'fieldset', class: 'form-group', error_class: 'form-group-invalid', valid_class: 'form-group-valid' do \|b\|
	312	+ b.use :html5
	313	+ b.optional :readonly
	314	+ b.wrapper :legend_tag, tag: 'legend', class: 'col-form-label pt-0' do \|ba\|
	315	+ ba.use :label_text
	316	+ end
	317	+ b.use :input, class: 'custom-control-input', error_class: 'is-invalid', valid_class: 'is-valid'
	318	+ b.use :full_error, wrap_with: { tag: 'div', class: 'invalid-feedback d-block' }
	319	+ b.use :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
	320	+ end
	321	+
	322	+ # custom file input
	323	+ config.wrappers :custom_file, tag: 'div', class: 'form-group', error_class: 'form-group-invalid', valid_class: 'form-group-valid' do \|b\|
	324	+ b.use :html5
	325	+ b.use :placeholder
	326	+ b.optional :maxlength
	327	+ b.optional :minlength
	328	+ b.optional :readonly
	329	+ b.use :label, class: 'form-control-label'
	330	+ b.wrapper :custom_file_wrapper, tag: 'div', class: 'custom-file' do \|ba\|
	331	+ ba.use :input, class: 'custom-file-input', error_class: 'is-invalid', valid_class: 'is-valid'
	332	+ ba.use :label, class: 'custom-file-label'
	333	+ ba.use :full_error, wrap_with: { tag: 'div', class: 'invalid-feedback' }
	334	+ end
	335	+ b.use :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
	336	+ end
	337	+
	338	+ # custom multi select
	339	+ config.wrappers :custom_multi_select, tag: 'div', class: 'form-group', error_class: 'form-group-invalid', valid_class: 'form-group-valid' do \|b\|
	340	+ b.use :html5
	341	+ b.optional :readonly
	342	+ b.use :label, class: 'form-control-label'
	343	+ b.wrapper tag: 'div', class: 'd-flex flex-row justify-content-between align-items-center' do \|ba\|
	344	+ ba.use :input, class: 'custom-select mx-1', error_class: 'is-invalid', valid_class: 'is-valid'
	345	+ end
	346	+ b.use :full_error, wrap_with: { tag: 'div', class: 'invalid-feedback d-block' }
	347	+ b.use :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
	348	+ end
	349	+
	350	+ # custom range input
	351	+ config.wrappers :custom_range, tag: 'div', class: 'form-group', error_class: 'form-group-invalid', valid_class: 'form-group-valid' do \|b\|
	352	+ b.use :html5
	353	+ b.use :placeholder
	354	+ b.optional :readonly
	355	+ b.optional :step
	356	+ b.use :label, class: 'form-control-label'
	357	+ b.use :input, class: 'custom-range', error_class: 'is-invalid', valid_class: 'is-valid'
	358	+ b.use :full_error, wrap_with: { tag: 'div', class: 'invalid-feedback d-block' }
	359	+ b.use :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
	360	+ end
	361	+
	362	+
	363	+ # Input Group - custom component
	364	+ # see example app and config at https://github.com/rafaelfranca/simple_form-bootstrap
	365	+ # config.wrappers :input_group, tag: 'div', class: 'form-group', error_class: 'form-group-invalid', valid_class: 'form-group-valid' do \|b\|
	366	+ # b.use :html5
	367	+ # b.use :placeholder
	368	+ # b.optional :maxlength
	369	+ # b.optional :minlength
	370	+ # b.optional :pattern
	371	+ # b.optional :min_max
	372	+ # b.optional :readonly
	373	+ # b.use :label, class: 'form-control-label'
	374	+ # b.wrapper :input_group_tag, tag: 'div', class: 'input-group' do \|ba\|
	375	+ # ba.optional :prepend
	376	+ # ba.use :input, class: 'form-control', error_class: 'is-invalid', valid_class: 'is-valid'
	377	+ # ba.optional :append
	378	+ # end
	379	+ # b.use :full_error, wrap_with: { tag: 'div', class: 'invalid-feedback d-block' }
	380	+ # b.use :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
	381	+ # end
	382	+
	383	+
	384	+ # Floating Labels form
	385	+ #
	386	+ # floating labels default_wrapper
	387	+ config.wrappers :floating_labels_form, tag: 'div', class: 'form-label-group', error_class: 'form-group-invalid', valid_class: 'form-group-valid' do \|b\|
	388	+ b.use :html5
	389	+ b.use :placeholder
	390	+ b.optional :maxlength
	391	+ b.optional :minlength
	392	+ b.optional :pattern
	393	+ b.optional :min_max
	394	+ b.optional :readonly
	395	+ b.use :input, class: 'form-control', error_class: 'is-invalid', valid_class: 'is-valid'
	396	+ b.use :label, class: 'form-control-label'
	397	+ b.use :full_error, wrap_with: { tag: 'div', class: 'invalid-feedback' }
	398	+ b.use :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
	399	+ end
	400	+
	401	+ # custom multi select
	402	+ config.wrappers :floating_labels_select, tag: 'div', class: 'form-label-group', error_class: 'form-group-invalid', valid_class: 'form-group-valid' do \|b\|
	403	+ b.use :html5
	404	+ b.optional :readonly
	405	+ b.use :input, class: 'custom-select custom-select-lg', error_class: 'is-invalid', valid_class: 'is-valid'
	406	+ b.use :label, class: 'form-control-label'
	407	+ b.use :full_error, wrap_with: { tag: 'div', class: 'invalid-feedback' }
	408	+ b.use :hint, wrap_with: { tag: 'small', class: 'form-text text-muted' }
	409	+ end
	410	+
	411	+
	412	+ # The default wrapper to be used by the FormBuilder.
	413	+ config.default_wrapper = :vertical_form
	414	+
	415	+ # Custom wrappers for input types. This should be a hash containing an input
	416	+ # type as key and the wrapper that will be used for all inputs with specified type.
	417	+ config.wrapper_mappings = {
	418	+ boolean: :vertical_boolean,
	419	+ check_boxes: :vertical_collection,
	420	+ date: :vertical_multi_select,
	421	+ datetime: :vertical_multi_select,
	422	+ file: :vertical_file,
	423	+ radio_buttons: :vertical_collection,
	424	+ range: :vertical_range,
	425	+ time: :vertical_multi_select
	426	+ }
	427	+
	428	+ # enable custom form wrappers
	429	+ # config.wrapper_mappings = {
	430	+ # boolean: :custom_boolean,
	431	+ # check_boxes: :custom_collection,
	432	+ # date: :custom_multi_select,
	433	+ # datetime: :custom_multi_select,
	434	+ # file: :custom_file,
	435	+ # radio_buttons: :custom_collection,
	436	+ # range: :custom_range,
	437	+ # time: :custom_multi_select
	438	+ # }
	439	+ end

config/locales/simple_form.en.yml created 644 ¶ +31

@@ -0,0 +1,31
	1	+ en:
	2	+ simple_form:
	3	+ "yes": 'Yes'
	4	+ "no": 'No'
	5	+ required:
	6	+ text: 'required'
	7	+ mark: '*'
	8	+ # You can uncomment the line below if you need to overwrite the whole required html.
	9	+ # When using html, text and mark won't be used.
	10	+ # html: '<abbr title="required">*</abbr>'
	11	+ error_notification:
	12	+ default_message: "Please review the problems below:"
	13	+ # Examples
	14	+ # labels:
	15	+ # defaults:
	16	+ # password: 'Password'
	17	+ # user:
	18	+ # new:
	19	+ # email: 'E-mail to sign in.'
	20	+ # edit:
	21	+ # email: 'E-mail.'
	22	+ # hints:
	23	+ # defaults:
	24	+ # username: 'User name to sign in.'
	25	+ # password: 'No special characters, please.'
	26	+ # include_blanks:
	27	+ # defaults:
	28	+ # age: 'Rather not say'
	29	+ # prompts:
	30	+ # defaults:
	31	+ # age: 'Select your age'

lib/templates/haml/scaffold/_form.html.haml created 644 ¶ +12

@@ -0,0 +1,12
	1	+ -# frozen_string_literal: true
	2	+ = simple_form_for(@<%= singular_table_name %>) do \|f\|
	3	+ = f.error_notification
	4	+ = f.error_notification message: f.object.errors[:base].to_sentence if f.object.errors[:base].present?
	5	+
	6	+ .form-inputs
	7	+ <%- attributes.each do \|attribute\| -%>
	8	+ = f.<%= attribute.reference? ? :association : :input %> :<%= attribute.name %>
	9	+ <%- end -%>
	10	+
	11	+ .form-actions
	12	+ = f.button :submit

test/application_system_test_case.rb created 644 ¶ +5

@@ -0,0 +1,5
	1	+ require "test_helper"
	2	+
	3	+ class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
	4	+ driven_by :selenium, using: :chrome, screen_size: [1400, 1400]
	5	+ end

test/system/announcements_test.rb created 644 ¶ +37

@@ -0,0 +1,37
	1	+ require "application_system_test_case"
	2	+
	3	+ class AnnouncementsTest < ApplicationSystemTestCase
	4	+ test "add new announcement" do
	5	+ visit root_path
	6	+ fill_in "Login", with: "admin"
	7	+ fill_in "Password", with: "admin"
	8	+ click_on "Login"
	9	+
	10	+ assert_text "MAIN"
	11	+ assert_text "Submission"
	12	+
	13	+ within :css, 'header' do
	14	+ click_on "Manage"
	15	+ click_on "Announcements"
	16	+ end
	17	+ assert_text "+ Add announcement"
	18	+
	19	+ click_on "Add announcement", match: :first
	20	+
	21	+ fill_in 'Title', with: 'test'
	22	+ fill_in 'Body', with: 'test body 12345'
	23	+ check 'Published'
	24	+
	25	+ click_on 'Create'
	26	+
	27	+ visit list_main_path
	28	+
	29	+ assert_text "test body 12345"
	30	+
	31	+ end
	32	+ # test "visiting the index" do
	33	+ # visit announcements_url
	34	+ #
	35	+ # assert_selector "h1", text: "Announcement"
	36	+ # end
	37	+ end

Gemfile ¶ +1

               source 'https://rubygems.org'
               git_source(:github) { |repo| "https://github.com/#{repo}.git" }
               #rails
               gem 'rails', '~>5.2'
               gem 'activerecord-session_store'
               gem 'puma'
               # Reduces boot times through caching; required in config/boot.rb
               gem 'bootsnap', '>= 1.1.0', require: false
               # Bundle edge Rails instead:
               # gem 'rails', :git => 'git://github.com/rails/rails.git'
               #---------------- database ---------------------
               #the database
               gem 'mysql2'
               #for testing
               gem 'sqlite3'
               gem 'rails-controller-testing'
               #for dumping database into yaml
               gem 'yaml_db'
               #------------- assset pipeline -----------------
               # Gems used only for assets and not required
               # in production environments by default.
               #sass-rails is depricated
               #gem 'sass-rails'
               gem 'sassc-rails'
               gem 'coffee-rails'
                 # See https://github.com/sstephenson/execjs#readme for more supported runtimes
                 # gem 'therubyracer', :platforms => :ruby
               gem 'uglifier'
               gem 'haml'
               gem 'haml-rails'
               # Turbolinks makes navigating your web application faster. Read more: https://github.com/turbolinks/turbolinks
               #gem 'turbolinks', '~> 5'
               # Build JSON APIs with ease. Read more: https://github.com/rails/jbuilder
               gem 'jbuilder', '~> 2.5'
               #in-place editor
               gem 'best_in_place', '~> 3.0.1'
               # jquery addition
               gem 'jquery-rails'
               gem 'jquery-ui-rails'
               gem 'jquery-timepicker-addon-rails'
               gem 'jquery-tablesorter'
               gem 'jquery-countdown-rails'
               #syntax highlighter
               gem 'rouge'
               #bootstrap add-ons
               gem 'bootstrap-sass', '~> 3.4.1'
               gem 'bootstrap-switch-rails'
               gem 'bootstrap-toggle-rails'
               gem 'autoprefixer-rails'
               gem 'momentjs-rails'
               gem 'rails_bootstrap_sortable'
               gem 'bootstrap-datepicker-rails'
               gem 'bootstrap3-datetimepicker-rails'
               gem 'jquery-datatables-rails'
               #----------- user interface -----------------
+            + gem 'simple_form'
               #select 2
               gem 'select2-rails'
               #ace editor
               gem 'ace-rails-ap'
               #paginator
               gem 'will_paginate', '~> 3.0.7'
               gem 'mail'
               gem 'rdiscount'
               gem 'dynamic_form'
               gem 'in_place_editing'
               #gem 'verification', :git => 'https://github.com/sikachu/verification.git'
               #---------------- testiing -----------------------
               gem 'minitest-reporters'
               #---------------- for console --------------------
               gem 'fuzzy-string-match'
               group :development, :test do
                 # Call 'byebug' anywhere in the code to stop execution and get a debugger console
                 gem 'byebug', platforms: [:mri, :mingw, :x64_mingw]
               end
               group :development do
                 # Access an interactive console on exception pages or by calling 'console' anywhere in the code.
                 gem 'web-console', '>= 3.3.0'
                 gem 'listen', '>= 3.0.5', '< 3.2'
                 # Spring speeds up development by keeping your application running in the background. Read more: https://github.com/rails/spring
                 gem 'spring'
                 gem 'spring-watcher-listen', '~> 2.0.0'
               end
               group :test do
                 # Adds support for Capybara system testing and selenium driver
                 gem 'capybara', '>= 2.15'
                 gem 'selenium-webdriver'
                 # Easy installation and use of chromedriver to run system tests with Chrome
                 #gem 'chromedriver-helper'
                 gem 'webdriver'
               end

Gemfile.lock ¶ +4

                     i18n (>= 0.7, < 2)
                     minitest (~> 5.1)
                     tzinfo (~> 1.1)
                   addressable (2.6.0)
                     public_suffix (>= 2.0.2, < 4.0)
                   ansi (1.5.0)
                   arel (9.0.0)
                   autoprefixer-rails (9.5.1.1)
                     execjs
                   best_in_place (3.0.3)
                     actionpack (>= 3.2)
                     railties (>= 3.2)
                   bindex (0.7.0)
                   bootsnap (1.4.4)
                     msgpack (~> 1.0)
                   bootstrap-datepicker-rails (1.8.0.1)
                     railties (>= 3.0)
                   bootstrap-sass (3.4.1)
                     autoprefixer-rails (>= 5.2.1)
                     sassc (>= 2.0.0)
                   bootstrap-switch-rails (3.3.4)
                   bootstrap-toggle-rails (2.2.1.0)
                   bootstrap3-datetimepicker-rails (4.17.47)
                     momentjs-rails (>= 2.8.1)
                   builder (3.2.3)
                   byebug (11.0.1)
                   capybara (3.25.0)
                     addressable
                     mini_mime (>= 0.1.3)
                     nokogiri (~> 1.8)
                     rack (>= 1.6.0)
                     rack-test (>= 0.6.3)
                     regexp_parser (~> 1.5)
                     xpath (~> 3.2)
                   childprocess (1.0.1)
                     rake (< 13.0)
                   coffee-rails (4.2.2)
                     coffee-script (>= 2.2.0)
                     railties (>= 4.0.0)
                   coffee-script (2.4.1)
                     coffee-script-source
                     execjs
                   coffee-script-source (1.12.2)
                   concurrent-ruby (1.1.5)
                   crass (1.0.4)
                   dynamic_form (1.1.4)
                   erubi (1.8.0)
                   erubis (2.7.0)
                   execjs (2.7.0)
                   ffi (1.11.1)
                   fuzzy-string-match (1.0.1)
                     RubyInline (>= 3.8.6)
                   globalid (0.4.2)
                     activesupport (>= 4.2.0)
                   haml (5.1.0)
                     temple (>= 0.8.0)
                     tilt
                   haml-rails (1.0.0)
                     actionpack (>= 4.0.1)
                     activesupport (>= 4.0.1)
                     haml (>= 4.0.6, < 6.0)
                     html2haml (>= 1.0.1)
                     railties (>= 4.0.1)
                   html2haml (2.2.0)
                     erubis (~> 2.7.0)
                     haml (>= 4.0, < 6)
                     nokogiri (>= 1.6.0)
                     ruby_parser (~> 3.5)
                   i18n (1.6.0)
                     concurrent-ruby (~> 1.0)
                   in_place_editing (1.2.0)
                   jbuilder (2.9.1)
                     activesupport (>= 4.2.0)
                   jquery-countdown-rails (2.0.2)
                   jquery-datatables-rails (3.4.0)
                     actionpack (>= 3.1)
                     jquery-rails
                     railties (>= 3.1)
                     sass-rails
                   jquery-rails (4.3.3)
                     rails-dom-testing (>= 1, < 3)
                     railties (>= 4.2.0)
                     thor (>= 0.14, < 2.0)
                   jquery-tablesorter (1.26.1)
                     railties (>= 3.2, < 6)
                   jquery-timepicker-addon-rails (1.4.1)
                     railties (>= 3.1)
                   jquery-ui-rails (6.0.1)
                     railties (>= 3.2.16)
                   listen (3.1.5)
                     rb-fsevent (~> 0.9, >= 0.9.4)
                     rb-inotify (~> 0.9, >= 0.9.7)
                     ruby_dep (~> 1.2)
                   loofah (2.2.3)
                     crass (~> 1.0.2)
                     nokogiri (>= 1.5.9)
                   mail (2.7.1)
                     mini_mime (>= 0.1.1)
                   marcel (0.3.3)
                     mimemagic (~> 0.3.2)
                   method_source (0.9.2)
                   mimemagic (0.3.3)
                   mini_mime (1.0.1)
                   mini_portile2 (2.4.0)
                   minitest (5.11.3)
                   minitest-reporters (1.3.6)
                     ansi
                     builder
                     minitest (>= 5.0)
                     ruby-progressbar
                   momentjs-rails (2.20.1)
                     railties (>= 3.1)
                   msgpack (1.3.0)
                   multi_json (1.13.1)
                   mysql2 (0.5.2)
                   nio4r (2.3.1)
                   nokogiri (1.10.3)
                     mini_portile2 (~> 2.4.0)
                   public_suffix (3.1.1)
                   puma (4.0.0)
                     nio4r (~> 2.0)
                   rack (2.0.7)
                   rack-test (1.1.0)
                     rack (>= 1.0, < 3)
                   rails (5.2.3)
                     actioncable (= 5.2.3)
                     actionmailer (= 5.2.3)
                     actionpack (= 5.2.3)
                     actionview (= 5.2.3)
                     activejob (= 5.2.3)
                     activemodel (= 5.2.3)
                     activerecord (= 5.2.3)
                     activestorage (= 5.2.3)
                     activesupport (= 5.2.3)
                     bundler (>= 1.3.0)
                     railties (= 5.2.3)
                     sprockets-rails (>= 2.0.0)
                   rails-controller-testing (1.0.4)
                     actionpack (>= 5.0.1.x)
                     actionview (>= 5.0.1.x)
                     activesupport (>= 5.0.1.x)
                   rails-dom-testing (2.0.3)
                     activesupport (>= 4.2.0)
                     nokogiri (>= 1.6)
                   rails-html-sanitizer (1.0.4)
                     loofah (~> 2.2, >= 2.2.2)
                   rails_bootstrap_sortable (2.0.6)
                     momentjs-rails (>= 2.8.3)
                   railties (5.2.3)
                     actionpack (= 5.2.3)
                     activesupport (= 5.2.3)
                     method_source
                     rake (>= 0.8.7)
                     thor (>= 0.19.0, < 2.0)
                   rake (12.3.2)
                   rb-fsevent (0.10.3)
                   rb-inotify (0.10.0)
                     ffi (~> 1.0)
                   rdiscount (2.2.0.1)
                   regexp_parser (1.5.1)
                   rouge (3.3.0)
                   ruby-progressbar (1.10.0)
                   ruby_dep (1.5.0)
                   ruby_parser (3.13.1)
                     sexp_processor (~> 4.9)
                   rubyzip (1.2.3)
                   sass (3.7.4)
                     sass-listen (~> 4.0.0)
                   sass-listen (4.0.0)
                     rb-fsevent (~> 0.9, >= 0.9.4)
                     rb-inotify (~> 0.9, >= 0.9.7)
                   sass-rails (5.0.7)
                     railties (>= 4.0.0, < 6)
                     sass (~> 3.1)
                     sprockets (>= 2.8, < 4.0)
                     sprockets-rails (>= 2.0, < 4.0)
                     tilt (>= 1.1, < 3)
                   sassc (2.0.1)
                     ffi (~> 1.9)
                     rake
                   sassc-rails (2.1.1)
                     railties (>= 4.0.0)
                     sassc (>= 2.0)
                     sprockets (> 3.0)
                     sprockets-rails
                     tilt
                   select2-rails (4.0.3)
                     thor (~> 0.14)
                   selenium-webdriver (3.142.3)
                     childprocess (>= 0.5, < 2.0)
                     rubyzip (~> 1.2, >= 1.2.2)
                   sexp_processor (4.12.0)
+            +     simple_form (4.1.0)
+            +       actionpack (>= 5.0)
+            +       activemodel (>= 5.0)
                   spring (2.1.0)
                   spring-watcher-listen (2.0.1)
                     listen (>= 2.7, < 4.0)
                     spring (>= 1.2, < 3.0)
                   sprockets (3.7.2)
                     concurrent-ruby (~> 1.0)
                     rack (> 1, < 3)
                   sprockets-rails (3.2.1)
                     actionpack (>= 4.0)
                     activesupport (>= 4.0)
                     sprockets (>= 3.0.0)
                   sqlite3 (1.4.1)
                   temple (0.8.1)
                   thor (0.20.3)
                   thread_safe (0.3.6)
                   tilt (2.0.9)
                   tzinfo (1.2.5)
                     thread_safe (~> 0.1)
                   uglifier (4.1.20)
                     execjs (>= 0.3.0, < 3)
                   web-console (3.7.0)
                     actionview (>= 5.0)
                     activemodel (>= 5.0)
                     bindex (>= 0.4.0)
                     railties (>= 5.0)
                   webdriver (0.1.0)
                   websocket-driver (0.7.1)
                     websocket-extensions (>= 0.1.0)
                   websocket-extensions (0.1.4)
                   will_paginate (3.0.12)
                   xpath (3.2.0)
                     nokogiri (~> 1.8)
                   yaml_db (0.7.0)
                     rails (>= 3.0)
                     rake (>= 0.8.7)
               PLATFORMS
                 ruby
               DEPENDENCIES
                 ace-rails-ap
                 activerecord-session_store
                 autoprefixer-rails
                 best_in_place (~> 3.0.1)
                 bootsnap (>= 1.1.0)
                 bootstrap-datepicker-rails
                 bootstrap-sass (~> 3.4.1)
                 bootstrap-switch-rails
                 bootstrap-toggle-rails
                 bootstrap3-datetimepicker-rails
                 byebug
                 capybara (>= 2.15)
                 coffee-rails
                 dynamic_form
                 fuzzy-string-match
                 haml
                 haml-rails
                 in_place_editing
                 jbuilder (~> 2.5)
                 jquery-countdown-rails
                 jquery-datatables-rails
                 jquery-rails
                 jquery-tablesorter
                 jquery-timepicker-addon-rails
                 jquery-ui-rails
                 listen (>= 3.0.5, < 3.2)
                 mail
                 minitest-reporters
                 momentjs-rails
                 mysql2
                 puma
                 rails (~> 5.2)
                 rails-controller-testing
                 rails_bootstrap_sortable
                 rdiscount
                 rouge
                 sassc-rails
                 select2-rails
                 selenium-webdriver
+            +   simple_form
                 spring
                 spring-watcher-listen (~> 2.0.0)
                 sqlite3
                 uglifier
                 web-console (>= 3.3.0)
                 webdriver
                 will_paginate (~> 3.0.7)
                 yaml_db
               BUNDLED WITH
 .17.2

app/controllers/graders_controller.rb ¶ -7

               class GradersController < ApplicationController
                 before_action :admin_authorization
-            -   verify :method => :post, :only => ['clear_all',
-            -                                      'start_exam',
-            -                                      'start_grading',
-            -                                      'stop_all',
-            -                                      'clear_terminated'],
-            -          :redirect_to => {:action => 'index'}
                 def index
                   redirect_to :action => 'list'
                 end
                 def list
                   @grader_processes = GraderProcess.find_running_graders
                   @stalled_processes = GraderProcess.find_stalled_process
                   @terminated_processes = GraderProcess.find_terminated_graders
                   @last_task = Task.last
                   @last_test_request = TestRequest.last
                   @submission = Submission.order("id desc").limit(20)
                   @backlog_submission = Submission.where('graded_at is null')
                 end
                 def clear
                   grader_proc = GraderProcess.find(params[:id])
                   grader_proc.destroy if grader_proc!=nil
                   redirect_to :action => 'list'
                 end
                 def clear_terminated
                   GraderProcess.find_terminated_graders.each do |p|
                     p.destroy
                   end
                   redirect_to :action => 'list'
                 end
                 def clear_all
                   GraderProcess.all.each do |p|
                     p.destroy
                   end
                   redirect_to :action => 'list'
                 end
                 def view
                   if params[:type]=='Task'
                     redirect_to :action => 'task', :id => params[:id]
                   else
                     redirect_to :action => 'test_request', :id => params[:id]
                   end
                 end
                 def test_request
                   @test_request = TestRequest.find(params[:id])
                 end
                 def task
                   @task = Task.find(params[:id])
                 end
                 # various grader controls
                 def stop
                   grader_proc = GraderProcess.find(params[:id])
                   GraderScript.stop_grader(grader_proc.pid)
                   flash[:notice] = 'Grader stopped.  It may not disappear now, but it should disappear shortly.'
                   redirect_to :action => 'list'
                 end
                 def stop_all
                   GraderScript.stop_graders(GraderProcess.find_running_graders +
                                             GraderProcess.find_stalled_process)
                   flash[:notice] = 'Graders stopped.  They may not disappear now, but they should disappear shortly.'
                   redirect_to :action => 'list'
                 end
                 def start_grading
                   GraderScript.start_grader('grading')
                   flash[:notice] = '2 graders in grading env started, one for grading queue tasks, another for grading test request'
                   redirect_to :action => 'list'
                 end
                 def start_exam
                   GraderScript.start_grader('exam')
                   flash[:notice] = '2 graders in grading env started, one for grading queue tasks, another for grading test request'
                   redirect_to :action => 'list'
                 end
               end

app/controllers/main_controller.rb ¶ -9

               class MainController < ApplicationController
                 before_action :authenticate, :except => [:index, :login]
                 before_action :check_viewability, :except => [:index, :login]
                 append_before_action :confirm_and_update_start_time,
                                      :except => [:index,
                                                  :login,
                                                  :confirm_contest_start]
                 # to prevent log in box to be shown when user logged out of the
                 # system only in some tab
                 prepend_before_action :reject_announcement_refresh_when_logged_out,
                                       :only => [:announcements]
                 before_action :authenticate_by_ip_address, :only => [:list]
-            -   # COMMENTED OUT: filter in each action instead
-            -   # before_filter :verify_time_limit, :only => [:submit]
-            -   verify :method => :post, :only => [:submit],
-            -          :redirect_to => { :action => :index }
-            -   # COMMENT OUT: only need when having high load
-            -   # caches_action :index, :login
                 # NOTE: This method is not actually needed, 'config/routes.rb' has
                 # assigned action login as a default action.
                 def index
                   redirect_to :action => 'login'
                 end
                 def login
                   saved_notice = flash[:notice]
                   reset_session
                   flash.now[:notice] = saved_notice
                   # EXPERIMENT:
                   # Hide login if in single user mode and the url does not
                   # explicitly specify /login
                   #
                   # logger.info "PATH: #{request.path}"
                   # if GraderConfiguration['system.single_user_mode'] and
                   #     request.path!='/main/login'
                   #   @hidelogin = true
                   # end
                   @announcements = Announcement.frontpage
                   render :action => 'login', :layout => 'empty'
                 end
                 def list
                   prepare_list_information
                 end
                 def help
                   @user = User.find(session[:user_id])
                 end
                 def submit
                   user = User.find(session[:user_id])
                   @submission = Submission.new
                   @submission.problem_id = params[:submission][:problem_id]
                   @submission.user = user
                   @submission.language_id = 0
                   if (params['file']) and (params['file']!='')
                     @submission.source = File.open(params['file'].path,'r:UTF-8',&:read)
                     @submission.source.encode!('UTF-8','UTF-8',invalid: :replace, replace: '')
                     @submission.source_filename = params['file'].original_filename
                   end
                   if (params[:editor_text])
                     language = Language.find_by_id(params[:language_id])
                     @submission.source = params[:editor_text]
                     @submission.source_filename = "live_edit.#{language.ext}"
                     @submission.language = language
                   end
                   @submission.submitted_at = Time.new.gmtime
                   @submission.ip_address = request.remote_ip
                   if GraderConfiguration.time_limit_mode? and user.contest_finished?
                     @submission.errors.add(:base,"The contest is over.")
                     prepare_list_information
                     render :action => 'list' and return
                   end
                   if @submission.valid?(@current_user)
                     if @submission.save == false
                       flash[:notice] = 'Error saving your submission'
                     elsif Task.create(:submission_id => @submission.id,
                                       :status => Task::STATUS_INQUEUE) == false
                       flash[:notice] = 'Error adding your submission to task queue'
                     end
                   else
                     prepare_list_information
                     render :action => 'list' and return
                   end
                   redirect_to edit_submission_path(@submission)
                 end
                 def source
                   submission = Submission.find(params[:id])
                   if ((submission.user_id == session[:user_id]) and
                       (submission.problem != nil) and
                       (submission.problem.available))
                     send_data(submission.source,
                               {:filename => submission.download_filename,
                                 :type => 'text/plain'})
                   else
                     flash[:notice] = 'Error viewing source'
                     redirect_to :action => 'list'
                   end
                 end
                 def compiler_msg
                   @submission = Submission.find(params[:id])
                   if @submission.user_id == session[:user_id]
                     render :action => 'compiler_msg', :layout => 'empty'
                   else
                     flash[:notice] = 'Error viewing source'
                     redirect_to :action => 'list'
                   end
                 end
                 def result
                   if !GraderConfiguration.show_grading_result
                     redirect_to :action => 'list' and return
                   end
                   @user = User.find(session[:user_id])
                   @submission = Submission.find(params[:id])
                   if @submission.user!=@user
                     flash[:notice] = 'You are not allowed to view result of other users.'
                     redirect_to :action => 'list' and return
                   end
                   prepare_grading_result(@submission)
                 end
                 def load_output
                   if !GraderConfiguration.show_grading_result or params[:num]==nil
                     redirect_to :action => 'list' and return
                   end
                   @user = User.find(session[:user_id])
                   @submission = Submission.find(params[:id])
                   if @submission.user!=@user
                     flash[:notice] = 'You are not allowed to view result of other users.'
                     redirect_to :action => 'list' and return
                   end
                   case_num = params[:num].to_i
                   out_filename = output_filename(@user.login,
                                                  @submission.problem.name,
                                                  @submission.id,
                                                  case_num)
                   if !FileTest.exists?(out_filename)
                     flash[:notice] = 'Output not found.'
                     redirect_to :action => 'list' and return
                   end
                   if defined?(USE_APACHE_XSENDFILE) and USE_APACHE_XSENDFILE
                     response.headers['Content-Type'] = "application/force-download"
                     response.headers['Content-Disposition'] = "attachment; filename=\"output-#{case_num}.txt\""
                     response.headers["X-Sendfile"] = out_filename
                     response.headers['Content-length'] = File.size(out_filename)
                     render :nothing => true
                   else
                     send_file out_filename, :stream => false, :filename => "output-#{case_num}.txt", :type => "text/plain"
                   end
                 end
                 def error
                   @user = User.find(session[:user_id])
                 end
                 # announcement refreshing and hiding methods
                 def announcements
                   if params.has_key? 'recent'
                     prepare_announcements(params[:recent])
                   else
                     prepare_announcements
                   end
                   render(:partial => 'announcement',
                          :collection => @announcements,
                          :locals => {:announcement_effect => true})
                 end
                 def confirm_contest_start
                   user = User.find(session[:user_id])
                   if request.method == 'POST'
                     user.update_start_time
                     redirect_to :action => 'list'
                   else
                     @contests = user.contests
                     @user = user
                   end
                 end
                 protected
                 def prepare_announcements(recent=nil)
                   if GraderConfiguration.show_tasks_to?(@user)
                     @announcements = Announcement.published(true)
                   else
                     @announcements = Announcement.published
                   end
                   if recent!=nil
                     recent_id = recent.to_i
                     @announcements = @announcements.find_all { |a| a.id > recent_id }
                   end
                 end
                 def prepare_list_information
                   @user = User.find(session[:user_id])
                   if not GraderConfiguration.multicontests?
                     @problems = @user.available_problems
                   else
                     @contest_problems = @user.available_problems_group_by_contests

app/controllers/messages_controller.rb ¶ -2

               class MessagesController < ApplicationController
                 before_action :authenticate
-            -   verify :method => :post, :only => ['create'],
-            -          :redirect_to => { :action => 'list' }
                 before_filter :admin_authorization, :only => ['console','show',
                                                               'reply','hide','list_all']
                 def list
                   @user = User.find(session[:user_id])
                   @messages = Message.find_all_sent_by_user(@user)
                 end
                 def console
                   @user = User.find(session[:user_id])
                   @messages = Message.find_all_system_unreplied_messages
                 end
                 def show
                   @message = Message.find(params[:id])
                 end
                 def list_all
                   @user = User.find(session[:user_id])
                   @messages = Message.where(receiver_id: nil).order(:created_at)
                 end
                 def create
                   user = User.find(session[:user_id])
                   @message = Message.new(params[:message])
                   @message.sender = user
                   if @message.body == '' or !@message.save
                     flash[:notice] = 'An error occurred'
                   else
                     flash[:notice] = 'New message posted'
                   end
                   redirect_to :action => 'list'
                 end
                 def reply
                   user = User.find(session[:user_id])
                   @message = Message.new(params[:r_message])
                   @message.sender = user
                   if @message.body == '' or !@message.save
                     flash[:notice] = 'An error occurred'
                     redirect_to :action => 'show', :id => @message.replying_message_id
                   else
                     flash[:notice] = 'Message replied'
                     rep_msg = @message.replying_message
                     rep_msg.replied = true
                     rep_msg.save
                     redirect_to :action => 'console'
                   end
                 end
                 def hide
                   message = Message.find(params[:id])
                   message.replied = true
                   message.save
                   flash[:notice] = 'Message hidden (just marked replied)'
                   redirect_to :action => 'console'
                 end
                 protected
                 def build_replying_message_hierarchy(user)
                   @all_messages = {}
                   # manually build replies hierarchy (to improve efficiency)
                   [@messages, @replied_messages].each do |collection|
                     collection.each do |m|
                       @all_messages[m.id] = {:msg => m, :replies => []}
                     end
                   end
                   @all_messages.each do |m|
                     rep_id = m.replying_message_id
                     if @all_messages[rep_id]!=nil
                       @all_messages[rep_id][:replies] << m
                     end
                   end
                 end
               end

app/controllers/problems_controller.rb ¶ +1 -7

               class ProblemsController < ApplicationController
                 before_action :authenticate, :authorization
                 before_action :testcase_authorization, only: [:show_testcase]
                 in_place_edit_for :problem, :name
                 in_place_edit_for :problem, :full_name
                 in_place_edit_for :problem, :full_score
                 def index
                   @problems = Problem.order(date_added: :desc)
                 end
-            -   # GETs should be safe (see http://www.w3.org/2001/tag/doc/whenToUseGet.html)
-            -   verify :method => :post, :only => [ :create, :quick_create,
-            -                                       :do_manage,
-            -                                       :do_import,
-            -                                     ],
-            -          :redirect_to => { :action => :index }
                 def show
                   @problem = Problem.find(params[:id])
                 end
                 def new
                   @problem = Problem.new
                   @description = nil
                 end
                 def create
                   @problem = Problem.new(problem_params)
-            -     @description = Description.new(params[:description])
+            +     @description = Description.new(problem_params[:description])
                   if @description.body!=''
                     if !@description.save
                       render :action => new and return
                     end
                   else
                     @description = nil
                   end
                   @problem.description = @description
                   if @problem.save
                     flash[:notice] = 'Problem was successfully created.'
                     redirect_to action: :index
                   else
                     render :action => 'new'
                   end
                 end
                 def quick_create
                   @problem = Problem.new(problem_params)
                   @problem.full_name = @problem.name if @problem.full_name == ''
                   @problem.full_score = 100
                   @problem.available = false
                   @problem.test_allowed = true
                   @problem.output_only = false
                   @problem.date_added = Time.new
                   if @problem.save
                     flash[:notice] = 'Problem was successfully created.'
                     redirect_to action: :index
                   else
                     flash[:notice] = 'Error saving problem'
                   redirect_to action: :index
                   end
                 end
                 def edit
                   @problem = Problem.find(params[:id])
                   @description = @problem.description
                 end
                 def update
                   @problem = Problem.find(params[:id])
                   @description = @problem.description
                   if @description.nil? and params[:description][:body]!=''
                     @description = Description.new(params[:description])
                     if !@description.save
                       flash[:notice] = 'Error saving description'
                       render :action => 'edit' and return
                     end
                     @problem.description = @description
                   elsif @description
                     if !@description.update_attributes(params[:description])
                       flash[:notice] = 'Error saving description'
                       render :action => 'edit' and return
                     end
                   end
                   if params[:file] and params[:file].content_type != 'application/pdf'
                       flash[:notice] = 'Error: Uploaded file is not PDF'
                       render :action => 'edit' and return
                   end
                   if @problem.update_attributes(problem_params)
                     flash[:notice] = 'Problem was successfully updated.'
                     unless params[:file] == nil or params[:file] == ''
                       flash[:notice] = 'Problem was successfully updated and a new PDF file is uploaded.'
                       out_dirname = "#{Problem.download_file_basedir}/#{@problem.id}"
                       if not FileTest.exists? out_dirname
                         Dir.mkdir out_dirname
                       end
                       out_filename = "#{out_dirname}/#{@problem.name}.pdf"
                       if FileTest.exists? out_filename
                         File.delete out_filename
                       end
                       File.open(out_filename,"wb") do |file|
                         file.write(params[:file].read)
                       end
                       @problem.description_filename = "#{@problem.name}.pdf"
                       @problem.save
                     end
                     redirect_to :action => 'show', :id => @problem
                   else
                     render :action => 'edit'
                   end
                 end
                 def destroy
                   p = Problem.find(params[:id]).destroy
                   redirect_to action: :index
                 end
                 def toggle
                   @problem = Problem.find(params[:id])
                   @problem.update_attributes(available: !(@problem.available) )
                   respond_to do |format|
                     format.js { }
                   end
                 end
                 def toggle_test
                   @problem = Problem.find(params[:id])
                   @problem.update_attributes(test_allowed: !(@problem.test_allowed?) )
                   respond_to do |format|
                     format.js { }
                   end
                 end
                 def toggle_view_testcase
                   @problem = Problem.find(params[:id])
                   @problem.update_attributes(view_testcase: !(@problem.view_testcase?) )
                   respond_to do |format|
                     format.js { }
                   end
                 end
                 def turn_all_off
                   Problem.available.all.each do |problem|
                     problem.available = false
                     problem.save
                   end
                   redirect_to action: :index
                 end
                 def turn_all_on
                   Problem.where.not(available: true).each do |problem|
                     problem.available = true
                     problem.save
                   end
                   redirect_to action: :index
                 end
                 def stat
                   @problem = Problem.find(params[:id])
                   unless @problem.available or session[:admin]
                     redirect_to :controller => 'main', :action => 'list'
                     return
                   end
                   @submissions = Submission.includes(:user).includes(:language).where(problem_id: params[:id]).order(:user_id,:id)
                   #stat summary
                   range =65
                   @histogram = { data: Array.new(range,0), summary: {} }
                   user = Hash.new(0)
                   @submissions.find_each do |sub|
                     d = (DateTime.now.in_time_zone - sub.submitted_at) / 24 / 60 / 60
                     @histogram[:data][d.to_i] += 1 if d < range
                     user[sub.user_id] = [user[sub.user_id], ((sub.try(:points) || 0) >= @problem.full_score) ? 1 : 0].max
                   end
                   @histogram[:summary][:max] = [@histogram[:data].max,1].max
                   @summary = { attempt: user.count, solve: 0 }
                   user.each_value { |v| @summary[:solve] += 1 if v == 1 }
                 end
                 def manage
                   @problems = Problem.order(date_added: :desc)
                 end
                 def do_manage
                   if params.has_key? 'change_date_added' and params[:date_added].strip.empty? == false
                     change_date_added
                   elsif params.has_key? 'add_to_contest'
                     add_to_contest
                   elsif params.has_key? 'enable_problem'
                     set_available(true)
                   elsif params.has_key? 'disable_problem'
                     set_available(false)
                   elsif params.has_key? 'add_group'
                     group = Group.find(params[:group_id])
                     ok = []
                     failed = []
                     get_problems_from_params.each do |p|
                       begin
                         group.problems << p
                         ok << p.full_name
                       rescue => e
                         failed << p.full_name
                       end
                     end
                     flash[:success] = "The following problems are added to the group #{group.name}: " + ok.join(', ') if ok.count > 0
                     flash[:alert] = "The following problems are already in the group #{group.name}: " + failed.join(', ') if failed.count > 0
                   elsif params.has_key? 'add_tags'
                     get_problems_from_params.each do |p|
                       p.tag_ids += params[:tag_ids]
                     end
                   end
                   redirect_to :action => 'manage'
                 end
                 def import
                   @allow_test_pair_import = allow_test_pair_import?
                 end

app/controllers/test_controller.rb ¶ -7

               class TestController < ApplicationController
                 before_action :authenticate, :check_viewability
-            - #
-            - #  COMMENT OUT: filter in each action instead
-            - #
-            - #  before_filter :verify_time_limit, :only => [:submit]
-            -   verify :method => :post, :only => [:submit],
-            -          :redirect_to => { :action => :index }
                 def index
                   prepare_index_information
                 end
                 def submit
                   @user = User.find(session[:user_id])
                   @submitted_test_request = TestRequest.new_from_form_params(@user,params[:test_request])
                   if ! @submitted_test_request.errors.empty?
                     prepare_index_information
                     render :action => 'index' and return
                   end
                   if GraderConfiguration.time_limit_mode?
                     if @user.contest_finished?
                       @submitted_test_request.errors.add(:base,'Contest is over.')
                       prepare_index_information
                       render :action => 'index' and return
                     end
                     if !GraderConfiguration.allow_test_request(@user)
                       prepare_index_information
                       flash[:notice] = 'Test request is not allowed during the last 30 minutes'
                       redirect_to :action => 'index' and return
                     end
                   end
                   if @submitted_test_request.save
                     redirect_to :action => 'index'
                   else
                     prepare_index_information
                     render :action => 'index'
                   end
                 end
                 def read
                   user = User.find(session[:user_id])
                   begin
                     test_request = TestRequest.find(params[:id])
                   rescue
                     test_request = nil
                   end
                   if test_request==nil or test_request.user_id != user.id
                     flash[:notice] = 'Invalid output'
                     redirect_to :action => 'index'
                     return
                   end
                   if test_request.output_file_name!=nil
                     data = File.open(test_request.output_file_name).read(2048)
                     if data==nil
                       data=""
                     end
                     send_data(data,
                               {:filename => 'output.txt',
                                 :type => 'text/plain'})
                     return
                   end
                   redirect_to :action => 'index'
                 end
                 def result
                   @user = User.find(session[:user_id])
                   begin
                     @test_request = TestRequest.find(params[:id])
                   rescue
                     @test_request = nil
                   end
                   if @test_request==nil or @test_request.user_id != @user.id
                     flash[:notice] = 'Invalid request'
                     redirect_to :action => 'index'
                     return
                   end
                 end
                 protected
                 def prepare_index_information
                   @user = User.find(session[:user_id])
                   @submissions = Submission.find_last_for_all_available_problems(@user.id)
                   all_problems = @submissions.collect { |submission| submission.problem }
                   @problems = []
                   all_problems.each do |problem|
                     if problem.test_allowed
                       @problems << problem
                     end
                   end
                   @test_requests = []
                   @user.test_requests.each do |ts|
                     if ts.problem and ts.problem.available
                       @test_requests << ts
                     end
                   end
                 end
                 def check_viewability
                   user = User.find(session[:user_id])
                   if !GraderConfiguration.show_tasks_to?(user)
                     redirect_to :controller => 'main', :action => 'list'
                   end
                   if (!GraderConfiguration.show_submitbox_to?(user)) and (action_name=='submit')
                     redirect_to :controller => 'test', :action => 'index'
                   end
                 end
               end

app/controllers/user_admin_controller.rb ¶ -9

               require 'csv'
               class UserAdminController < ApplicationController
                 include MailHelperMethods
                 before_action :admin_authorization
-            -   # GETs should be safe (see http://www.w3.org/2001/tag/doc/whenToUseGet.html)
-            -   verify :method => :post, :only => [
-            -                                       :create, :create_from_list,
-            -                                       :update,
-            -                                       :manage_contest,
-            -                                       :bulk_mail
-            -                                     ],
-            -          :redirect_to => { :action => :list }
                 def index
                   @user_count = User.count
                   if params[:page] == 'all'
                     @users = User.all
                     @paginated = false
                   else
                     @users = User.paginate :page => params[:page]
                     @paginated = true
                   end
                   @users = User.all
                   @hidden_columns = ['hashed_password', 'salt', 'created_at', 'updated_at']
                   @contests = Contest.enabled
                 end
                 def active
                   sessions = ActiveRecord::SessionStore::Session.where("updated_at >= ?", 60.minutes.ago)
                   @users = []
                   sessions.each do |session|
                     if session.data[:user_id]
                       @users << User.find(session.data[:user_id])
                     end
                   end
                 end
                 def show
                   @user = User.find(params[:id])
                 end
                 def new
                   @user = User.new
                 end
                 def create
                   @user = User.new(user_params)
                   @user.activated = true
                   if @user.save
                     flash[:notice] = 'User was successfully created.'
                     redirect_to :action => 'index'
                   else
                     render :action => 'new'
                   end
                 end
                 def clear_last_ip
                   @user = User.find(params[:id])
                   @user.last_ip = nil
                   @user.save
                   redirect_to action: 'index', page: params[:page]
                 end
                 def create_from_list
                   lines = params[:user_list]
                   note = []
                   lines.split("\n").each do |line|
                     items = line.chomp.split(',')
                     if items.length>=2
                       login = items[0]
                       full_name = items[1]
                       remark =''
                       user_alias = ''
                       added_random_password = false
                       if items.length >= 3 and items[2].chomp(" ").length > 0;
                         password = items[2].chomp(" ")
                       else
                         password = random_password
                         add_random_password=true;
                       end
                       if items.length>= 4 and items[3].chomp(" ").length > 0;
                         user_alias = items[3].chomp(" ")
                       else
                         user_alias = login
                       end
                       if items.length>=5
                         remark = items[4].strip;
                       end
                       user = User.find_by_login(login)
                       if (user)
                         user.full_name = full_name
                         user.password = password
                         user.remark = remark
                       else
                         user = User.new({:login => login,
                                           :full_name => full_name,
                                           :password => password,
                                           :password_confirmation => password,
                                           :alias => user_alias,
                                           :remark => remark})
                       end
                       user.activated = true
                       user.save
                       if added_random_password
                         note << "'#{login}' (+)"
                       else
                         note << login
                       end
                     end
                   end
                   flash[:success] = 'User(s) ' + note.join(', ') +
                     ' were successfully created.  ' +
                     '( (+) - created with random passwords.)'
                   redirect_to :action => 'index'
                 end
                 def edit
                   @user = User.find(params[:id])
                 end
                 def update
                   @user = User.find(params[:id])
                   if @user.update_attributes(user_params)
                     flash[:notice] = 'User was successfully updated.'
                     redirect_to :action => 'show', :id => @user
                   else
                     render :action => 'edit'
                   end
                 end
                 def destroy
                   User.find(params[:id]).destroy
                   redirect_to :action => 'index'
                 end
                 def user_stat
                   if params[:commit] == 'download csv'
                     @problems = Problem.all
                   else
                     @problems = Problem.available_problems
                   end
                   @users = User.includes(:contests, :contest_stat).where(enabled: true)
                   @scorearray = Array.new
                   @users.each do |u|
                     ustat = Array.new
                     ustat[0] = u
                     @problems.each do |p|
                       sub = Submission.find_last_by_user_and_problem(u.id,p.id)
                       if (sub!=nil) and (sub.points!=nil) and p and p.full_score
                         ustat << [(sub.points.to_f*100/p.full_score).round, (sub.points>=p.full_score)]
                       else
                         ustat << [0,false]
                       end
                     end
                     @scorearray << ustat
                   end
                   if params[:commit] == 'download csv' then
                     csv = gen_csv_from_scorearray(@scorearray,@problems)
                     send_data csv, filename: 'last_score.csv'
                   else
                     render template: 'user_admin/user_stat'
                   end
                 end
                 def user_stat_max
                   if params[:commit] == 'download csv'
                     @problems = Problem.all
                   else
                     @problems = Problem.available_problems
                   end
                   @users = User.includes(:contests).includes(:contest_stat).all
                   @scorearray = Array.new
                   #set up range from param
                   since_id = params.fetch(:since_id, 0).to_i
                   until_id = params.fetch(:until_id, 0).to_i
                   @users.each do |u|
                     ustat = Array.new
                     ustat[0] = u
                     @problems.each do |p|
                       max_points = 0
                       Submission.find_in_range_by_user_and_problem(u.id,p.id,since_id,until_id).each do |sub|
                         max_points = sub.points if sub and sub.points and (sub.points > max_points)
                       end
                       ustat << [(max_points.to_f*100/p.full_score).round, (max_points>=p.full_score)]
                     end
                     @scorearray << ustat
                   end
                   if params[:commit] == 'download csv' then
                     csv = gen_csv_from_scorearray(@scorearray,@problems)
                     send_data csv, filename: 'max_score.csv'
                   else
                     render template: 'user_admin/user_stat'
                   end
                 end
                 def import
                   if params[:file]==''

app/controllers/users_controller.rb ¶ -3

               require 'net/smtp'
               class UsersController < ApplicationController
                 include MailHelperMethods
                 before_action :authenticate, :except => [:new,
                                                          :register,
                                                          :confirm,
                                                          :forget,
                                                          :retrieve_password]
                 before_action :verify_online_registration, :only => [:new,
                                                                      :register,
                                                                      :forget,
                                                                      :retrieve_password]
                 before_action :authenticate, :profile_authorization, only: [:profile]
                 before_action :admin_authorization, only: [:stat, :toggle_activate, :toggle_enable]
-            -   verify :method => :post, :only => [:chg_passwd],
-            -          :redirect_to => { :action => :index }
                 #in_place_edit_for :user, :alias_for_editing
                 #in_place_edit_for :user, :email_for_editing
                 def index
                   if !GraderConfiguration['system.user_setting_enabled']
                     redirect_to :controller => 'main', :action => 'list'
                   else
                     @user = User.find(session[:user_id])
                   end
                 end
                 def chg_passwd
                   user = User.find(session[:user_id])
                   user.password = params[:passwd]
                   user.password_confirmation = params[:passwd_verify]
                   if user.save
                     flash[:notice] = 'password changed'
                   else
                     flash[:notice] = 'Error: password changing failed'
                   end
                   redirect_to :action => 'index'
                 end
                 def new
                   @user = User.new
                   render :action => 'new', :layout => 'empty'
                 end
                 def register
                   if(params[:cancel])
                     redirect_to :controller => 'main', :action => 'login'
                     return
                   end
                   @user = User.new(user_params)
                   @user.password_confirmation = @user.password = User.random_password
                   @user.activated = false
                   if (@user.valid?) and (@user.save)
                     if send_confirmation_email(@user)
                       render :action => 'new_splash', :layout => 'empty'
                     else
                       @admin_email = GraderConfiguration['system.admin_email']
                       render :action => 'email_error', :layout => 'empty'
                     end
                   else
                     @user.errors.add(:base,"Email cannot be blank") if @user.email==''
                     render :action => 'new', :layout => 'empty'
                   end
                 end
                 def confirm
                   login = params[:login]
                   key = params[:activation]
                   @user = User.find_by_login(login)
                   if (@user) and (@user.verify_activation_key(key))
                     if @user.valid?  # check uniquenss of email
                       @user.activated = true
                       @user.save
                       @result = :successful
                     else
                       @result = :email_used
                     end
                   else
                     @result = :failed
                   end
                   render :action => 'confirm', :layout => 'empty'
                 end
                 def forget
                   render :action => 'forget', :layout => 'empty'
                 end
                 def retrieve_password
                   email = params[:email]
                   user = User.find_by_email(email)
                   if user
                     last_updated_time = user.updated_at || user.created_at || (Time.now.gmtime - 1.hour)
                     if last_updated_time > Time.now.gmtime - 5.minutes
                       flash[:notice] = 'The account has recently created or new password has recently been requested.  Please wait for 5 minutes'
                     else
                       user.password = user.password_confirmation = User.random_password
                       user.save
                       send_new_password_email(user)
                       flash[:notice] = 'New password has been mailed to you.'
                     end
                   else
                     flash[:notice] = I18n.t 'registration.password_retrieval.no_email'
                   end
                   redirect_to :action => 'forget'
                 end
                 def stat
                   @user = User.find(params[:id])
                   @submission = Submission.joins(:problem).where(user_id: params[:id])
                   @submission = @submission.where('problems.available = true') unless current_user.admin?
                   range = 120
                   @histogram = { data: Array.new(range,0), summary: {} }
                   @summary = {count: 0, solve: 0, attempt: 0}
                   problem = Hash.new(0)
                   @submission.find_each do |sub|
                     #histogram
                     d = (DateTime.now.in_time_zone - sub.submitted_at) / 24 / 60 / 60
                     @histogram[:data][d.to_i] += 1 if d < range
                     @summary[:count] += 1
                     next unless sub.problem
                     problem[sub.problem] = [problem[sub.problem], ( (sub.try(:points) || 0) >= sub.problem.full_score) ? 1 : 0].max
                   end
                   @histogram[:summary][:max] = [@histogram[:data].max,1].max
                   @summary[:attempt] = problem.count
                   problem.each_value { |v| @summary[:solve] += 1 if v == 1 }
                 end
                 def toggle_activate
                   @user = User.find(params[:id])
                   @user.update_attributes( activated:  !@user.activated? )
                   respond_to do |format|
                     format.js { render partial: 'toggle_button',
                                 locals: {button_id: "#toggle_activate_user_#{@user.id}",button_on: @user.activated? } }
                   end
                 end
                 def toggle_enable
                   @user = User.find(params[:id])
                   @user.update_attributes( enabled:  !@user.enabled? )
                   respond_to do |format|
                     format.js { render partial: 'toggle_button',
                                 locals: {button_id: "#toggle_enable_user_#{@user.id}",button_on: @user.enabled? } }
                   end
                 end
                 protected
                 def verify_online_registration
                   if !GraderConfiguration['system.online_registration']
                     redirect_to :controller => 'main', :action => 'login'
                   end
                 end
                 def send_confirmation_email(user)
                   contest_name = GraderConfiguration['contest.name']
                   activation_url = url_for(:action => 'confirm',
                                            :login => user.login,
                                            :activation => user.activation_key)
                   home_url = url_for(:controller => 'main', :action => 'index')
                   mail_subject = "[#{contest_name}] Confirmation"
                   mail_body = t('registration.email_body', {
                                   :full_name => user.full_name,
                                   :contest_name => contest_name,
                                   :login => user.login,
                                   :password => user.password,
                                   :activation_url => activation_url,
                                   :admin_email => GraderConfiguration['system.admin_email']
                                 })
                   logger.info mail_body
                   send_mail(user.email, mail_subject, mail_body)
                 end
                 def send_new_password_email(user)
                   contest_name = GraderConfiguration['contest.name']
                   mail_subject = "[#{contest_name}] Password recovery"
                   mail_body = t('registration.password_retrieval.email_body', {
                                   :full_name => user.full_name,
                                   :contest_name => contest_name,
                                   :login => user.login,
                                   :password => user.password,
                                   :admin_email => GraderConfiguration['system.admin_email']
                                 })
                   logger.info mail_body
                   send_mail(user.email, mail_subject, mail_body)
                 end
                 # allow viewing of regular user profile only when options allow so
                 # only admins can view admins profile
                 def profile_authorization
                   #if view admins' profile, allow only admin
                   return false unless(params[:id])
                   user = User.find(params[:id])
                   return false unless user
                   return admin_authorization if user.admin?
                   return true if GraderConfiguration["right.user_view_submission"]
                   #finally, we allow only admin
                   admin_authorization
                 end

app/models/group.rb ¶ +2 -2

               class Group < ActiveRecord::Base
-            -   has_many :groups_problems, class_name: GroupProblem
+            +   has_many :groups_problems, class_name: 'GroupProblem'
                 has_many :problems, :through => :groups_problems
-            -   has_many :groups_users, class_name: GroupUser
+            +   has_many :groups_users, class_name: 'GroupUser'
                 has_many :users, :through => :groups_users
                 #has_and_belongs_to_many :problems
                 #has_and_belongs_to_many :users
               end

app/models/problem.rb ¶ +2 -2

               class Problem < ActiveRecord::Base
                 belongs_to :description
                 has_and_belongs_to_many :contests, :uniq => true
                 #has_and_belongs_to_many :groups
-            -   has_many :groups_problems, class_name: GroupProblem
+            +   has_many :groups_problems, class_name: 'GroupProblem'
                 has_many :groups, :through => :groups_problems
-            -   has_many :problems_tags, class_name: ProblemTag
+            +   has_many :problems_tags, class_name: 'ProblemTag'
                 has_many :tags, through: :problems_tags
                 has_many :test_pairs, :dependent => :delete_all
                 has_many :testcases, :dependent => :destroy
                 has_many :submissions
                 validates_presence_of :name
                 validates_format_of :name, :with => /\A\w+\z/
                 validates_presence_of :full_name
                 scope :available, -> { where(available: true) }
                 DEFAULT_TIME_LIMIT = 1
                 DEFAULT_MEMORY_LIMIT = 32
                 def self.available_problems
                   available.order(date_added: :desc).order(:name)
                   #Problem.available.all(:order => "date_added DESC, name ASC")
                 end
                 def self.create_from_import_form_params(params, old_problem=nil)
                   org_problem = old_problem || Problem.new
                   import_params, problem = Problem.extract_params_and_check(params,
                                                                             org_problem)
                   if !problem.errors.empty?
                     return problem, 'Error importing'
                   end
                   problem.full_score = 100
                   problem.date_added = Time.new
                   problem.test_allowed = true
                   problem.output_only = false
                   problem.available = false
                   if not problem.save
                     return problem, 'Error importing'
                   end
                   import_to_db = params.has_key? :import_to_db
                   importer = TestdataImporter.new(problem)
                   if not importer.import_from_file(import_params[:file],
                                                    import_params[:time_limit],
                                                    import_params[:memory_limit],
                                                    import_params[:checker_name],
                                                    import_to_db)
                     problem.errors.add(:base,'Import error.')
                   end
                   return problem, importer.log_msg
                 end
                 def self.download_file_basedir
                   return "#{Rails.root}/data/tasks"
                 end
                 def get_submission_stat
                   result = Hash.new
                   #total number of submission
                   result[:total_sub] = Submission.where(problem_id: self.id).count
                   result[:attempted_user] = Submission.where(problem_id: self.id).group(:user_id)
                   result[:pass] = Submission.where(problem_id: self.id).where("points >= ?",self.full_score).count
                   return result
                 end
                 def long_name
                   "[#{name}] #{full_name}"
                 end
                 protected
                 def self.to_i_or_default(st, default)
                   if st!=''
                     result = st.to_i
                   end
                   result ||= default
                 end
                 def self.to_f_or_default(st, default)
                   if st!=''
                     result = st.to_f
                   end
                   result ||= default
                 end
                 def self.extract_params_and_check(params, problem)
                   time_limit = Problem.to_f_or_default(params[:time_limit],
                                                        DEFAULT_TIME_LIMIT)
                   memory_limit = Problem.to_i_or_default(params[:memory_limit],
                                                          DEFAULT_MEMORY_LIMIT)
                   if time_limit<=0 or time_limit >60
                     problem.errors.add(:base,'Time limit out of range.')
                   end
                   if memory_limit==0 and params[:memory_limit]!='0'
                     problem.errors.add(:base,'Memory limit format errors.')
                   elsif memory_limit<=0 or memory_limit >512
                     problem.errors.add(:base,'Memory limit out of range.')
                   end
                   if params[:file]==nil or params[:file]==''
                     problem.errors.add(:base,'No testdata file.')
                   end
                   checker_name = 'text'
                   if ['text','float'].include? params[:checker]
                     checker_name = params[:checker]
                   end
                   file = params[:file]
                   if !problem.errors.empty?
                     return nil, problem
                   end
                   problem.name = params[:name]
                   if params[:full_name]!=''
                     problem.full_name = params[:full_name]
                   else
                     problem.full_name = params[:name]
                   end
                   return [{
                             :time_limit => time_limit,
                             :memory_limit => memory_limit,
                             :file => file,
                             :checker_name => checker_name
                           },
                           problem]
                 end
               end

app/models/tag.rb ¶ +1 -1

               class Tag < ActiveRecord::Base
-            -   has_many :problems_tags, class_name: ProblemTag
+            +   has_many :problems_tags, class_name: 'ProblemTag'
                 has_many :problems, through: :problems_tags
               end

app/models/user.rb ¶ +1 -1

               require 'digest/sha1'
               require 'net/pop'
               require 'net/https'
               require 'net/http'
               require 'json'
               class User < ActiveRecord::Base
                 has_and_belongs_to_many :roles
                 #has_and_belongs_to_many :groups
-            -   has_many :groups_users, class_name: GroupUser
+            +   has_many :groups_users, class_name: 'GroupUser'
                 has_many :groups, :through => :groups_users
                 has_many :test_requests, -> {order(submitted_at: :desc)}
                 has_many :messages, -> { order(created_at: :desc) },
                          :class_name => "Message",
                          :foreign_key => "sender_id"
                 has_many :replied_messages, -> { order(created_at: :desc) },
                          :class_name => "Message",
                          :foreign_key => "receiver_id"
                 has_one :contest_stat, :class_name => "UserContestStat", :dependent => :destroy
                 belongs_to :site
                 belongs_to :country
                 has_and_belongs_to_many :contests, -> { order(:name); uniq}
                 scope :activated_users, -> {where activated: true}
                 validates_presence_of :login
                 validates_uniqueness_of :login
                 validates_format_of :login, :with => /\A[\_A-Za-z0-9]+\z/
                 validates_length_of :login, :within => 3..30
                 validates_presence_of :full_name
                 validates_length_of :full_name, :minimum => 1
                 validates_presence_of :password, :if => :password_required?
                 validates_length_of :password, :within => 4..20, :if => :password_required?
                 validates_confirmation_of :password, :if => :password_required?
                 validates_format_of :email,
                                     :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i,
                                     :if => :email_validation?
                 validate :uniqueness_of_email_from_activated_users,
                          :if => :email_validation?
                 validate :enough_time_interval_between_same_email_registrations,
                          :if => :email_validation?
                 # these are for ytopc
                 # disable for now
                 #validates_presence_of :province
                 attr_accessor :password
                 before_save :encrypt_new_password
                 before_save :assign_default_site
                 before_save :assign_default_contest
                 # this is for will_paginate
                 cattr_reader :per_page
                 @@per_page = 50
                 def self.authenticate(login, password)
                   user = find_by_login(login)
                   if user
                     return user if user.authenticated?(password)
                   end
                 end
                 def authenticated?(password)
                   if self.activated
                     hashed_password == User.encrypt(password,self.salt)
                   else
                     false
                   end
                 end
                 def admin?
                   self.roles.detect {|r| r.name == 'admin' }
                 end
                 def email_for_editing
                   if self.email==nil
                     "(unknown)"
                   elsif self.email==''
                     "(blank)"
                   else
                     self.email
                   end
                 end
                 def email_for_editing=(e)
                   self.email=e
                 end
                 def alias_for_editing
                   if self.alias==nil
                     "(unknown)"
                   elsif self.alias==''
                     "(blank)"
                   else
                     self.alias
                   end
                 end
                 def alias_for_editing=(e)
                   self.alias=e
                 end
                 def activation_key
                   if self.hashed_password==nil
                     encrypt_new_password
                   end
                   Digest::SHA1.hexdigest(self.hashed_password)[0..7]
                 end
                 def verify_activation_key(key)
                   key == activation_key
                 end
                 def self.random_password(length=5)
                   chars = 'abcdefghjkmnopqrstuvwxyz'
                   password = ''
                   length.times { password << chars[rand(chars.length - 1)] }
                   password
                 end
                 def self.find_non_admin_with_prefix(prefix='')
                   users = User.all
                   return users.find_all { |u| !(u.admin?) and u.login.index(prefix)==0 }
                 end
                 # Contest information
                 def self.find_users_with_no_contest()
                   users = User.all
                   return users.find_all { |u| u.contests.length == 0 }
                 end
                 def contest_time_left
                   if GraderConfiguration.contest_mode?
                     return nil if site==nil
                     return site.time_left
                   elsif GraderConfiguration.indv_contest_mode?
                     time_limit = GraderConfiguration.contest_time_limit
                     if time_limit == nil
                       return nil
                     end
                     if contest_stat==nil or contest_stat.started_at==nil
                       return (Time.now.gmtime + time_limit) - Time.now.gmtime
                     else
                       finish_time = contest_stat.started_at + time_limit
                       current_time = Time.now.gmtime
                       if current_time > finish_time
                         return 0
                       else
                         return finish_time - current_time
                       end
                     end
                   else
                     return nil
                   end
                 end
                 def contest_finished?
                   if GraderConfiguration.contest_mode?
                     return false if site==nil
                     return site.finished?
                   elsif GraderConfiguration.indv_contest_mode?
                     return false if self.contest_stat(true)==nil
                     return contest_time_left == 0
                   else
                     return false
                   end
                 end
                 def contest_started?
                   if GraderConfiguration.indv_contest_mode?
                     stat = self.contest_stat
                     return ((stat != nil) and (stat.started_at != nil))
                   elsif GraderConfiguration.contest_mode?
                     return true if site==nil
                     return site.started
                   else
                     return true
                   end
                 end
                 def update_start_time
                   stat = self.contest_stat
                   if stat.nil? or stat.started_at.nil?
                     stat ||= UserContestStat.new(:user => self)
                     stat.started_at = Time.now.gmtime
                     stat.save
                   end
                 end
                 def problem_in_user_contests?(problem)

app/views/problems/index.html.haml ¶ +1 -1

               - content_for :head do
                 = stylesheet_link_tag 'problems'
               %h1 Problems
               %p
                 = link_to 'Import problems', {:action => 'import'}, class: 'btn btn-success btn-sm'
                 = link_to 'New problem', new_problem_path, class: 'btn btn-success btn-sm'
                 = link_to 'Bulk Manage', { action: 'manage'}, class: 'btn btn-info btn-sm'
                 = link_to 'Turn off all problems', {:action => 'turn_all_off'}, class: 'btn btn-default btn-sm'
                 = link_to 'Turn on all problems', {:action => 'turn_all_on'}, class: 'btn btn-default btn-sm'
               .submitbox
-            -   = form_tag :action => 'quick_create' do
+            +   = form_tag action: 'quick_create', controller: 'problems' do
                   %b Quick New:
                   %label{:for => "problem_name"} Name
                   = text_field 'problem', 'name'
                   |
                   %label{:for => "problem_full_name"} Full name
                   = text_field 'problem', 'full_name'
                   = submit_tag "Create"
               %table.table.table-condense.table-hover
                 %thead
                   %th Name
                   %th Full name
                   %th.text-right Full score
                   %th Tags
                   %th
                     Submit
                     %sup{class: 'text-primary',data: {toggle: 'tooltip'}, title: 'Admin can always submit to any problem' } [?]
                   %th Date added
                   %th.text-center
                     Avail?
                     %sup{class: 'text-primary',data: {toggle: 'tooltip'}, title: 'Let user submits to this problem?' } [?]
                   %th.text-center
                     View Data?
                     %sup{class: 'text-primary',data: {toggle: 'tooltip'}, title: 'Let user view the testcase of this problem?' } [?]
                   %th.text-center
                     Test?
                     %sup{class: 'text-primary',data: {toggle: 'tooltip'}, title: 'Let user uses test interface on this problem?' } [?]
                   - if GraderConfiguration.multicontests?
                     %th Contests
                 - for problem in @problems
                   %tr{:class => "#{(problem.available) ? "success" : "danger"}", :id => "prob-#{problem.id}", :name => "prob-#{problem.id}"}
                     - @problem=problem
                     %td= problem.name #in_place_editor_field :problem, :name, {}, :rows=>1
                     %td
                       = problem.full_name #in_place_editor_field :problem, :full_name, {}, :rows=>1
                       = link_to_description_if_any "[#{t 'main.problem_desc'}] <span class='glyphicon glyphicon-file'></span>".html_safe, problem
                     %td.text-right= problem.full_score #in_place_editor_field :problem, :full_score, {}, :rows=>1
                     %td
                       - problem.tags.each do |t|
                         - #%button.btn.btn-default.btn-xs= t.name
                         %span.label.label-default= t.name
                     %td= link_to "Submit", direct_edit_problem_submissions_path(problem,@current_user.id), class: 'btn btn-xs btn-primary'
                     %td= problem.date_added
                     %td= toggle_button(@problem.available?, toggle_problem_path(@problem), "problem-avail-#{@problem.id}")
                     %td= toggle_button(@problem.view_testcase?, toggle_view_testcase_problem_path(@problem), "problem-view-testcase-#{@problem.id}")
                     %td= toggle_button(@problem.test_allowed?, toggle_test_problem_path(@problem), "problem-test-#{@problem.id}")
                     - if GraderConfiguration.multicontests?
                       %td
                         = problem.contests.collect { |c| c.name }.join(', ')
                     %td= link_to 'Stat', {:action => 'stat', :id => problem.id}, class: 'btn btn-info btn-xs btn-block'
                     %td= link_to 'Show', {:action => 'show', :id => problem}, class: 'btn btn-info btn-xs btn-block'
                     %td= link_to 'Edit', {:action => 'edit', :id => problem}, class: 'btn btn-info btn-xs btn-block'
                     %td= link_to 'Destroy', { :action => 'destroy', :id => problem }, :confirm => 'Are you sure?', :method => :delete, class: 'btn btn-danger btn-xs btn-block'
               %br/
               = link_to '[New problem]', :action => 'new'

app/views/problems/new.html.erb ¶ +1 -1

               <h1>New problem</h1>
               <%= form_tag :action => 'create' do %>
                 <%= render :partial => 'form' %>
                 <%= submit_tag "Create" %>
               <% end %>
-            - <%= link_to 'Back', :action => 'list' %>
+            + <%= link_to 'Back', problems_path %>

app/views/user_admin/edit.html.haml ¶ +1 -1

               %h1 Editing user
               = form_tag( {:action => 'update', :id => @user}, {class: 'form-horizontal'}) do
                 = error_messages_for 'user'
                 = render partial: "form"
                 .form-group
                   .col-md-offset-2.col-md-4
                     = submit_tag "Edit", class: 'btn btn-primary'
               = link_to 'Show', :action => 'show', :id => @user
               |
-            - = link_to 'Back', :action => 'list'
+            + = link_to 'Back', :action => 'index'

config/initializers/new_framework_defaults.rb ¶ +1 -1

               # Be sure to restart your server when you modify this file.
               #
               # This file contains migration options to ease your Rails 5.0 upgrade.
               #
               # Once upgraded flip defaults one by one to migrate to the new default.
               #
               # Read the Guide for Upgrading Ruby on Rails for more info on each option.
               Rails.application.config.action_controller.raise_on_unfiltered_parameters = true
               # Enable per-form CSRF tokens. Previous versions had false.
               Rails.application.config.action_controller.per_form_csrf_tokens = false
               # Enable origin-checking CSRF mitigation. Previous versions had false.
               Rails.application.config.action_controller.forgery_protection_origin_check = false
               # Make Ruby 2.4 preserve the timezone of the receiver when calling `to_time`.
               # Previous versions had false.
               ActiveSupport.to_time_preserves_timezone = false
               # Require `belongs_to` associations by default. Previous versions had false.
               Rails.application.config.active_record.belongs_to_required_by_default = false
               # Do not halt callback chains when a callback returns false. Previous versions had true.
-            - ActiveSupport.halt_callback_chains_on_return_false = true
+            + # ActiveSupport.halt_callback_chains_on_return_false = true

config/routes.rb ¶ +4

               Rails.application.routes.draw do
                 resources :tags
                 get "sources/direct_edit"
                 root :to => 'main#login'
                 #logins
                 match 'login/login',  to: 'login#login', via: [:get,:post]
                 resources :contests
                 resources :sites
                 resources :test
                 resources :messages do
                   collection do
                     get 'console'
                   end
                 end
                 resources :announcements do
                   member do
                     get 'toggle','toggle_front'
                   end
                 end
                 resources :problems do
                   member do
                     get 'toggle'
                     get 'toggle_test'
                     get 'toggle_view_testcase'
                     get 'stat'
                   end
                   collection do
                     get 'turn_all_off'
                     get 'turn_all_on'
                     get 'import'
                     get 'manage'
+            +       get 'quick_create'
+            +       post 'do_manage'
                   end
                 end
                 resources :groups do
                   member do
                     post 'add_user', to: 'groups#add_user', as: 'add_user'
                     delete 'remove_user/:user_id', to: 'groups#remove_user', as: 'remove_user'
                     delete 'remove_all_user', to: 'groups#remove_all_user', as: 'remove_all_user'
                     post 'add_problem', to: 'groups#add_problem', as: 'add_problem'
                     delete 'remove_problem/:problem_id', to: 'groups#remove_problem', as: 'remove_problem'
                     delete 'remove_all_problem', to: 'groups#remove_all_problem', as: 'remove_all_problem'
                   end
                   collection do
                   end
                 end
                 resources :testcases, only: [] do
                   member do
                     get 'download_input'
                     get 'download_sol'
                   end
                   collection do
                     get 'show_problem/:problem_id(/:test_num)' => 'testcases#show_problem', as: 'show_problem'
                   end
                 end
                 resources :grader_configuration, controller: 'configurations'
                 resources :users do
                   member do
                     get 'toggle_activate', 'toggle_enable'
                     get 'stat'
                   end
                 end
                 resources :submissions do
                   member do
                     get 'download'
                     get 'compiler_msg'
                     get 'rejudge'
                   end
                   collection do
                     get 'prob/:problem_id', to: 'submissions#index', as: 'problem'
                     get 'direct_edit_problem/:problem_id(/:user_id)', to: 'submissions#direct_edit_problem', as: 'direct_edit_problem'
                     get 'get_latest_submission_status/:uid/:pid', to: 'submissions#get_latest_submission_status', as: 'get_latest_submission_status'
                   end
                 end
                 #user admin
                 resources :user_admin do
                   collection do
                     match 'bulk_manage', via: [:get, :post]
+            +       get 'bulk_mail'
                     get 'user_stat'
                     get 'import'
                     get 'new_list'
                     get 'admin'
                     get 'random_all_passwords'
                     get 'active'
                     get 'mass_mailing'
                     match 'create_from_list', via: [:get, :post]
+            +       post 'grant_admin'
                   end
                   member do
                     get 'clear_last_ip'
                   end
                 end
                 resources :contest_management, only: [:index] do
                   collection do
                     get 'user_stat'
                     get 'clear_stat'
                     get 'clear_all_stat'
                   end
                 end
                 #get 'user_admin', to: 'user_admin#index'
                 #get 'user_admin/bulk_manage', to: 'user_admin#bulk_manage', as: 'bulk_manage_user_admin'
                 #post 'user_admin', to: 'user_admin#create'
                 #delete 'user_admin/:id', to: 'user_admin#destroy', as: 'user_admin_destroy'
                 #singular resource
                 #---- BEWARE ---- singular resource maps to plural controller by default, we can override by provide controller name directly
                 #report
                 resource :report, only: [], controller: 'report' do
                   get 'login'
                   get 'multiple_login'
                   get 'problem_hof/:id', action: 'problem_hof'
                   get 'current_score'
                   get 'max_score'
                   post 'show_max_score'
                 end
                 #get 'report/current_score', to: 'report#current_score', as: 'report_current_score'
                 #get 'report/problem_hof(/:id)', to: 'report#problem_hof', as: 'report_problem_hof'
                 #get "report/login"
                 #get 'report/max_score', to: 'report#max_score', as: 'report_max_score'
                 #post 'report/show_max_score', to: 'report#show_max_score', as: 'report_show_max_score'
                 resource :main, only: [], controller: 'main' do
                   get 'list'
                   get 'submission(/:id)', action: 'submission', as: 'main_submission'
                   post 'submit'
                   get 'announcements'
                   get 'help'
                 end
                 #main
                 #get "main/list"
                 #get 'main/submission(/:id)', to: 'main#submission', as: 'main_submission'
                 #post 'main/submit', to: 'main#submit'
                 #get 'main/announcements', to: 'main#announcements'
                 #
                 get 'tasks/view/:file.:ext' => 'tasks#view'
                 get 'tasks/download/:id/:file.:ext' => 'tasks#download'
                 get 'heartbeat/:id/edit' => 'heartbeat#edit'
                 #grader
                 get 'graders/list', to: 'graders#list', as: 'grader_list'
                 # See how all your routes lay out with "rake routes"
                 # This is a legacy wild controller route that's not recommended for RESTful applications.
                 # Note: This route will make all actions in every controller accessible via GET requests.
                 # match ':controller(/:action(/:id))(.:format)', via:  [:get, :post]
               end

test/test_helper.rb ¶ +4 -3

-            - ENV["RAILS_ENV"] = "test"
+            + ENV['RAILS_ENV'] ||= 'test'
-            - require File.expand_path('../../config/environment', __FILE__)
+            + require_relative '../config/environment'
               require 'rails/test_help'
               #reporter for beautiful result
               require "minitest/reporters"
               Minitest::Reporters.use!
               module SignInHelper
                 def sign_in_as(user,password)
                   post login_login_path, {login: user, password: password }
                 end
               end
               class ActiveSupport::TestCase
                 include SignInHelper
                 # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
                 #
                 # Note: You'll currently still have to declare fixtures explicitly in integration tests
                 # -- they do not yet inherit this setting
                 fixtures :all
                 # Add more helper methods to be used by all tests here...
-            -   self.use_transactional_fixtures = true
+            +   self.use_transactional_tests = true
+            +   #self.use_instantiated_fixtures  = false
                 self.use_instantiated_fixtures  = false
               end

app/views/announcements/new.html.erb removed ¶ -46

deleted file

app/views/announcements/show.html.erb removed ¶ -37

deleted file

Write
Preview

You need to be logged in to leave comments. Login now

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository permissions settings

Sign in to your account

Commit r751:01b657de42d9 public

Author

r751:01b657de42d9 - Thu, 04 Jul 2019 09:13:44 - 29 files changed: 765 inserted, 140 deleted

Commit `r751:01b657de42d9` public