Month: September 2023

During the previous week, my primary focus was resolving a query related to the entity’s unfulfilled list, ensuring the accurate transmission of data. Initially, I crafted a comprehensive query that retrieves all data without any specific conditions. Once I confirmed the success of this initial test, I proceeded to construct a query with two main conditions. These conditions revolved around the status of the fulfillment date, if it was enabled, the query would retrieve a list of unfulfilled dates based on certain criteria, otherwise, it would generate the standard list. Following thorough testing to ensure the correctness of these implementations, I committed the changes before transitioning to my next task.

My subsequent task involved updating a migration in accordance with Mr. Peter’s instructions. Later on, I moved on to the next task, which entailed pulling changes from another branch for a new feature update. During the initial attempt to pull these changes, I encountered a conflict stemming from a test. After successfully resolving the conflict and merging the changes without issues, I proceeded to rebuild the application.

Continuing to follow the provided guide, I encountered errors, one of which was due to my oversight in not copying the necessary files from cloud before editing and using them. This experience taught me to always remember to update files into my own folders instead of directly using them from cloud. Various tasks, including migration, setting up DBs, configuring certificates, and establishing the access key, were primarily handled by Mr. Peter due to my limited competence in following instructions and addressing bugs throughout the process.

The week concluded with Mr. Peter introducing me to the new feature, with my upcoming responsibilities focused on bug identification and prompt reporting to Mr. Peter if any issues arise. Although last week was marked by significant debugging, stemming from my own limitations, I am determined to learn from these experiences and avoid repeating similar mistakes in the future.

Continuing from the previous week, while wrapping up the implementation of a new feature, I encountered an issue stemming from an outdated wrapper that constrained my ability to configure it according to my requirements. To address this, I took the initiative to create a new wrapper tailored specifically for the feature. However, this decision necessitated adding mappings for the new wrapper. As I approached the final mapping for the feature, Mr. Peter noticed that I had been using the wrong service throughout the process. This led to me creating a read operation for the entity’s list using the CQRS pattern. To guide me, Mr. Peter provided a similarly-pattern example from another entity.

I started by making a specific folder for the entity’s Get List Query, initialising the properties query, and creating the List Dto. The Get List Query Handler class that I created later implemented the IRequestHandler interface and took control of handling the request to obtain a list of entities. It used a particular service interface and the IMapper. I followed the example given within the Handle function, but I soon realised that a new service was needed to obtain the entity list because the current service was unable to satisfy the conditions required. Additionally, I also added a new controller responsible for handling GET requests to retrieve a list of entities based on query and also provide Swagger documentation for the API.

My next step involved creating a new service exclusively for retrieving the entity’s list. Initially, I designed a straightforward query to retrieve the list without any specific conditions. Nevertheless, I made sure the methods were implemented asynchronously.  By implementing these methods in an asynchronous manner, I ensure that the retrieval operations can be performed efficiently and non-blocking. This enables better scalability and responsiveness in the application, especially when dealing with a large number of entities or concurrent requests. To validate the correctness of my implementation, I incorporated unit tests that verified successful scenarios for Read List methods. These tests employed a client to emulate HTTP requests and validate the returned status codes and data.

With the foundational work on the backend completed, I shifted my focus to the UI to confirm that data was being transmitted correctly as intended. After some debugging, I successfully verified its functionality and the data was passing. However, the week concluded, and in the upcoming week, my priority is to ensure that the query for retrieving the list functions flawlessly before I can proceed to the next task.