wildwindxy/ikunnect

University of Toronto 2023 Fall CSC207 Final Project

iKunnect

Problem Domain: Chat System

Communication and socializing are vital to us because they're how we connect with others and feel like we belong. It's how we make friends, share experiences, and just enjoy life. So, our team decided to develop a chat system enabling users to stay happy and connected through online chatting.

High-Level Application Description

We aim to build a Chat System that will have the following features:

• send and receive messages
• edit/delete messages
• translation
• group chat & one-to-one messaging
• voice chat
• contact list
• chatbots

We are also planning to develop multiple platforms for our chat system. In particular, our goal is to make it available on both mobile (Android) and web.

API link

Translation: https://www.deepl.com/docs-api

Screenshot of using a tool to try out the API

Sample output of the current code

Task :com.xiaoheizi.IKunnect.main()
Response Code: 200
Response Data: {"translations":[{"detected_source_language":"ZH","text":"Hello world."}]}

ikunnect's Issues

Server Not Correctly Sending Messages Sometimes

Cleanup Task: Delete Logged-In Related Files

Issue Summary:
Post the successful implementation of the 'LoggedIn' use case, certain files and assets previously used in the project are now redundant. This issue proposes their removal to streamline the codebase and reduce clutter.

Background:
With the 'LoggedIn' use case now being the MainView-related ones, several files that were part of the old implementation or used as temporary measures have become unnecessary. Keeping these files in the repository can lead to confusion, maintenance difficulties, and potential technical debt.

Files Suggested for Removal:
List of Specific Files/Folders: All files that contain LoggedIn in their names.
Reasons for Removal: Briefly explain why each file or folder is no longer needed.
Expected Impact:
Cleaner Codebase: Removing these files will help keep the codebase clean and easy to navigate.
Clarity in Documentation: Updating the documentation post-removal will provide clearer guidance to new developers and contributors.
Proposed Steps:
Review the List: Team members are encouraged to review the list of files slated for removal for any potential oversight.
Backup Plan: Before deletion, ensure that backups are made, just in case any file turns out to be needed later.
Update Documentation: Following the removal, update any documentation referencing these files.
Final Check: Perform a final check to ensure no critical functionality is affected post-deletion.
Request for Feedback:
I invite feedback, suggestions, or concerns regarding this proposal. If anyone is aware of reasons why any of these files should be retained, please provide that information as soon as possible.

Timeline:
Barring any objections, I propose to start this cleanup process by Dec 4th, giving enough time for review and feedback.

Errors in Javadoc in SendMessage Use Case

声明在Javadoc引用中有问题
ReceiveMessageDataAccess
ReceiveMessageInputBoundary
ReceiveMessageInteractor
ReceiveMessageOutputData

Connect the front end and back end

Summary
As part of our ongoing development, we need to establish a connection between our front-end application and the back-end services. This integration is critical for enabling seamless communication and data exchange between the two parts of our application.

Objectives
Establish API Endpoints: Identify and set up the necessary API endpoints on the back end that the front end will interact with.
Data Exchange Format: Define and standardize the format for data exchange (e.g., JSON) between the front end and back end.
Front-End Service Integration: Implement service calls on the front end to interact with the back-end APIs.
Error Handling and Feedback: Ensure robust error handling and user feedback mechanisms for network requests.
Key Areas for Integration
User Authentication: Connect the login/signup interfaces with the user authentication services on the back end.

Data Retrieval and Management: Integrate the interfaces responsible for displaying and managing data (e.g., user profiles, settings) with corresponding back-end services.

Real-time Data Interactions: For dynamic components like chat or live updates, set up appropriate WebSockets or long-polling mechanisms.

Challenges to Address
Security: Secure handling of sensitive data and implementation of authorization and authentication checks.
Performance: Efficient handling of requests to ensure a responsive user experience.
Consistency: Data format and API contract consistency between front end and back end.

Steps for Completion
API Design and Documentation: Collaborate with the back-end team to define API contracts.
Front-End Implementation: Develop the necessary service calls and state management on the front end.
Testing and Validation: Test the integrated system thoroughly to ensure functionality and performance.
Iterative Improvements: Based on testing feedback, iterate over the integration to refine and optimize.

Collaboration
This task requires close collaboration between front-end and back-end teams. Regular communication and updates are essential for the timely and effective completion of this integration.

Template Deletion

After all the use cases are implemented, remember to delete the template files in the code project.

Rubric confirmation

Before our presentation, ensure that our group project meets all the rubrics mentioned.
https://q.utoronto.ca/courses/314288/pages/final-project-presentation-expectations?module_item_id=5195829

Double check Clean Architecture Inherence

Description:
To enhance the scalability, maintainability, and testability of Project iKunnect, there is a need to adopt Clean Architecture principles. This implementation will help decouple the system's various components, making the codebase more modular and easier to understand, adapt, and test.

Actors:

Software Developers
System Architects
QA Engineers
Preconditions:

The existing codebase of Project iKunnect is in place.
The development team has a basic understanding of Clean Architecture principles.
Basic Flow:

Training and Knowledge Sharing: Conduct training sessions for the development team to ensure everyone understands Clean Architecture principles.

Assessment of Current Architecture: Review the current architecture of Project iKunnect to identify areas that do not conform to Clean Architecture principles.

Planning: Create a detailed plan for the transition to Clean Architecture, including identifying the layers (Entities, Use Cases, Interface Adapters, Frameworks & Drivers) and defining the dependencies rule.

Refactoring Existing Code: Start the process of refactoring the existing codebase. This might involve breaking down monolithic structures into more modular ones, separating business logic from UI, and ensuring dependency rule compliance.

Developing New Features Following Clean Architecture: Ensure that all new code written for Project iKunnect strictly adheres to Clean Architecture principles.

Continuous Refactoring: As new features are added and the project evolves, continuously refactor the code to align with Clean Architecture.

Code Review and Quality Assurance: Implement a rigorous code review process to ensure all new code adheres to Clean Architecture. QA Engineers should also adapt their testing strategies to align with the new architecture.

Documentation: Update all project documentation to reflect changes in the architecture and provide guidance for future development.

Postconditions:

Project iKunnect codebase is fully compliant with Clean Architecture.
The development team is proficient in applying Clean Architecture principles.
The system is more modular, testable, and maintainable.
Exceptions:

Developers encounter specific scenarios where Clean Architecture principles are challenging to implement. In such cases, the team should discuss and document the reasons and any deviations from the standard.
Special Requirements:

The transition to Clean Architecture should not disrupt the current operational capabilities of Project iKunnect.
Training materials and resources should be made available to the team.

Bug: Login/Signup-View Related

1. Unable to switch back to login view by clicking "log in", after selecting "sign up" button.
2. TextFields in login view are not cleared properly. If first type in "str1" gives a failed login attempt, removing "str1" by pressing delete key, then type in "str2", the SignupData would contain "str2str1" instead of "str2" as wanted.

Test Code for Server

Bug: MainView-Related

1. Current channel label not showing correctly.
2. MainView after signup looks weird.

Main Branch Not Compiling

Test codes

Summary
Our recent pull requests introduced several significant changes, including the PlainTextMessage component, thread pool refactoring, DDoS resilience testing, and others. While initial test cases are in place, there is a clear need to broaden our test coverage to ensure robustness and reliability across these components.

Components Needing Enhanced Test Coverage
PlainTextMessage: Tests to cover various user interactions, edge cases in text rendering, and dynamic content sizing.

Thread Pool and Management Strategy: Comprehensive tests for the new thread pool implementation, including concurrency issues, resource leaks, and performance under stress.

DDoS Resilience and Server Stability: Extended tests to simulate various DDoS attack scenarios, and their impact on server stability and performance.

Message Encryption and Network Handling: Tests to ensure the integrity and security of message encryption and correct handling of network operations.

Goals
Reliability: Ensure that all components behave as expected under various scenarios, including edge cases.
Performance: Verify that the changes do not negatively impact the system's performance, particularly under high load or stress.
Security: Confirm that security measures, particularly in message handling and network communication, are effective and resilient against potential vulnerabilities.
Documentation: Ensure that all tests are well-documented, explaining their purpose and the scenarios they cover.

Proposed Steps
Gap Analysis: Review the current test suite to identify gaps in coverage.
Test Case Development: Develop additional test cases to cover identified gaps.
Review and Integration: Peer review of new tests followed by integration into the continuous testing pipeline.
Continuous Monitoring: Monitor test results and iterate to address any emerging issues or uncovered scenarios.

Request for Contributions
We encourage team members to contribute to this effort by identifying potential scenarios, writing additional tests, and assisting in the review process. Collaboration is key to ensuring our product's quality and reliability.

The code for channel is static right now. Need to discuss problems on ID/Name. Also, need to connect the client & server.

Update the README.md file after completion

SInce we changed some functions and use cases for our project, we should modify our README.md file after all the final use cases are deternined.

Main Branch Not Compiling

In src\main\java\client\TestClientUI.java

Rename Packages

Naming is inconsistent currently.

Bug: Login/Signup-Related

Press signup then login would direct to main view without logging in.

Resolve Merging Conflict

For the current pull request, it is too many commits behind the main branch. Thus, we would need to fix the conflicts before accpeting the pull request.