Add Portfolio to Transactions

[fedefailla18]

For the sake of users we need to be able to first save the transaction information (done in /transaction/information). Then, we need to identify transactions to its portfolio. Finally, this portfolio can be shown in a FE view.

Right now we support portoflio view only to holdings. This holdings are manually and static added by a user, we need to leverage this and the amount calculated for the transactions we need to add it here. This will allow us to use an already built platform and save up valuable time.

[fedefailla18]

Project Plan: Visualizing Crypto Portfolio Information

Objective: Enable users to visualize their crypto portfolio, incorporating both manually added holdings and dynamically calculated transactions.

Overview

1. Save Transaction Information: Ensure transaction details are correctly stored.
2. Identify Transactions to Portfolio: Link transactions to the appropriate portfolio.
3. Integrate Transactions into Holdings: Combine manually added holdings with transaction data.
4. Front-End Visualization: Develop a user-friendly interface for portfolio visualization.

Tasks Breakdown

1. Save Transaction Information

• Status: Completed (Endpoint: /transaction/information)
• Action Items: Verify data integrity and performance under load.

2. Identify Transactions to Portfolio

• Steps:
  • Design Database Schema: Ensure the database supports efficient linking of transactions to portfolios.
  • Develop Linking Logic: Implement logic to associate transactions with their respective portfolios based on user ID and asset type.
  • Testing: Validate linking functionality with various transaction scenarios.

3. Integrate Transactions into Holdings

• Current State: Holdings are manually and statically added by users.
• Goal: Dynamically update holdings based on transaction data.
  • This is done but hardcoded for now. Since we only support transactions from Binance upload.

Steps:

1. Update Holdings Model:
   • Include fields for dynamic updates based on transactions.
2. Calculate Current Holdings:
   • Implement logic to update holdings with transaction amounts (BUY/SELL).
3. Aggregate Data:
   • Combine manually added holdings with dynamically calculated ones.
4. Testing:
   • Validate the integration with various portfolios and transactions.

4. Front-End Visualization

• Goal: Provide a comprehensive view of the user's portfolio, showing both manually added holdings and transactions.

Steps:

1. Design UI/UX:
   • Create wireframes and mockups for the portfolio view.
   • Ensure the design is user-friendly and informative.
2. Develop Front-End Components:
   • Use a front-end framework (e.g., React, Angular, Vue.js).
   • Implement components to display portfolio, holdings, and transaction history.
3. Integrate Back-End Data:
   • Develop APIs to fetch holdings and transaction data.
   • Ensure real-time updates or periodic refresh of data.
4. Testing:
   • Perform usability testing with actual users.
   • Ensure cross-browser compatibility and responsiveness.

Detailed Implementation Plan

Database Schema Design

• Tables:
  • Users: Stores user information.
  • Portfolios: Stores portfolio details linked to users.
  • Transactions: Stores transaction details.
  • Holdings: Stores manually added and calculated holdings.
• Relationships:
  • Users -> Portfolios (One-to-Many)
  • Portfolios -> Transactions (One-to-Many)
  • Portfolios -> Holdings (One-to-Many)

Linking Logic

• Backend Services:
  • TransactionService: Fetch transactions and link them to portfolios.
  • PortfolioService: Update holdings based on transaction data.

Aggregate Holdings

• Algorithm:
  1. Fetch all transactions for a portfolio.
  2. Initialize holdings with manually added data.
  3. Iterate through transactions, updating the holdings based on the type (BUY/SELL).
  4. Save the updated holdings back to the database.

UI/UX Design

• Key Components:
  • Portfolio Summary: Overall view of the portfolio.
  • Holdings List: Detailed view of each holding.
  • Transaction History: List of transactions affecting the portfolio.
• Design Tools: Figma, Sketch, Adobe XD.

Front-End Development

• Framework: React (or preferred framework).
• Components:
  • PortfolioView: Main component displaying the portfolio.
  • HoldingsTable: Displays a table of current holdings.
  • TransactionList: Displays a list of transactions.
• API Integration:
  • Use Axios or Fetch API to retrieve data from the backend.

Testing Plan

• Unit Testing: Ensure individual components and services work correctly.
• Integration Testing: Test the interaction between backend services and the frontend.
• User Testing: Gather feedback from users to improve the interface.

Timeline

1. Week 1-2: Database schema design and backend service implementation.
2. Week 3-4: Develop linking logic and integrate transaction data into holdings.
3. Week 5-6: Front-end design and initial development.
4. Week 7-8: Integration, testing, and final adjustments.

Team Roles

• Project Manager: Oversee the project, ensure milestones are met.
• Backend Developers: Implement linking logic and aggregate holdings.
• Front-End Developers: Design and develop the user interface.
• QA Engineers: Conduct testing and ensure quality.
• UI/UX Designers: Design the user interface and ensure a good user experience.

Next Steps

1. Review Plan: Discuss and refine the plan with the team.
2. Assign Tasks: Allocate tasks to team members based on their expertise.
3. Kickoff Meeting: Officially start the project and ensure everyone is aligned.

This plan outlines a clear path to visualize the crypto portfolio, integrating both static holdings and dynamic transaction data.

[fedefailla18]

Finish associating Transactions to holdings for Binance transactions. Now we need to store the rest of the fields calculated in CoinInformationFacade.

[fedefailla18]

Linking Transaction with Holdings and Portfolio. https://github.com/fedefailla18/file-importer/pull/19

[fedefailla18]

Finally here https://github.com/fedefailla18/file-importer/pull/23 we have the whole integration in the BE. Now when uploading a file the endpoint receives a path variable containing the portfolio name. From here if it does not exist, it's created and linked to the transactions. The endpoint is POST /transaction/upload/{{portfolio}}. Then to calculate holdings we can do it by portfolio or by symbol:

• Using the POST /transaction/information/all/{{portfolio}} transactions associated to that portfolio are fetched and use to calculate the holding of each symbol.
• Using POST /transaction/information?symbol=:symbol transactions of that symbol are fetched and processed as the previous bullet point. Although we are doing this, we still need to open the chance to upload files from others portfolios. Once doing this we will be able to de-hardcode the CoinInformationService.setAndSaveHolding set of the portfolio to any.

There are still some improvements to do in the scope of this ticket so I will keep it open for the next iteration.