andrerwolff / pft Goto Github PK

• Make option of credit card when creating new account

Credit cards are handled differently than other accounts in ynab. We can discuss how we want to do it later.

Accounts should be able to be closed. If they are closed, they won't show up on list accounts. I don't think they should be deleted because they will need to be referenced by any reports or look backs showing net-worth over time

Create a budgeting tool to help set up envelopes.

1. Input expected income
2. Input known bills (for bills group)
3. Input savings goal (for goals group)
4. Using remaining funds, create working budget

Using created, balanced budget 'tree' create envelopes/groups accordingly.
It would be nice to create some external file or db table that stores this info for future reference and/or tweaking. JSON? txt?

*Will likely require heavy re-factoring...

We should keep track of who is giving us money and where our money is going

• Create DB Table for Payee
• When entering transactions, allow user to select payee

PFT should validate all input so that the user doesn't blow something up accidentally.

*Idea: Create new module that handles all inputs. whenever user input is required, call the required function or call the function with required argument to handle that specific input case.

Something like:

from PFT import inputValidation as iv

name = iv.account_names()

def account_names()
    while True:
        name = input('enter account name:')
        if name is a valid entry:
            return name
       else:
           print('Try again')

Ongoing reminder for me to comment on the code I am writing.

Allow user to edit transaction details.

• Date
• Amount
• To Envelope
• From Envelope
• To Account
• From Account

All edits should update all impacted info in other tables.

Do you think it would be better to combine the functions for deposits and withdrawals into one transaction function? It can ask the user if the transaction is a deposit or a withdrawal. That way if we need to make any changes to how we want to implement the transaction function we will only need to change it once rather than in the deposit and the withdrawal functions. The option text will be for users to record a transaction.

On a similar note, I think the user should have the option to deposit into any envelope. It should default to the income pool (maybe press y to deposit into income pool), but I think it is more clear if the user knows where the money is going. Also there are some times where you would want to deposit directly into an envelope.

Let me know your thoughts

In the PR I made earlier I addressed this issue in main.py. But the functions also call os.system('clear').

I will move the clear function from the main to functions.py

Maybe we want to make a utils.py file to put this function in because it does not relate to the functionality of the software. For now, I will leave it in functions.py.

Be able to track any debts/liabilities.

We should be able to keep track of debt(student loans/mortgages/consumer debt). Since payments toward these items doesn't change net worth (other than interest payments/fees) they shouldn't be handled as regular expenses.

For example: I make $800 payment to student loans. $150 of that is interest.

My checking account (and Loans envelope) sees -$800, my student loan principal sees +$650 and there is a net withdrawal to the servicer of $150.

Rather than be depressed that my balance decreased by $800, I can be less depressed that my net worth only decreased by $150.

Implement GUI for App

PFT is kind of lame. Lets brainstorm a better name!

So I can remember/reference later what has worked for me. Confirmed with #31

[L] - Local [GH] - GitHub

1. [L] Make sure master is checked out. git checkout master.
2. [GH] Make sure in master branch.
3. [GH] Create new branch for issue (iss#) or hotfix (hotfixM.D) from master branch.
4. [L] Retrieve new branch and up-to-date master from GH. git pull
5. [L] Checkout new branch. git checkout branch_name
6. [L] Make sure you are in the correct branch. git branch
7. [L] Make changes as necessary.
8. [L] Commit changes to branch. git add * and git commit
9. [L] Push branch to GH. git push origin branch_name
10. [GH] Create pull request and check differences.
11. [GH] Assuming all is well, merge branch_name into master.
12. [L] Make sure master is checked out. git checkout master
13. [L] Update local master with updated GH master. git pull
14. [L] Delete local branch if desired. git branch -d branch_name
15. [GH] Delete branch from GH if desired.

Feel free to add something if I missed it.

I have been doing some research, and I think pytest is the best framework/runner to move forward with

Be able to track investment accounts. Web scrape for prices or manual input.

Will likely require its own table and its own transaction table to handle $ > shares.

For Transactions:

• Each transaction should have a 0/1 status attribute if it has cleared the bank.
• Then we add functionality to clear transactions as you balance them against your online banking or bank statement

For Accounts:

• Accounts should have 2 balances: Cleared and Total
• As transactions are cleared in PFT they will total up to the cleared balance, and the difference between total and cleared will be how much your account tracking in PFT is different from your bank account

Unless I'm missing something, this will always return True because of these in lines 21 and 22 in main.py.

f.table_init(conn)
f.env_init(conn)

I deleted the PFT.db file and started up again and it still returns true even though the db is empty

User should be able to split a transaction between several envelopes.

Will need special input validation and sequence to handle this.

Do we need a separate table or column to identify splits?