Beispiel #1
0
def filter(expenses, parameters):
    """
    Function that handles the 'filter' functionality
    :param expenses: The expense list to filter
    :param parameters: The parameters for filtering
    """

    rules = [
        [str],  # filter <category>
        [str, Operator.Operator, int]  # filter <category>  < / > / =  <value>
    ]

    all_categories = get_all_categories(expenses)

    if Parser.parameters_are_valid(parameters, rules[0]) is True:
        category_to_keep = parameters[0]

        for category in all_categories:
            if category != category_to_keep:
                remove(expenses, [category])
    elif Parser.parameters_are_valid(parameters, rules[1]) is True:
        category_to_keep = parameters[0]
        operator = parameters[1]
        value = int(parameters[2])

        for category in all_categories:
            if category != category_to_keep:
                remove(expenses, [category])
        for expense in expenses[:]:
            if Operator.operator_map[operator](Expense.get_amount(expense),
                                               value) is False:
                expenses.remove(expense)
Beispiel #2
0
Datei: UI.py Projekt: VicSera/UBB
def menu_sort(expenses):
    """
    Launch the menu that corresponds to the 'sort' command
    :param expenses: The list of expenses to sort
    """

    options = ['Day', 'Category']
    criterion = Parser.choose(options, "Sort by:")

    if criterion is 'Day':
        valid_days = Functions.get_all_days(
            expenses)  # get all the unique entries for days
        day = Parser.get_input_of_type(int, "Please choose a day:")

        if day not in valid_days:
            print("There are no entries for day {}".format(str(day)))
            return

        Functions.sort_by(expenses, [day])
    elif criterion is 'Category':
        valid_categories = Functions.get_all_categories(
            expenses)  # get all the unique entries for categories
        category = Parser.choose(valid_categories, "Please pick a category:")

        Functions.sort_by(expenses, [category])
Beispiel #3
0
Datei: UI.py Projekt: VicSera/UBB
def menu_list(expenses):
    """
    Launch the menu that corresponds to the 'list' command
    :param expenses: The list of expenses to print out
    """
    printer = Functions.list_elements

    categories = ['All categories'] + Functions.get_all_categories(expenses)
    category = Parser.choose(categories, "Please choose a category:")

    if category is 'All categories':
        printer(expenses, [])
        return

    constraining_options = ['No constraints', 'Place a constraint']
    constraint_choice = Parser.choose(constraining_options,
                                      "Please choose a constraint:")

    if constraint_choice is 'No constraints':
        printer(expenses, [category])
        return

    operators = ['<', '>', '=']
    operator = Parser.choose(operators, "Please choose an operator: ")
    comparison_element = Parser.get_input_of_type(
        int, "Please choose a number to compare to: ")
    printer(expenses, [category, operator, comparison_element])
Beispiel #4
0
Datei: UI.py Projekt: VicSera/UBB
def menu_add(expenses):
    """
    Launch the menu that corresponds to the 'add' command
    :param expenses: The list of expenses to add elements to
    """
    add = Functions.add  # Reference the same function used in the command-based menu
    print("You have selected the 'add' option.")

    amount = Parser.get_input_of_type(int, "Please give an amount")
    category = Parser.get_input_of_type(str, "Please give a category")

    add(expenses, [amount, category])
Beispiel #5
0
Datei: UI.py Projekt: VicSera/UBB
def menu_insert(expenses):
    """
    Launch the menu that corresponds to the 'insert' command
    :param expenses: The list of expenses to insert new expenses into
    """
    add = Functions.insert  # Reference the same function used in the command-based menu
    print("You have selected the 'add' option.")

    while True:
        day = Parser.get_input_of_type(int, "Please give a valid day (1-30)")
        if day in range(1, 31):
            break
    amount = Parser.get_input_of_type(int, "Please give an amount")
    category = Parser.get_input_of_type(str, "Please give a category")

    add(expenses, [day, amount, category])
Beispiel #6
0
def max_day(expenses, parameters):
    """
    Function that gets the day with the biggest expenses
    :param expenses:
    :param parameters:
    :return:
    """

    rule = []

    if Parser.parameters_are_valid(parameters, rule) is False:
        print("Usage: maxday")
        return

    max_day = -1
    sum_exp_per_day = {}

    for expense in expenses:
        day = Expense.get_day(expense)
        amount = Expense.get_amount(expense)
        if day not in sum_exp_per_day.keys():
            sum_exp_per_day[day] = amount
            if max_day is -1:
                max_day = day
            if sum_exp_per_day[max_day] < amount:
                max_day = day
        else:
            sum_exp_per_day[day] += amount
            if sum_exp_per_day[max_day] < sum_exp_per_day[day]:
                max_day = day

    print(max_day)
Beispiel #7
0
def max_per_day(expenses, parameters):
    """
    Function that returns a list of expenses that have the day equal to a given day
    :param expenses: The list to look through
    :param day: The target day
    :return: The list of corresponding days
    """

    usage = "max <day>"

    rule = [int]

    if Parser.parameters_are_valid(parameters, rule) is False:
        print(usage)
        return

    day = int(parameters[0])

    if day not in range(1, 31):
        print(usage)
        return

    max_expense = 0

    for expense in expenses:
        if Expense.get_day(expense) == day:
            amount = Expense.get_amount(expense)
            if amount > max_expense:
                max_expense = amount

    print(max_expense)
Beispiel #8
0
def sum_category(expenses, parameters):
    """
    Function that handles the 'sum' functionality
    Usage: sum <category>
    :param expenses: The expense list
    :param parameters: The list of parameters used for summing
    :return: The sum corresponding to the elements described by the parameters
    """

    rule = [str]
    usage = "sum <category>"

    if Parser.parameters_are_valid(parameters, rule):
        target_category = parameters[0]
        if target_category not in get_all_categories(expenses):
            print("Category {} not found.".format(target_category))
            return

        total = 0
        for expense in expenses:
            if Expense.get_type(expense) == target_category:
                total += Expense.get_amount(expense)
        print(total)
    else:
        print(usage)
Beispiel #9
0
Datei: UI.py Projekt: VicSera/UBB
def menu_max(expenses):
    """
    Launch the menu that corresponds to the 'maxday' command
    :param expenses: The list of expenses to look through
    """

    options = [
        "Get the day with the most expenses",
        "Get the maximum expense in a day"
    ]

    user_choice = Parser.choose(options, "Please choose what max you want:")

    if user_choice is options[0]:
        Functions.max_day(expenses, [])
    elif user_choice is options[1]:
        day = Parser.get_input_of_type(int, "Please pick a day:")
        Functions.max_per_day(expenses, [day])
Beispiel #10
0
Datei: UI.py Projekt: VicSera/UBB
def menu_sum(expenses):
    """
    Launch the menu that corresponds to the 'sum' command
    :param expenses: The list of expenses to sum
    """

    categories = Functions.get_all_categories(expenses)
    category = Parser.choose(categories, "Please choose a category:")

    Functions.sum_category(expenses, [category])
Beispiel #11
0
Datei: UI.py Projekt: VicSera/UBB
def get_menu_type():
    """
    Function that gets called first, to decide what type of menu the user desires
    :return: 1 or 2, corresponding to a command-based interface, or a menu-based one respectively
    """
    print("Please choose an interface type.\n"
          "1. Command-based\n"
          "2. Menu-based")
    while True:
        choice = Parser.get_input_of_type(int, "Choice: ")
        if choice in [1, 2]:
            return choice
Beispiel #12
0
def sort_by(expenses, parameters):
    """
    Sort the expenses in a given day in ascending order
    :param expenses: The expense list to look through
    :param parameters: The parameters for sorting
    """

    usage = "sort <day>\nsort <category>"

    rules = [[int], [str]]
    if Parser.parameters_are_valid(parameters, rules[0]) is True:  # sort <day>
        all_day_entries = get_all_days(expenses)
        target_day = int(parameters[0])

        if target_day not in all_day_entries:
            print("No entry for day {}".format(parameters[0]))
            return

        expenses_in_target_day = get_all_expenses(expenses, day=target_day)
        criterion = lambda e: Expense.get_amount(e)
        expenses_in_target_day.sort(key=criterion)
        list_elements(expenses_in_target_day, [])
    elif Parser.parameters_are_valid(parameters,
                                     rules[1]) is True:  # sort <category>
        all_category_entries = get_all_categories(expenses)
        target_category = parameters[0]

        if target_category not in all_category_entries:
            print("No entry for category {}".format(target_category))
            return

        expenses_in_target_category = get_all_expenses(
            expenses, category=target_category)
        criterion = lambda e: Expense.get_amount(e)
        expenses_in_target_category.sort(key=criterion)
        list_elements(expenses_in_target_category, [])
    else:  # invalid arguments
        print(usage)
        return
Beispiel #13
0
Datei: UI.py Projekt: VicSera/UBB
def menu_filter(expenses):
    """
    Launch the menu that corresponds to the 'filter' command
    :param expenses: The list of expenses to filter
    """

    categories = Functions.get_all_categories(expenses)
    category = Parser.choose(categories, "Please choose a category:")

    restrictions = ['No restrictions', 'Add restriction']
    restriction = Parser.choose(restrictions,
                                "Please choose any further restriction:")

    if restriction is 'No restrictions':
        Functions.filter(expenses, [category])
    elif restriction is 'Add restriction':
        operators = ['<', '>', '=']
        operator = Parser.choose(operators, "Please pick an operator:")
        value = Parser.get_input_of_type(int,
                                         "Please pick a value to compare to:")

        Functions.filter(expenses, [category, operator, value])
Beispiel #14
0
def list_elements(expenses, parameters):
    '''
    Function that handles listing expenses
    Possible parameters:
    list
    list <category>
    list <category> [ < | = | > ] <value>
    :param expenses: Expense list to be listed out
    :param parameters: Parameters used by the listing feature
    '''

    rules = [[], [str], [str, Operator.Operator, int]]

    rule_used = -1

    for rule_index, rule in enumerate(rules):
        if Parser.parameters_are_valid(parameters, rule):
            rule_used = rule_index
            break

    if rule_used == -1:
        print('Usage:\n', 'list\n', 'list <category>\n'
              'list <category> [ < | = | > ] <value>')
    else:
        print_row(to_print=None)
        print_row(to_print='Header')
        print_row(to_print=None)
        if rule_used == 0:  # First case
            for expense in expenses:
                print_row(to_print=expense)
        elif rule_used == 1:  # Second case
            for expense in expenses:
                if Expense.get_type(expense) == parameters[0]:
                    print_row(to_print=expense)
        elif rule_used == 2:  # Third case
            for expense in expenses:
                type_match = Expense.get_type(expense) == parameters[0]
                operator_rule_followed = Operator.operator_map[parameters[1]](
                    Expense.get_amount(expense), int(parameters[2]))
                if operator_rule_followed and type_match:
                    print_row(to_print=expense)
        print_row(to_print=None)
Beispiel #15
0
def remove(expenses, parameters):
    '''
    Function that handles the remove feature in the menu
    Possible parameter structure:
    remove <day>
    remove <start day> to <end day>
    remove <category>
    :param expenses: Expense list to change
    :param parameters: Parameters for the remove feature
    :return:
    '''

    rules = [[int], [int, 'to', int], [str]]

    rule_used = -1

    for rule_index in range(len(
            rules)):  # Figure out which of the three rules the command follows
        if Parser.parameters_are_valid(
                parameters,
                rules[rule_index]):  # Found the corresponding set of rules
            rule_used = rule_index
            break

    if rule_used == -1:  # No rule matched up with the given parameters
        print("Usage:\n"
              "remove <day>\n"
              "remove <start day> to <end day>\n"
              "remove <category>")
    if rule_used == 0:  # First case
        for expense in expenses[:]:
            if Expense.get_day(expense) == int(parameters[0]):
                expenses.remove(expense)
    elif rule_used == 1:  # Second case
        for expense in expenses[:]:
            if int(parameters[0]) <= Expense.get_day(expense) <= int(
                    parameters[2]):
                expenses.remove(expense)
    elif rule_used == 2:  # Third case
        for expense in expenses[:]:
            if Expense.get_type(expense) == parameters[0]:
                expenses.remove(expense)
Beispiel #16
0
def insert(expenses, parameters):
    '''
    Function that inserts a new expense into the list, but this time all three details of an expense have to be specified
    :param expenses: The list of expenses
    :param parameters: The list of parameters
    '''

    # Rule for checking parameter validity
    rule = [int, int,
            str]  # Parameters have to be in day/amount/category format

    if not Parser.parameters_are_valid(parameters, rule) or int(
            parameters[0]) not in range(1, 31):
        print("Invalid parameters for inserting function.")
        print("Usage: insert <day> <sum> <category>")
        return

    expense = Expense.create(int(parameters[0]), int(parameters[1]),
                             parameters[2])

    expenses.append(expense)
Beispiel #17
0
Datei: UI.py Projekt: VicSera/UBB
def menu_interface():
    """
    The main menu-based user interface
    """
    os.system('clear')

    expenses = Expense.initialize_list()
    expenses_history = [copy.deepcopy(expenses)]

    menu_options = [
        "Add an element to the list", "Insert an element to the list",
        "List elements", "Sort elements", "Filter out certain elements",
        "Get maximum", "Sum elements", "Undo", "Exit"
    ]

    functions = {
        menu_options[0]: menu_add,
        menu_options[1]: menu_insert,
        menu_options[2]: menu_list,
        menu_options[3]: menu_sort,
        menu_options[4]: menu_filter,
        menu_options[5]: menu_max,
        menu_options[6]: menu_sum,
        menu_options[7]: None,
        menu_options[8]: menu_exit
    }

    while True:
        function_to_call = functions[Parser.choose(
            menu_options, "Please choose one of the following options:")]
        os.system('clear')

        if function_to_call is None:
            expenses = Functions.undo(expenses_history)
            continue

        function_to_call(expenses)

        if expenses != expenses_history[-1]:
            expenses_history.append(copy.deepcopy(expenses))
Beispiel #18
0
def add(expenses, parameters):
    '''
    Function that handles adding expenses to the expenses list, checking for the day of the month automatically
    :param expenses: The list to modify
    :param parameters: The list of parameters the user inputted for the 'add' command
    The parameters are in the following format:
    add <sum> <category>
    '''

    # Rule for checking parameter validity
    rule = [int,
            str]  # Parameters have to be an int and a str in this exact order

    if not Parser.parameters_are_valid(parameters, rule):
        print("Invalid parameters for adding function.")
        print("Usage: add <sum> <category>")
        return

    expense = Expense.create(int(datetime.now().day), int(parameters[0]),
                             parameters[1])

    expenses.append(expense)