Пример #1
0
def delete_participants():
    """
    Deletes all participants, startlists and results. Categories stay.
    Function is called by a javascript/jquery
    """
    ParticipantModel.delete_all_rows()
    StartlistModel.delete_all_rows()
    StartlistNameModel.delete_all_rows()

    message = "Deleted all participants, startlists and results"
    return jsonify(result=message)
Пример #2
0
def delete_all():
    """
    Deletes all participants, startlists and results and categories
    Function is called by a javascript/jquery
    """
    ParticipantModel.delete_all_rows()
    StartlistModel.delete_all_rows()
    StartlistNameModel.delete_all_rows()
    CategoryModel.delete_all_rows()

    message = "Deleted all data from the Database"
    return jsonify(result=message)
Пример #3
0
def wizard_start():
    # clearing session counter
    clearsession()
    startlist_display = [(st.id, st.name)
                         for st in StartlistNameModel.list_all()
                         if not st.measured_flag]
    return render_template('startlist/create_new_wizard.html',
                           data=startlist_display)
Пример #4
0
def create_startlist_classification():
    # TODO pass number of athletes in each finished startlist to the template.

    startlist_finished = [(stlist.id, stlist.name)
                          for stlist in StartlistNameModel.list_measured_all()]

    return render_template('startlist/create_new_list_classification.html',
                           startlist_finished=startlist_finished)
Пример #5
0
def rename_startlist_by_id(startlist_id, startlist_new_name):
    try:
        startlist_db_object = StartlistNameModel.get_by_id(startlist_id)
        startlist_db_object.name = startlist_new_name
        startlist_db_object.save_to_db()
        return True
    except:
        return False
Пример #6
0
def generate_startlist_category():
    if request.method == 'POST':
        startlist_name = request.form['startlist_name'].strip()

        # startlist name must not be empty
        # this condition can be improved to be more user friendly
        if startlist_name == "":
            return redirect(url_for('.create_startlist_category'))

        startlist_lines = request.form['startlist_lines']
        startlist_category = request.form['startlist_category']

        # print(startlist_name)
        # print(startlist_lines)
        # print(startlist_category)

        new_startlist = StartlistNameModel(startlist_name,
                                           startlist_lines,
                                           round1_flag=True)
        new_startlist.save_to_db()

        # print("Startlist ID: {} - {} - {}".format(new_startlist.id, new_startlist.name, new_startlist.startline_count))

        new_startlist.startlist_rounds = startlist_processing.process(
            new_startlist.id, startlist_category, int(startlist_lines))
        new_startlist.save_to_db()

    return redirect(url_for('.create_startlist_category'))
Пример #7
0
def startlist_one_delete():
    startlist_id = request.form['startlist_select']

    startlist_name = StartlistNameModel.get_name_by_id(startlist_id)

    deleted = startlist_processing.delete_startlist_by_id(startlist_id)

    startlist_all = [(stlist.id, stlist.name)
                     for stlist in StartlistNameModel.list_all()]

    if deleted:
        return render_template(
            'startlist/startlist_one_menu_delete_success.html',
            data=startlist_all,
            startlist_name=startlist_name)
    return render_template('startlist/startlist_one_menu_delete_fail.html',
                           data=startlist_all,
                           startlist_name=startlist_name)
Пример #8
0
def results_specific_startlist():
    startlist_id = request.form['startlist_select']

    startlist_instance = StartlistNameModel.get_by_id(startlist_id)
    output_list = startlist_processing.result_list_generate(startlist_id)

    return render_template('startlist/results_specific_startlist.html',
                           startlist_name=startlist_instance.name,
                           data=output_list)
Пример #9
0
def results_final():
    results = {}
    startlists_finished = [
        (stlist.id, stlist.name)
        for stlist in StartlistNameModel.list_measured_and_not_final_all()
    ]
    for startlist_id, startlist_name in startlists_finished:
        results[startlist_name] = result_list_generate(startlist_id)

    return collections.OrderedDict(sorted(results.items()))
Пример #10
0
def startlist_one():
    startlist_id = request.form['startlist_select']
    startlist_instance = StartlistNameModel.get_by_id(startlist_id)

    output_list = startlist_processing.startlist_generate(startlist_id)
    output_length = startlist_processing.startlist_generate_length(
        startlist_id)

    return render_template('startlist/startlist_one.html',
                           startlist_name=startlist_instance.name,
                           data=output_list,
                           length=output_length)
Пример #11
0
def startlist_one_rename():
    startlist_id = request.form['startlist_select']

    # for startlist_one_edit_save()
    session['startlist_id'] = startlist_id

    # get the startlist name
    # render form to enter its new name

    startlist_name = StartlistNameModel.get_name_by_id(startlist_id)

    return render_template('startlist/startlist_one_rename.html',
                           startlist_name=startlist_name)
Пример #12
0
def delete_startlist_by_id(startlist_id):
    try:
        startlist_records = StartlistModel.get_by_startlist_id(startlist_id)
        for r in startlist_records:
            r.delete_from_db()

        startlist_db_object = StartlistNameModel.get_by_id(startlist_id)
        startlist_db_object.delete_from_db()

        # find all instances of the startlistmodel in startlist table
        # delete them one by one
        # delete the instance in the startlist model

        return True
    except:
        return False
Пример #13
0
def generate_startlist_classfication():
    if request.method == 'POST':
        # print(request.form)

        startlist_finished_id = request.form['startlist_select']
        startlist_name = request.form['startlist_name'].strip()

        if startlist_name == "":
            return redirect(url_for('.create_startlist_classification'))

        startlist_top_times = int(request.form['startlist_top_times'])
        startlist_lines = request.form['startlist_lines']

        new_startlist = StartlistNameModel(startlist_name,
                                           startlist_lines,
                                           round1_flag=False)
        new_startlist.save_to_db()

        # Note: Not used at the moment
        # startlist_finished_instance = StartlistNameModel.get_by_id(startlist_finished_id)

        startlist_finished_results_ordered = \
            [result for result in StartlistModel.get_records_by_startlist_id_order_by_time(startlist_finished_id)]\
            [:startlist_top_times]

        print(startlist_finished_results_ordered)

        # removing Participant objects from a tuples
        # removing Participant objects from a tuples
        # and also ignoring Athletes with the time 59:59.59 - datetime.timedelta(0, 3599, 590000)
        # 59:59.59 means that an athletes is DNF. This form of time has been chosen for code simplicity.
        # At the UZE sprinter event, it is impossible that an athlete will have such a time
        startlist_finished_only_results_ordered = \
            [startlist_record for startlist_record, _ in startlist_finished_results_ordered
                if startlist_record.time_measured != datetime.timedelta(0, 3599, 590000)]

        # In case there is only one classification run, the records are re-ordered so that the fasterst
        # athletes are placed in the middle of the start field.
        if startlist_top_times <= int(startlist_lines):
            startlist_finished_only_results_ordered = startlist_alg.order_from_the_middle(
                startlist_finished_only_results_ordered)

        # generating new startlist record instances, startline numbers and rounds assignment
        new_startlist.startlist_rounds = startlist_processing.process_classification(
            new_startlist.id, startlist_finished_only_results_ordered,
            int(startlist_lines))
        new_startlist.save_to_db()

    return redirect(url_for('.create_startlist_classification'))
Пример #14
0
def startlist_one_rename_save():
    startlist_id = session['startlist_id']
    new_startlist_name = request.form['new_startlist_name']

    renamed = startlist_processing.rename_startlist_by_id(
        startlist_id, new_startlist_name)

    startlist_all = [(stlist.id, stlist.name)
                     for stlist in StartlistNameModel.list_all()]

    if renamed:
        return render_template(
            'startlist/startlist_one_menu_rename_success.html',
            data=startlist_all,
            startlist_name=new_startlist_name)
    return render_template('startlist/startlist_one_menu_rename_fail.html',
                           data=startlist_all,
                           startlist_name=new_startlist_name)
Пример #15
0
def startlist_one_edit():
    startlist_id = request.form['startlist_select']

    # for startlist_one_edit_save()
    session['startlist_id'] = startlist_id

    startlist_instance = StartlistNameModel.get_by_id(startlist_id)
    output_list = startlist_processing.startlist_generate(startlist_id)
    output_length = startlist_processing.startlist_generate_length(
        startlist_id)
    rounds, line_count = startlist_processing.startlist_get_rounds_lines(
        startlist_id)

    return render_template('startlist/startlist_one_edit.html',
                           startlist_name=startlist_instance.name,
                           data=output_list,
                           length=output_length,
                           rounds=rounds,
                           line_count=line_count)
Пример #16
0
def results():
    startlist_finished = [(stlist.id, stlist.name)
                          for stlist in StartlistNameModel.list_measured_all()]
    return render_template('startlist/results_finished_startlists_menu.html',
                           data=startlist_finished)
Пример #17
0
def startlist_get_rounds_lines(startlist_id):
    startlist_instance = StartlistNameModel.get_by_id(startlist_id).json()
    return startlist_instance['startlist_rounds'], startlist_instance[
        'startline_count']
Пример #18
0
def get_startlist_instances_not_round1():
    return [
        startlist_def
        for startlist_def in StartlistNameModel.list_not_round1_all()
    ]
Пример #19
0
def get_startlist_instances():
    return [startlist_def for startlist_def in StartlistNameModel.list_all()]
Пример #20
0
def startlist_menu_delete():
    startlist_all = [(stlist.id, stlist.name)
                     for stlist in StartlistNameModel.list_all()]
    return render_template('startlist/startlist_one_menu_delete.html',
                           data=startlist_all)
Пример #21
0
def wizard():

    if request.method == 'POST':
        try:
            session['startlist_selected'] = request.form['startlist_select']
        except:
            print("error - method wizard")

    try:
        startlist_selected = session['startlist_selected']
    except KeyError:
        return redirect(url_for('.wizard_start'))

    startlist_instance = StartlistNameModel.get_by_id(startlist_selected)

    # it does nothing if session['counter'] already exists
    init_session_counter()

    if session['counter'] > startlist_instance.startlist_rounds:
        # indicates that there are times stored in this startlist
        startlist_instance.measured_flag = True
        startlist_instance.save_to_db()
        return redirect(url_for('.wizard_start'))

    found_records = [
        record for record in
        StartlistModel.get_records_by_startlist_id_and_round_number(
            startlist_selected, session['counter'])
    ]

    startlist_round = []
    for stm, ptm in found_records:
        record = (ptm.last_name, ptm.first_name, stm.start_position,
                  stm.start_round, stm.id)
        startlist_round.append(record)

    # to easily receive startlist_id in the next_round()
    session['startlist_round'] = startlist_round

    startlist_lines = len(startlist_round)

    # not used at the moment
    # random_times = time_random(startlist_lines)

    # loading of the times from old database
    # db_times = [str(item.time_measured)[2:-4] for item in TimeDbModel.list_all()][-startlist_lines:]
    # session['random_times'] = db_times

    # loading of the times from the external database
    db_times_ext = [
        str(item.time_measured)[2:-4] for item in TimyDbModel.list_all()
    ][-startlist_lines:]
    session['random_times'] = db_times_ext

    progress_now = session[
        'counter'] * 100 / startlist_instance.startlist_rounds
    progress_now_int = int(round(progress_now))

    # Note: Verification if the site has been reloaded due to wrong assignment of startlines by user.
    # redirected from next_round() function.
    try:
        if session['wrong_entry'] == 1:
            session['wrong_entry'] = 0

            return render_template(
                'startlist/wizard_wrong_lines_assigned.html',
                name=startlist_instance.name,
                startlist=startlist_round,
                progress_now=progress_now_int,
                startlist_lines=startlist_lines,
                random_times=db_times_ext,
                rounds_count=startlist_instance.startlist_rounds)

        if session['wrong_entry'] == 2:
            session['wrong_entry'] = 0

            return render_template(
                'startlist/wizard_wrong_time_entered.html',
                name=startlist_instance.name,
                startlist=startlist_round,
                progress_now=progress_now_int,
                startlist_lines=startlist_lines,
                random_times=db_times_ext,
                rounds_count=startlist_instance.startlist_rounds)

    except KeyError:
        pass

    return render_template('startlist/wizard.html',
                           name=startlist_instance.name,
                           startlist=startlist_round,
                           progress_now=progress_now_int,
                           startlist_lines=startlist_lines,
                           random_times=db_times_ext,
                           rounds_count=startlist_instance.startlist_rounds)