Merge pull request #7 from Faculty-Projects-Organisation/develop

Some QoL impovements to the repo

Author: shanji97

.github/workflows/dotnet-develop.yml

@@ -0,0 +1,27 @@
+name: Build and Push Docker DEV Image
+
+on:
+  push:
+    branches:
+      - develop
+
+jobs:
+  build-and-push:
+    name: Push Docker DEV image to Docker Hub
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    - name: Login to Docker Hub
+      uses: docker/login-action@v2
+      with:
+        username: ${{ secrets.DOCKERHUB_USERNAME }}
+        password: ${{ secrets.DOCKERHUB_ACCESS_TOKEN }}
+    - name: Build and push Docker image
+      uses: docker/build-push-action@v4
+      with:
+        context: RSOUserMicroServiceAPI/
+        push: true
+        tags: muchacho3alex/rsouserservice:dev
+        file: RSOUserMicroServiceAPI/RSOUserMicroService/Dockerfile

Exercises.md

@@ -0,0 +1,66 @@
+# Exercises
+
+## Exercise 1: Docker Image Preparation
+In this exercise, you will optimize your application's Docker image by organizing it into multiple layers. This involves separating dependencies (libraries) that rarely change into lower layers, while placing your application code in higher layers. You'll then set up continuous integration (CI) using GitHub Actions or another preferred service to automate the build process. This CI/CD pipeline should compile and package all code from the main branch, create a new Docker image with the appropriate tag, and publish the image to a Docker Hub repository.
+
+## Kubernetes
+Securely storing sensitive information like database connection passwords is crucial in Kubernetes. In this exercise, you'll learn how to manage secrets by storing the database connection password in a secret object within Kubernetes. This ensures that sensitive information is kept safe and can be accessed securely by your microservices.
+
+## Exercise 2: Configuration Management
+Effective configuration management is essential for modern microservice architectures. You'll explore concepts such as using environment variables for configuration and separating configuration from code. By defining configuration settings that can be easily changed without recompiling or reinstalling the microservice, you'll ensure flexibility and maintainability in your application.
+
+## Exercise 3: Health Check API and Kubernetes Liveness Probes
+Ensuring the health of your microservices is critical for maintaining system reliability and availability. You'll implement a Health Check API within your services to monitor their health status. Additionally, you'll leverage Kubernetes Liveness Probes to automatically detect and restart unhealthy service instances. This exercise will help you build robust, self-healing microservices that can recover from failures gracefully.
+
+## Exercise 4: Metrics Collection
+Collecting and analyzing metrics is essential for gaining insights into the performance and behavior of your microservices. You'll add endpoints to expose metrics such as request latency, error rates, and resource utilization. By utilizing tools like KumuluzEE Metrics or Datadog, you'll be able to collect and visualize these metrics, enabling you to monitor and optimize your Kubernetes environment effectively.
+
+## Exercise 5: Kubernetes Logs
+Logging is crucial for troubleshooting and debugging microservices deployed in Kubernetes. You'll explore Kubernetes logging mechanisms and implement centralized logging for your microservices. By configuring your microservices to send logs to a centralized logging system, such as logit.io, you'll be able to aggregate and analyze logs from multiple service instances, making it easier to identify and resolve issues.
+
+## Exercise 6: API Documentation with OpenAPI
+Documenting your REST APIs is essential for ensuring interoperability and facilitating collaboration between teams. You'll use OpenAPI specifications to document your APIs, including details such as endpoints, request/response formats, and authentication mechanisms. Additionally, you'll provide a graphical interface for exploring and interacting with your APIs, making it easier for developers to understand and use your services.
+
+## External API Integration
+Incorporating external APIs into your application can extend its functionality and provide access to valuable third-party services. You'll integrate an external API into your microservice application, leveraging tools like RapidAPI to discover and consume APIs. This exercise will give you hands-on experience with integrating external services and handling API requests and responses within your application.
+
+## Advanced Communication Protocol (Optional)
+Implementing asynchronous communication protocols can improve the scalability and resilience of your microservice architecture. In this optional exercise, you'll explore asynchronous REST calls and integrate them into your microservice application. By decoupling services and leveraging asynchronous messaging patterns, you'll be able to handle high loads and improve fault tolerance in your application.
+Don't forget to prepare a simple user interface (web and/or mobile) for your application. The user interface should include a few simple screens that demonstrate the functionality of your application (e.g., uploading images, viewing all user images, displaying one image along with comments, etc.). The user interface should be straightforward, with a focus on showcasing the implemented functionalities of your microservice application.
+
+## Exercise 7: Ingress
+
+Configure an ingress proxy on Kubernetes so that all your microservices are publicly accessible through a single address. You can use the ingress installed on your cloud provider or install any ingress controller, such as NGINX Ingress Controller.
+
+Useful resources:
+- [Ingress Controllers](https://kubernetes.io/docs/concepts/services-networking/ingress-controllers/)
+- [Ingress on Azure](https://docs.microsoft.com/en-us/azure/aks/ingress-basic)
+- [NGINX Ingress Controller](https://kubernetes.github.io/ingress-nginx/)
+
+## Exercise 8: Fault Isolation and Tolerance
+
+Simulate an error in one of the calls between two microservices (e.g., the microservice registers at the wrong address or port, the microservice returns improperly formatted data, etc.). The goal of this task is to limit the impact of errors in individual microservices on the entire application.
+
+You can use KumuluzEE Fault Tolerance to assist in implementing fault resilience. Prepare an appropriate fallback mechanism that will trigger in case of an error in the called microservice. You can use a timer (timeout) in implementing fault resilience. Implement a circuit breaker. Prepare a demonstration showing different states of the circuit breaker (open, half-open, closed). 
+
+Simulate an error again in one of the microservices and observe the application's behavior.
+
+## Exercise 9: Advanced Communication Protocol
+
+Incorporate the GraphQL protocol into your microservice application.
+
+## Optional Task (Exercise 9)
+
+### Stream Processing Systems
+
+Apache Kafka is a stream-processing platform that enables the processing, storing, creation, and reading of events. Support event-driven interaction in your project and sensibly incorporate a stream processing system that allows publishing and subscribing to event streams. Examples of events include IoT device sensor readings, orders, and transactions. Create a single topic, where the producer inserts records into the topic, and the consumer reads records from partitions. You can use KumuluzEE Event Streaming, which supports the Apache Kafka platform. This task earns additional points.
+
+You can find resources on:
+- [KumuluzEE Event Streaming](https://docs.kumuluz.com/event-streaming/master/)
+- [Apache Kafka](https://kafka.apache.org/)
+
+## Optional Task (Exercise 10)
+
+### Advanced Communication Protocol
+
+Incorporate the gRPC protocol into your micr

README.md

@@ -0,0 +1,24 @@
+# User Microservice In ASP .NET 8 [Cloud computing @ FRI UL]
+
+![Build Status](https://img.shields.io/badge/Build-Passing-brightgreen)
+
+A microservice dedicated to handling user CRUD operations for the advertisement web app "Oglasnik" which serves as the project for the course cloud computing.
+
+## Contributors
+- [Aleksander Kovač](https://github.com/shanji97)
+- [Urbanus98](https://github.com/urbanus98)
+
+## Docker
+[![Docker Hub](https://img.shields.io/badge/Build-Passing-brightgreen)](https://hub.docker.com/r/muchacho3alex/rsouserservice/tags)
+
+## Related Repositories
+ [![rso-ad-service](https://img.shields.io/badge/GitHub-rso--ad--service-blue)](https://github.com/Faculty-Projects-Organisation/rso-ad-service)
+ [![rso-discussions-service](https://img.shields.io/badge/GitHub-rso--discussions--service-blue)](https://github.com/Faculty-Projects-Organisation/rso-discussions-service)
+[![rso-transaction-service](https://img.shields.io/badge/GitHub-rso--transaction--service-blue)](https://github.com/Faculty-Projects-Organisation/rso-transaction-service)
+[![kubernetes](https://img.shields.io/badge/GitHub-kubernetes-blue)](https://github.com/Faculty-Projects-Organisation/kubernetes)
+
+## Exercises
+For detailed explanations of each exercise that culminated in this project, refer to the [Exercises.md](Exercises.md) file.
+
+## LinkedIn
+[![LinkedIn](https://img.shields.io/badge/LinkedIn-Profile-blue)](https://www.linkedin.com/in/aleksander-kova%C4%8D-0662a8156/)

RSOUserMicroServiceAPI/RSO.Core/BL/IUserLogic.cs

@@ -4,30 +4,30 @@
 namespace RSO.Core.BL;
 
 /// <summary>
-/// Handles the user logic.
+/// Handles the userId logic.
 /// </summary>
 public interface IUserLogic
 {
     /// <summary>
-    /// Deletes the user.
+    /// Gets the city name from the userId zip code.
     /// </summary>
-    /// <param name="user">The user we would like to delete.</param>
-    /// <returns>Throw error if it fails.</returns>
-    public Task DeleteUserAsync(User user);
+    /// <param name="userZipCode">The userId provided zip code.</param>
+    /// <returns>The name of the city.</returns>
+    public Task<string?> GetCityFromZipCodeAsync(string userZipCode);
 
     /// <summary>
-    /// Gets the city name from the user zip code.
+    /// Deletes the userId.
     /// </summary>
-    /// <param name="userZipCode">The user provided zip code.</param>
-    /// <returns>The name of the city.</returns>
-    public Task<string> GetCityFromZipCodeAsync(string userZipCode);
+    /// <param name="userId">The userId we would like to delete.</param>
+    /// <returns>Throw error if it fails.</returns>
+    public Task<bool> DeleteUserAsync(int userId);
 
     /// <summary>
     /// Gets the JWT.
     /// </summary>
-    /// <param name="existingUser">The user that hopefully exist in our database.</param>
+    /// <param name="existingUser">The userId that hopefully exist in our database.</param>
     /// <returns>JWT token if result is true.</returns>
-    public string GetJwtToken(User existingUser);
+    public string? GetJwtToken(User existingUser);
 
     /// <summary>
     /// Gets all users.
@@ -36,26 +36,26 @@ public interface IUserLogic
     public Task<List<User>> GetAllUsersAsync();
 
     /// <summary>
-    /// Gets user by its Id.
+    /// Gets userId by its Id.
     /// </summary>
-    /// <param name="id">The userId of the user.</param>
-    /// <returns><see cref="User"/> instance, specified by the userId of the user.</returns>
+    /// <param name="id">The userId of the userId.</param>
+    /// <returns><see cref="User"/> instance, specified by the userId of the userId.</returns>
     public Task<User> GetUserByIdAsync(int id);
 
     /// <summary>
-    /// Gets the user based on the provided username or email or password.
+    /// Gets the userId based on the provided username or email or password.
     /// </summary>
-    /// <param name="emailOrUsername"></param>
-    /// <param name="password"></param>
-    /// <returns>The user specified by the email or username and password.</returns>
-    public Task<User> GetUserByUsernameOrEmailAndPasswordAsync(string emailOrUsername, string password);
+    /// <param name="emailOrUsername">User's email or username.</param>
+    /// <param name="password">User's password.</param>
+    /// <returns>The userId specified by the email or username and password.</returns>
+    public User GetUserByUsernameOrEmailAndPassword(string emailOrUsername, string password);
 
     /// <summary>
-    /// Get ads from a certain user.
+    /// Get ads from a certain userId.
     /// </summary>
-    /// <param name="userId"></param>
-    /// <returns></returns>
-    public Task<List<Ad>> GetUsersAdsAsync(int userId);
+    /// <param name="userId">The id of the userId for which the adds are going to be queried.</param>
+    /// <returns>A list of userId's advertisements based on the userId's id.</returns>
+    public Task<List<Ad>?> GetUsersAdsAsync(int userId);
 
     /// <summary>
     /// Checks if the email is unique.
@@ -72,36 +72,36 @@ public interface IUserLogic
     public Task<bool> IsUserNameUniqueAsync(string userName);
 
     /// <summary>
-    /// Implements user registration and insert the user.
+    /// Implements userId registration and insert the userId.
     /// </summary>
     /// <param name="newUser"></param>
     /// <returns>The same <see cref="User"/> object with and userId.</returns>
     public Task<User> RegisterUserAsync(User newUser);
 
     /// <summary>
-    /// Updates the user.
+    /// Updates the userId.
     /// </summary>
     /// <param name="user"><see cref="User"/> instance.</param>
     /// <returns>True, if the username was successfully updated.</returns>
     public Task<bool> UpdateUserAsync(User user);
 
     /// <summary>
-    /// Updates the user data.
+    /// Updates the userId data.
     /// </summary>
-    /// <param name="userData">The new user data.</param>
+    /// <param name="userData">The new userId data.</param>
     /// <returns>True, if the update was successfull.</returns>
     public Task<bool> UpdateUserDataAsync(User userData);
 
     /// <summary>
-    /// Checks if the user exists by username or email or password.
+    /// Checks if the userId exists by username or email or password.
     /// </summary>
     /// <param name="userName">Username.</param>
-    /// <param name="email">The email of the user.</param>
+    /// <param name="email">The email of the userId.</param>
     /// <returns>True, if the username is already taken.</returns>
     public Task<bool> UsernameOrEmailAlreadyTakenAsync(string userName, string email);
 
     /// <summary>
-    /// Gets all the add of a certain user.
+    /// Gets all the add of a certain userId.
     /// </summary>
     /// <param name="userId">User's ID.</param>
     /// <returns>All of the users ads.</returns>

RSOUserMicroServiceAPI/RSO.Core/BL/LogicModels/CityData.cs renamed to RSOUserMicroServiceAPI/RSO.Core/BL/LogicModels/DTO/CityData.cs

@@ -1,6 +1,6 @@
 using Newtonsoft.Json;
 
-namespace RSO.Core.BL.LogicModels;
+namespace RSO.Core.BL.LogicModels.DTO;
 
 /// <summary>
 /// Stores the Zip Code and City from Dejci's API.
@@ -11,11 +11,11 @@ public class CityData
     /// Zip Code.
     /// </summary>
     [JsonProperty("postnaStevilka")]
-    public int CityZip { get; set;}
+    public int ZipCode { get; set; }
 
     /// <summary>
     /// The name of the city that corresponds to the zip code.
     /// </summary>
     [JsonProperty("kraj")]
-    public string City { get; set;}
+    public string? City { get; set; }
 }

RSOUserMicroServiceAPI/RSO.Core/BL/LogicModels/DTO/LoginCredentialsDTO.cs

@@ -0,0 +1,17 @@
+namespace RSO.Core.BL.LogicModels.DTO;
+
+/// <summary>
+/// DTO for the login credentials.
+/// </summary>
+public class LoginCredentialsDTO
+{
+    /// <summary>
+    /// The login credential of the user - email or username.
+    /// </summary>
+    public string? EmailOrUsername { get; set; }
+
+    /// <summary>
+    /// User's password.
+    /// </summary>
+    public string? Password { get; set; }
+}

RSOUserMicroServiceAPI/RSO.Core/BL/LogicModels/DTO/UserDataDTO.cs

@@ -0,0 +1,45 @@
+using RSO.Core.AdModels;
+using RSO.Core.UserModels;
+
+namespace RSO.Core.BL.LogicModels.DTO;
+
+/// <summary>
+/// A custom DTO for returning the needed user data.
+/// </summary>
+/// <remarks>
+/// Get the neccessary data from the user.
+/// </remarks>
+/// <param name="user"><see cref=User""/> instance.</param>
+/// <param name="adsFromTheUser">Advertisements from the user.</param>
+public class UserDataDTO(User user, List<Ad>? adsFromTheUser)
+{
+    /// <summary>
+    /// The date the user was registered on.
+    /// </summary>
+    public string RegisteredOn { get; } = $"Registriran od {user.RegisteredOn.Value:dd.MM.yyyy at H:mm}";
+
+    /// <summary>
+    /// The user id.
+    /// </summary>
+    public int Id { get; } = user.UserId;
+
+    /// <summary>
+    /// The user name.
+    /// </summary>
+    public string UserName { get; } = user.UserName;
+
+    /// <summary>
+    /// The email of the user.
+    /// </summary>
+    public string UserEmail { get; } = user.UserEmail;
+
+    /// <summary>
+    /// The user location based on the zip code and the city.
+    /// </summary>
+    public string UserLocation { get; } = $"{user.UserZipCode}  {user.UserCity}";
+
+    /// <summary>
+    /// The ads that the user has.
+    /// </summary>
+    public List<Ad> Ads { get; } = adsFromTheUser ?? [];
+}