From 954e1f707bda7e6b88e0ab33fdab8fa1aaa6f602 Mon Sep 17 00:00:00 2001 From: cuqmbr Date: Mon, 20 May 2024 18:26:23 +0300 Subject: [PATCH] initial commit --- .gitignore | 489 ++++++++++++++++++ .../Controllers/AccountController.cs | 155 ++++++ .../Controllers/AuthenticationController.cs | 88 ++++ .../Controllers/BaseController.cs | 11 + .../Controllers/TransactionController.cs | 45 ++ ExpenseTracker.Api/ExpenseTracker.Api.csproj | 25 + .../GlobalExceptionHandlerMiddleware.cs | 212 ++++++++ ExpenseTracker.Api/Program.cs | 71 +++ .../Services/InternationalizationService.cs | 18 + .../Services/SessionUserService.cs | 38 ++ .../AcceptCurrencyHeaderFilter.cs | 21 + ExpenseTracker.Api/appsettings.json | 9 + .../Accounts/AccountDto.cs | 27 + .../Accounts/AccountJsonDto.cs | 26 + .../Commands/Create/CreateAccountCommand.cs | 16 + .../Create/CreateAccountCommandAuthorizer.cs | 32 ++ .../Create/CreateAccountCommandHandler.cs | 59 +++ .../Create/CreateAccountCommandValidator.cs | 20 + .../Commands/Delete/DeleteAccountCommand.cs | 8 + .../Delete/DeleteAccountCommandAuthorizer.cs | 37 ++ .../Delete/DeleteAccountCommandHandler.cs | 31 ++ .../Delete/DeleteAccountCommandValidator.cs | 12 + .../Json/Many/ImportJsonAccountsQuery.cs | 8 + .../Many/ImportJsonAccountsQueryAuthorizer.cs | 23 + .../Many/ImportJsonAccountsQueryHandler.cs | 67 +++ .../Many/ImportJsonAccountsQueryValidator.cs | 11 + .../Import/Json/One/ImportJsonAccountQuery.cs | 8 + .../One/ImportJsonAccountQueryAuthorizer.cs | 23 + .../Json/One/ImportJsonAccountQueryHandler.cs | 71 +++ .../One/ImportJsonAccountQueryValidator.cs | 11 + .../Commands/Update/UpdateAccountCommand.cs | 14 + .../Update/UpdateAccountCommandAuthorized.cs | 32 ++ .../Update/UpdateAccountCommandHandler.cs | 45 ++ .../Update/UpdateAccountCommandValidator.cs | 17 + .../Charts/DailyTransactionsBarChart.cs | 39 ++ .../GetExpenseBarChartQuery.cs | 12 + .../GetExpenseBarChartQueryAuthorizer.cs | 37 ++ .../GetExpenseBarChartQueryHandler.cs | 43 ++ .../GetExpenseBarChartQueryValidator.cs | 15 + .../GetExpenseByCategoryPieChartQuery.cs | 13 + ...xpenseByCategoryPieChartQueryAuthorizer.cs | 37 ++ ...etExpenseByCategoryPieChartQueryHandler.cs | 57 ++ ...ExpenseByCategoryPieChartQueryValidator.cs | 15 + .../GetIncomeBarChartQuery.cs | 12 + .../GetIncomeBarChartQueryAuthorizer.cs | 37 ++ .../GetIncomeBarChartQueryHandler.cs | 43 ++ .../GetIncomeBarChartQueryValidator.cs | 15 + .../GetProfitBarChartQuery.cs | 12 + .../GetProfitBarChartQueryAuthorizer.cs | 37 ++ .../GetProfitBarChartQueryHandler.cs | 41 ++ .../GetProfitBarChartQueryValidator.cs | 15 + .../Export/Csv/One/ExportCsvAccountQuery.cs | 8 + .../One/ExportCsvAccountQueryAuthorizer.cs | 37 ++ .../Csv/One/ExportCsvAccountQueryHandler.cs | 67 +++ .../Csv/One/ExportCsvAccountQueryValidator.cs | 11 + .../Json/Many/ExportJsonAccountsQuery.cs | 5 + .../Many/ExportJsonAccountsQueryAuthorizer.cs | 24 + .../Many/ExportJsonAccountsQueryHandler.cs | 72 +++ .../Many/ExportJsonAccountsQueryValidator.cs | 10 + .../Export/Json/One/ExportJsonAccountQuery.cs | 8 + .../One/ExportJsonAccountQueryAuthorizer.cs | 37 ++ .../Json/One/ExportJsonAccountQueryHandler.cs | 69 +++ .../One/ExportJsonAccountQueryValidator.cs | 11 + .../Accounts/Queries/Get/GetAccountQuery.cs | 8 + .../Queries/Get/GetAccountQueryAuthorizer.cs | 37 ++ .../Queries/Get/GetAccountQueryHandler.cs | 31 ++ .../Queries/Get/GetAccountQueryValidator.cs | 12 + .../GetAccountsWithPaginationQuery.cs | 13 + ...etAccountsWithPaginationQueryAuthorizer.cs | 33 ++ .../GetAccountsWithPaginationQueryHandler.cs | 42 ++ ...GetAccountsWithPaginationQueryValidator.cs | 16 + .../Accounts/TransactionCsvMap.cs | 20 + .../RegisterWithEmailCommand.cs | 8 + .../RegisterWithEmailCommandHandler.cs | 19 + .../RegisterWithEmailValidator.cs | 16 + .../RegisterWithEmailAndPasswordCommand.cs | 10 + ...isterWithEmailAndPasswordCommandHandler.cs | 19 + ...terWithEmailAndPasswordCommandValidator.cs | 23 + .../RenewAccessTokenWithBodyCommand.cs | 8 + .../RenewAccessTokenWithBodyCommandHandler.cs | 19 + ...enewAccessTokenWithBodyCommandValidator.cs | 11 + .../RenewAccessTokenWithCookieCommand.cs | 5 + ...enewAccessTokenWithCookieCommandHandler.cs | 23 + ...ewAccessTokenWithCookieCommandValidator.cs | 17 + .../RevokeRefreshTokenWithBodyCommand.cs | 8 + ...evokeRefreshTokenWithBodyCommandHandler.cs | 19 + ...okeRefreshTokenWithBodyCommandValidator.cs | 11 + .../RevokeRefreshTokenWithBodyCommand.cs | 5 + ...evokeRefreshTokenWithBodyCommandHandler.cs | 23 + ...okeRefreshTokenWithBodyCommandValidator.cs | 17 + .../Queries/Login/LoginQuery.cs | 10 + .../Queries/Login/LoginQueryHandler.cs | 19 + .../Queries/Login/LoginQueryValidator.cs | 16 + .../Authentication/TokensModel.cs | 14 + .../CustomUnAuthorizedResultHandler.cs | 13 + .../MustBeAuthenticatedRequirement.cs | 22 + .../Authorization/MustBeInRolesRequirement.cs | 24 + ...InteractingWithUnOwnedEntityRequirement.cs | 28 + .../Common/Behaviours/LoggingBehaviour.cs | 46 ++ .../Common/Behaviours/ValidationBehaviour.cs | 37 ++ .../Exceptions/CurrencyConverterException.cs | 11 + .../Common/Exceptions/ForbiddenException.cs | 11 + .../Common/Exceptions/LoginException.cs | 10 + .../Common/Exceptions/NotFoundException.cs | 10 + .../Exceptions/RegistrationException.cs | 11 + .../Exceptions/RenewAccessTokenException.cs | 11 + .../Exceptions/RevokeRefreshTokenException.cs | 10 + .../Exceptions/UnAuthorizedException.cs | 10 + .../Common/Exceptions/ValidationException.cs | 22 + .../Common/Extensions/QueryableExtensions.cs | 135 +++++ .../Common/Extensions/StringExtensions.cs | 14 + .../Common/Interfaces/IUnitOfWork.cs | 12 + .../Repositories/IAccountRepository.cs | 5 + .../Repositories/IBaseRepository.cs | 21 + .../Repositories/ITransactionRepository.cs | 5 + .../Services/IAuthenticationService.cs | 16 + .../Services/ICurrencyConverterService.cs | 10 + .../Services/IEmailSenderService.cs | 6 + .../Services/IInternationalizationService.cs | 8 + .../Services/ISessionUserService.cs | 14 + .../Common/Mappings/IMapFrom.cs | 12 + .../Common/Mappings/MappingProfile.cs | 35 ++ .../Common/Models/IdentityRoles.cs | 7 + .../Common/Models/PaginatedList.cs | 47 ++ .../DependencyInjection.cs | 54 ++ .../ExpenseTracker.Application.csproj | 28 + .../Create/CreateTransactionCommand.cs | 16 + .../CreateTransactionCommandAuthorizer.cs | 38 ++ .../Create/CreateTransactionCommandHandler.cs | 44 ++ .../CreateTransactionCommandValidator.cs | 23 + .../Delete/DeleteTransactionCommand.cs | 8 + .../DeleteTransactionCommandAuthorizer.cs | 44 ++ .../Delete/DeleteTransactionCommandHandler.cs | 33 ++ .../DeleteTransactionCommandValidator.cs | 12 + .../Update/UpdateTransactionCommand.cs | 18 + .../UpdateTransactionCommandAuthorized.cs | 57 ++ .../Update/UpdateTransactionCommandHandler.cs | 47 ++ .../UpdateTransactionCommandValidator.cs | 29 ++ .../Queries/Get/GetTransactionQuery.cs | 8 + .../Get/GetTransactionQueryAuthorizer.cs | 44 ++ .../Queries/Get/GetTransactionQueryHandler.cs | 47 ++ .../Get/GetTransactionQueryValidator.cs | 12 + .../GetTransactionsWithPaginationQuery.cs | 13 + ...ansactionsWithPaginationQueryAuthorizer.cs | 40 ++ ...tTransactionsWithPaginationQueryHandler.cs | 42 ++ ...ransactionsWithPaginationQueryValidator.cs | 16 + .../Transactions/TransactionDto.cs | 29 ++ .../Transactions/TransactionJsonDto.cs | 25 + .../Commands/Create/CreateUserCommand.cs | 12 + .../Create/CreateUserCommandAuthorizer.cs | 31 ++ .../Create/CreateUserCommandHandler.cs | 15 + .../Create/CreateUserCommandValidator.cs | 11 + .../Commands/Delete/DeleteUserCommand.cs | 8 + .../Delete/DeleteUserCommandAuthorizer.cs | 31 ++ .../Delete/DeleteUserCommandHandler.cs | 15 + .../Delete/DeleteUserCommandValidator.cs | 12 + .../Commands/Update/UpdateUserCommand.cs | 12 + .../Update/UpdateUserCommandAuthorizer.cs | 31 ++ .../Update/UpdateUserCommandHandler.cs | 15 + .../Update/UpdateUserCommandValidator.cs | 11 + .../Users/Queries/Get/GetUserQuery.cs | 8 + .../Queries/Get/GetUserQueryAuthorizer.cs | 30 ++ .../Users/Queries/Get/GetUserQueryHandler.cs | 20 + .../Queries/Get/GetUserQueryValidator.cs | 12 + .../GetUsersWithPaginationQuery.cs | 11 + .../GetUsersWithPaginationQueryAuthorizer.cs | 30 ++ .../GetUsersWithPaginationQueryHandler.cs | 21 + .../GetUsersWithPaginationQueryValidator.cs | 16 + ExpenseTracker.Application/Users/UserDto.cs | 12 + ExpenseTracker.Domain/Entities/Account.cs | 17 + ExpenseTracker.Domain/Entities/EntityBase.cs | 6 + ExpenseTracker.Domain/Entities/Role.cs | 8 + ExpenseTracker.Domain/Entities/Transaction.cs | 18 + ExpenseTracker.Domain/Entities/User.cs | 12 + ExpenseTracker.Domain/Entities/UserRole.cs | 12 + ExpenseTracker.Domain/Enums/Category.cs | 126 +++++ ExpenseTracker.Domain/Enums/Currency.cs | 37 ++ ExpenseTracker.Domain/Enums/Enumeration.cs | 78 +++ .../ExpenseTracker.Domain.csproj | 9 + .../DependencyInjection.cs | 99 ++++ .../Email/EmailSenderService.cs | 63 +++ .../ExpenseTracker.Infrastructure.csproj | 22 + .../Identity/IdentitySeeder.cs | 114 ++++ .../Identity/Models/ApplicationRole.cs | 5 + .../Identity/Models/ApplicationUser.cs | 8 + .../Identity/Models/RefreshToken.cs | 20 + .../Services/AuthenticationService.cs | 251 +++++++++ .../Services/CurrencyConverterService.cs | 201 +++++++ .../DependencyInjection.cs | 68 +++ .../ExpenseTracker.Persistence.csproj | 27 + .../MongoDb/MongoDbContext.cs | 115 ++++ .../MongoDb/MongoDbUnitOfWork.cs | 47 ++ .../Repositories/AccountMongoDbRepository.cs | 11 + .../Repositories/BaseMongoDbRepository.cs | 68 +++ .../TransactionMongoDbRepository.cs | 11 + .../MongoDb/Serializers/AccountSerializer.cs | 109 ++++ .../Serializers/TransactionSerializer.cs | 110 ++++ .../PostgreSQL/ApplicationDbContext.cs | 26 + .../Configurations/BudgetConfiguration.cs | 62 +++ .../Configurations/EntityBaseConfiguration.cs | 20 + .../Configurations/ExpenseConfiguration.cs | 64 +++ ...Budgets_and_Expenses_relations.Designer.cs | 129 +++++ ...1520_Add_Budgets_and_Expenses_relations.cs | 80 +++ .../ApplicationDbContextModelSnapshot.cs | 126 +++++ .../Repositories/BasePostgreSQLRepository.cs | 55 ++ .../BudgetPostgreSQLRepository.cs | 10 + .../ExpensePostgreSQLRepository.cs | 10 + ExpenseTracker.sln | 46 ++ README.md | 3 + globl.json | 6 + 210 files changed, 7174 insertions(+) create mode 100644 .gitignore create mode 100644 ExpenseTracker.Api/Controllers/AccountController.cs create mode 100644 ExpenseTracker.Api/Controllers/AuthenticationController.cs create mode 100644 ExpenseTracker.Api/Controllers/BaseController.cs create mode 100644 ExpenseTracker.Api/Controllers/TransactionController.cs create mode 100644 ExpenseTracker.Api/ExpenseTracker.Api.csproj create mode 100644 ExpenseTracker.Api/Middlewares/GlobalExceptionHandlerMiddleware.cs create mode 100644 ExpenseTracker.Api/Program.cs create mode 100644 ExpenseTracker.Api/Services/InternationalizationService.cs create mode 100644 ExpenseTracker.Api/Services/SessionUserService.cs create mode 100644 ExpenseTracker.Api/Swashbuckle/OperationFilters/AcceptCurrencyHeaderFilter.cs create mode 100644 ExpenseTracker.Api/appsettings.json create mode 100644 ExpenseTracker.Application/Accounts/AccountDto.cs create mode 100644 ExpenseTracker.Application/Accounts/AccountJsonDto.cs create mode 100644 ExpenseTracker.Application/Accounts/Commands/Create/CreateAccountCommand.cs create mode 100644 ExpenseTracker.Application/Accounts/Commands/Create/CreateAccountCommandAuthorizer.cs create mode 100644 ExpenseTracker.Application/Accounts/Commands/Create/CreateAccountCommandHandler.cs create mode 100644 ExpenseTracker.Application/Accounts/Commands/Create/CreateAccountCommandValidator.cs create mode 100644 ExpenseTracker.Application/Accounts/Commands/Delete/DeleteAccountCommand.cs create mode 100644 ExpenseTracker.Application/Accounts/Commands/Delete/DeleteAccountCommandAuthorizer.cs create mode 100644 ExpenseTracker.Application/Accounts/Commands/Delete/DeleteAccountCommandHandler.cs create mode 100644 ExpenseTracker.Application/Accounts/Commands/Delete/DeleteAccountCommandValidator.cs create mode 100644 ExpenseTracker.Application/Accounts/Commands/Import/Json/Many/ImportJsonAccountsQuery.cs create mode 100644 ExpenseTracker.Application/Accounts/Commands/Import/Json/Many/ImportJsonAccountsQueryAuthorizer.cs create mode 100644 ExpenseTracker.Application/Accounts/Commands/Import/Json/Many/ImportJsonAccountsQueryHandler.cs create mode 100644 ExpenseTracker.Application/Accounts/Commands/Import/Json/Many/ImportJsonAccountsQueryValidator.cs create mode 100644 ExpenseTracker.Application/Accounts/Commands/Import/Json/One/ImportJsonAccountQuery.cs create mode 100644 ExpenseTracker.Application/Accounts/Commands/Import/Json/One/ImportJsonAccountQueryAuthorizer.cs create mode 100644 ExpenseTracker.Application/Accounts/Commands/Import/Json/One/ImportJsonAccountQueryHandler.cs create mode 100644 ExpenseTracker.Application/Accounts/Commands/Import/Json/One/ImportJsonAccountQueryValidator.cs create mode 100644 ExpenseTracker.Application/Accounts/Commands/Update/UpdateAccountCommand.cs create mode 100644 ExpenseTracker.Application/Accounts/Commands/Update/UpdateAccountCommandAuthorized.cs create mode 100644 ExpenseTracker.Application/Accounts/Commands/Update/UpdateAccountCommandHandler.cs create mode 100644 ExpenseTracker.Application/Accounts/Commands/Update/UpdateAccountCommandValidator.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Charts/DailyTransactionsBarChart.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseBarChart/GetExpenseBarChartQuery.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseBarChart/GetExpenseBarChartQueryAuthorizer.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseBarChart/GetExpenseBarChartQueryHandler.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseBarChart/GetExpenseBarChartQueryValidator.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseByCategoryPieChart/GetExpenseByCategoryPieChartQuery.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseByCategoryPieChart/GetExpenseByCategoryPieChartQueryAuthorizer.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseByCategoryPieChart/GetExpenseByCategoryPieChartQueryHandler.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseByCategoryPieChart/GetExpenseByCategoryPieChartQueryValidator.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Charts/GetIncomeBarChart/GetIncomeBarChartQuery.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Charts/GetIncomeBarChart/GetIncomeBarChartQueryAuthorizer.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Charts/GetIncomeBarChart/GetIncomeBarChartQueryHandler.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Charts/GetIncomeBarChart/GetIncomeBarChartQueryValidator.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Charts/GetProfitBarChart/GetProfitBarChartQuery.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Charts/GetProfitBarChart/GetProfitBarChartQueryAuthorizer.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Charts/GetProfitBarChart/GetProfitBarChartQueryHandler.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Charts/GetProfitBarChart/GetProfitBarChartQueryValidator.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Export/Csv/One/ExportCsvAccountQuery.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Export/Csv/One/ExportCsvAccountQueryAuthorizer.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Export/Csv/One/ExportCsvAccountQueryHandler.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Export/Csv/One/ExportCsvAccountQueryValidator.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Export/Json/Many/ExportJsonAccountsQuery.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Export/Json/Many/ExportJsonAccountsQueryAuthorizer.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Export/Json/Many/ExportJsonAccountsQueryHandler.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Export/Json/Many/ExportJsonAccountsQueryValidator.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Export/Json/One/ExportJsonAccountQuery.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Export/Json/One/ExportJsonAccountQueryAuthorizer.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Export/Json/One/ExportJsonAccountQueryHandler.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Export/Json/One/ExportJsonAccountQueryValidator.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Get/GetAccountQuery.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Get/GetAccountQueryAuthorizer.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Get/GetAccountQueryHandler.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/Get/GetAccountQueryValidator.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/GetWithPagination/GetAccountsWithPaginationQuery.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/GetWithPagination/GetAccountsWithPaginationQueryAuthorizer.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/GetWithPagination/GetAccountsWithPaginationQueryHandler.cs create mode 100644 ExpenseTracker.Application/Accounts/Queries/GetWithPagination/GetAccountsWithPaginationQueryValidator.cs create mode 100644 ExpenseTracker.Application/Accounts/TransactionCsvMap.cs create mode 100644 ExpenseTracker.Application/Authentication/Commands/RegisterWithEmail/RegisterWithEmailCommand.cs create mode 100644 ExpenseTracker.Application/Authentication/Commands/RegisterWithEmail/RegisterWithEmailCommandHandler.cs create mode 100644 ExpenseTracker.Application/Authentication/Commands/RegisterWithEmail/RegisterWithEmailValidator.cs create mode 100644 ExpenseTracker.Application/Authentication/Commands/RegisterWithEmailAndPassword/RegisterWithEmailAndPasswordCommand.cs create mode 100644 ExpenseTracker.Application/Authentication/Commands/RegisterWithEmailAndPassword/RegisterWithEmailAndPasswordCommandHandler.cs create mode 100644 ExpenseTracker.Application/Authentication/Commands/RegisterWithEmailAndPassword/RegisterWithEmailAndPasswordCommandValidator.cs create mode 100644 ExpenseTracker.Application/Authentication/Commands/RenewAccessTokenWithBody/RenewAccessTokenWithBodyCommand.cs create mode 100644 ExpenseTracker.Application/Authentication/Commands/RenewAccessTokenWithBody/RenewAccessTokenWithBodyCommandHandler.cs create mode 100644 ExpenseTracker.Application/Authentication/Commands/RenewAccessTokenWithBody/RenewAccessTokenWithBodyCommandValidator.cs create mode 100644 ExpenseTracker.Application/Authentication/Commands/RenewAccessTokenWithCookie/RenewAccessTokenWithCookieCommand.cs create mode 100644 ExpenseTracker.Application/Authentication/Commands/RenewAccessTokenWithCookie/RenewAccessTokenWithCookieCommandHandler.cs create mode 100644 ExpenseTracker.Application/Authentication/Commands/RenewAccessTokenWithCookie/RenewAccessTokenWithCookieCommandValidator.cs create mode 100644 ExpenseTracker.Application/Authentication/Commands/RevokeRefreshTokenWithBody/RevokeRefreshTokenWithBodyCommand.cs create mode 100644 ExpenseTracker.Application/Authentication/Commands/RevokeRefreshTokenWithBody/RevokeRefreshTokenWithBodyCommandHandler.cs create mode 100644 ExpenseTracker.Application/Authentication/Commands/RevokeRefreshTokenWithBody/RevokeRefreshTokenWithBodyCommandValidator.cs create mode 100644 ExpenseTracker.Application/Authentication/Commands/RevokeRefreshTokenWithCookie/RevokeRefreshTokenWithBodyCommand.cs create mode 100644 ExpenseTracker.Application/Authentication/Commands/RevokeRefreshTokenWithCookie/RevokeRefreshTokenWithBodyCommandHandler.cs create mode 100644 ExpenseTracker.Application/Authentication/Commands/RevokeRefreshTokenWithCookie/RevokeRefreshTokenWithBodyCommandValidator.cs create mode 100644 ExpenseTracker.Application/Authentication/Queries/Login/LoginQuery.cs create mode 100644 ExpenseTracker.Application/Authentication/Queries/Login/LoginQueryHandler.cs create mode 100644 ExpenseTracker.Application/Authentication/Queries/Login/LoginQueryValidator.cs create mode 100644 ExpenseTracker.Application/Authentication/TokensModel.cs create mode 100644 ExpenseTracker.Application/Common/Authorization/CustomUnAuthorizedResultHandler.cs create mode 100644 ExpenseTracker.Application/Common/Authorization/MustBeAuthenticatedRequirement.cs create mode 100644 ExpenseTracker.Application/Common/Authorization/MustBeInRolesRequirement.cs create mode 100644 ExpenseTracker.Application/Common/Authorization/MustBeInRolesWhenInteractingWithUnOwnedEntityRequirement.cs create mode 100644 ExpenseTracker.Application/Common/Behaviours/LoggingBehaviour.cs create mode 100644 ExpenseTracker.Application/Common/Behaviours/ValidationBehaviour.cs create mode 100644 ExpenseTracker.Application/Common/Exceptions/CurrencyConverterException.cs create mode 100644 ExpenseTracker.Application/Common/Exceptions/ForbiddenException.cs create mode 100644 ExpenseTracker.Application/Common/Exceptions/LoginException.cs create mode 100644 ExpenseTracker.Application/Common/Exceptions/NotFoundException.cs create mode 100644 ExpenseTracker.Application/Common/Exceptions/RegistrationException.cs create mode 100644 ExpenseTracker.Application/Common/Exceptions/RenewAccessTokenException.cs create mode 100644 ExpenseTracker.Application/Common/Exceptions/RevokeRefreshTokenException.cs create mode 100644 ExpenseTracker.Application/Common/Exceptions/UnAuthorizedException.cs create mode 100644 ExpenseTracker.Application/Common/Exceptions/ValidationException.cs create mode 100644 ExpenseTracker.Application/Common/Extensions/QueryableExtensions.cs create mode 100644 ExpenseTracker.Application/Common/Extensions/StringExtensions.cs create mode 100644 ExpenseTracker.Application/Common/Interfaces/IUnitOfWork.cs create mode 100644 ExpenseTracker.Application/Common/Interfaces/Repositories/IAccountRepository.cs create mode 100644 ExpenseTracker.Application/Common/Interfaces/Repositories/IBaseRepository.cs create mode 100644 ExpenseTracker.Application/Common/Interfaces/Repositories/ITransactionRepository.cs create mode 100644 ExpenseTracker.Application/Common/Interfaces/Services/IAuthenticationService.cs create mode 100644 ExpenseTracker.Application/Common/Interfaces/Services/ICurrencyConverterService.cs create mode 100644 ExpenseTracker.Application/Common/Interfaces/Services/IEmailSenderService.cs create mode 100644 ExpenseTracker.Application/Common/Interfaces/Services/IInternationalizationService.cs create mode 100644 ExpenseTracker.Application/Common/Interfaces/Services/ISessionUserService.cs create mode 100644 ExpenseTracker.Application/Common/Mappings/IMapFrom.cs create mode 100644 ExpenseTracker.Application/Common/Mappings/MappingProfile.cs create mode 100644 ExpenseTracker.Application/Common/Models/IdentityRoles.cs create mode 100644 ExpenseTracker.Application/Common/Models/PaginatedList.cs create mode 100644 ExpenseTracker.Application/DependencyInjection.cs create mode 100644 ExpenseTracker.Application/ExpenseTracker.Application.csproj create mode 100644 ExpenseTracker.Application/Transactions/Commands/Create/CreateTransactionCommand.cs create mode 100644 ExpenseTracker.Application/Transactions/Commands/Create/CreateTransactionCommandAuthorizer.cs create mode 100644 ExpenseTracker.Application/Transactions/Commands/Create/CreateTransactionCommandHandler.cs create mode 100644 ExpenseTracker.Application/Transactions/Commands/Create/CreateTransactionCommandValidator.cs create mode 100644 ExpenseTracker.Application/Transactions/Commands/Delete/DeleteTransactionCommand.cs create mode 100644 ExpenseTracker.Application/Transactions/Commands/Delete/DeleteTransactionCommandAuthorizer.cs create mode 100644 ExpenseTracker.Application/Transactions/Commands/Delete/DeleteTransactionCommandHandler.cs create mode 100644 ExpenseTracker.Application/Transactions/Commands/Delete/DeleteTransactionCommandValidator.cs create mode 100644 ExpenseTracker.Application/Transactions/Commands/Update/UpdateTransactionCommand.cs create mode 100644 ExpenseTracker.Application/Transactions/Commands/Update/UpdateTransactionCommandAuthorized.cs create mode 100644 ExpenseTracker.Application/Transactions/Commands/Update/UpdateTransactionCommandHandler.cs create mode 100644 ExpenseTracker.Application/Transactions/Commands/Update/UpdateTransactionCommandValidator.cs create mode 100644 ExpenseTracker.Application/Transactions/Queries/Get/GetTransactionQuery.cs create mode 100644 ExpenseTracker.Application/Transactions/Queries/Get/GetTransactionQueryAuthorizer.cs create mode 100644 ExpenseTracker.Application/Transactions/Queries/Get/GetTransactionQueryHandler.cs create mode 100644 ExpenseTracker.Application/Transactions/Queries/Get/GetTransactionQueryValidator.cs create mode 100644 ExpenseTracker.Application/Transactions/Queries/GetWithPagination/GetTransactionsWithPaginationQuery.cs create mode 100644 ExpenseTracker.Application/Transactions/Queries/GetWithPagination/GetTransactionsWithPaginationQueryAuthorizer.cs create mode 100644 ExpenseTracker.Application/Transactions/Queries/GetWithPagination/GetTransactionsWithPaginationQueryHandler.cs create mode 100644 ExpenseTracker.Application/Transactions/Queries/GetWithPagination/GetTransactionsWithPaginationQueryValidator.cs create mode 100644 ExpenseTracker.Application/Transactions/TransactionDto.cs create mode 100644 ExpenseTracker.Application/Transactions/TransactionJsonDto.cs create mode 100644 ExpenseTracker.Application/Users/Commands/Create/CreateUserCommand.cs create mode 100644 ExpenseTracker.Application/Users/Commands/Create/CreateUserCommandAuthorizer.cs create mode 100644 ExpenseTracker.Application/Users/Commands/Create/CreateUserCommandHandler.cs create mode 100644 ExpenseTracker.Application/Users/Commands/Create/CreateUserCommandValidator.cs create mode 100644 ExpenseTracker.Application/Users/Commands/Delete/DeleteUserCommand.cs create mode 100644 ExpenseTracker.Application/Users/Commands/Delete/DeleteUserCommandAuthorizer.cs create mode 100644 ExpenseTracker.Application/Users/Commands/Delete/DeleteUserCommandHandler.cs create mode 100644 ExpenseTracker.Application/Users/Commands/Delete/DeleteUserCommandValidator.cs create mode 100644 ExpenseTracker.Application/Users/Commands/Update/UpdateUserCommand.cs create mode 100644 ExpenseTracker.Application/Users/Commands/Update/UpdateUserCommandAuthorizer.cs create mode 100644 ExpenseTracker.Application/Users/Commands/Update/UpdateUserCommandHandler.cs create mode 100644 ExpenseTracker.Application/Users/Commands/Update/UpdateUserCommandValidator.cs create mode 100644 ExpenseTracker.Application/Users/Queries/Get/GetUserQuery.cs create mode 100644 ExpenseTracker.Application/Users/Queries/Get/GetUserQueryAuthorizer.cs create mode 100644 ExpenseTracker.Application/Users/Queries/Get/GetUserQueryHandler.cs create mode 100644 ExpenseTracker.Application/Users/Queries/Get/GetUserQueryValidator.cs create mode 100644 ExpenseTracker.Application/Users/Queries/GetWithPagination/GetUsersWithPaginationQuery.cs create mode 100644 ExpenseTracker.Application/Users/Queries/GetWithPagination/GetUsersWithPaginationQueryAuthorizer.cs create mode 100644 ExpenseTracker.Application/Users/Queries/GetWithPagination/GetUsersWithPaginationQueryHandler.cs create mode 100644 ExpenseTracker.Application/Users/Queries/GetWithPagination/GetUsersWithPaginationQueryValidator.cs create mode 100644 ExpenseTracker.Application/Users/UserDto.cs create mode 100644 ExpenseTracker.Domain/Entities/Account.cs create mode 100644 ExpenseTracker.Domain/Entities/EntityBase.cs create mode 100644 ExpenseTracker.Domain/Entities/Role.cs create mode 100644 ExpenseTracker.Domain/Entities/Transaction.cs create mode 100644 ExpenseTracker.Domain/Entities/User.cs create mode 100644 ExpenseTracker.Domain/Entities/UserRole.cs create mode 100644 ExpenseTracker.Domain/Enums/Category.cs create mode 100644 ExpenseTracker.Domain/Enums/Currency.cs create mode 100644 ExpenseTracker.Domain/Enums/Enumeration.cs create mode 100644 ExpenseTracker.Domain/ExpenseTracker.Domain.csproj create mode 100644 ExpenseTracker.Infrastructure/DependencyInjection.cs create mode 100644 ExpenseTracker.Infrastructure/Email/EmailSenderService.cs create mode 100644 ExpenseTracker.Infrastructure/ExpenseTracker.Infrastructure.csproj create mode 100644 ExpenseTracker.Infrastructure/Identity/IdentitySeeder.cs create mode 100644 ExpenseTracker.Infrastructure/Identity/Models/ApplicationRole.cs create mode 100644 ExpenseTracker.Infrastructure/Identity/Models/ApplicationUser.cs create mode 100644 ExpenseTracker.Infrastructure/Identity/Models/RefreshToken.cs create mode 100644 ExpenseTracker.Infrastructure/Identity/Services/AuthenticationService.cs create mode 100644 ExpenseTracker.Infrastructure/Services/CurrencyConverterService.cs create mode 100644 ExpenseTracker.Persistence/DependencyInjection.cs create mode 100644 ExpenseTracker.Persistence/ExpenseTracker.Persistence.csproj create mode 100644 ExpenseTracker.Persistence/MongoDb/MongoDbContext.cs create mode 100644 ExpenseTracker.Persistence/MongoDb/MongoDbUnitOfWork.cs create mode 100644 ExpenseTracker.Persistence/MongoDb/Repositories/AccountMongoDbRepository.cs create mode 100644 ExpenseTracker.Persistence/MongoDb/Repositories/BaseMongoDbRepository.cs create mode 100644 ExpenseTracker.Persistence/MongoDb/Repositories/TransactionMongoDbRepository.cs create mode 100644 ExpenseTracker.Persistence/MongoDb/Serializers/AccountSerializer.cs create mode 100644 ExpenseTracker.Persistence/MongoDb/Serializers/TransactionSerializer.cs create mode 100644 ExpenseTracker.Persistence/PostgreSQL/ApplicationDbContext.cs create mode 100644 ExpenseTracker.Persistence/PostgreSQL/Configurations/BudgetConfiguration.cs create mode 100644 ExpenseTracker.Persistence/PostgreSQL/Configurations/EntityBaseConfiguration.cs create mode 100644 ExpenseTracker.Persistence/PostgreSQL/Configurations/ExpenseConfiguration.cs create mode 100644 ExpenseTracker.Persistence/PostgreSQL/Migrations/20240408161520_Add_Budgets_and_Expenses_relations.Designer.cs create mode 100644 ExpenseTracker.Persistence/PostgreSQL/Migrations/20240408161520_Add_Budgets_and_Expenses_relations.cs create mode 100644 ExpenseTracker.Persistence/PostgreSQL/Migrations/ApplicationDbContextModelSnapshot.cs create mode 100644 ExpenseTracker.Persistence/PostgreSQL/Repositories/BasePostgreSQLRepository.cs create mode 100644 ExpenseTracker.Persistence/PostgreSQL/Repositories/BudgetPostgreSQLRepository.cs create mode 100644 ExpenseTracker.Persistence/PostgreSQL/Repositories/ExpensePostgreSQLRepository.cs create mode 100644 ExpenseTracker.sln create mode 100644 README.md create mode 100644 globl.json diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..cbed2ba --- /dev/null +++ b/.gitignore @@ -0,0 +1,489 @@ +run.sh +notes.md +dev-scripts/ +ExpenseTracker.Api/appsettings.Development.json + +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. +## +## Get latest from `dotnet new gitignore` + +# dotenv files +.env + +# User-specific files +*.rsuser +*.suo +*.user +*.userosscache +*.sln.docstates + +# User-specific files (MonoDevelop/Xamarin Studio) +*.userprefs + +# Mono auto generated files +mono_crash.* + +# Build results +[Dd]ebug/ +[Dd]ebugPublic/ +[Rr]elease/ +[Rr]eleases/ +x64/ +x86/ +[Ww][Ii][Nn]32/ +[Aa][Rr][Mm]/ +[Aa][Rr][Mm]64/ +bld/ +[Bb]in/ +[Oo]bj/ +[Ll]og/ +[Ll]ogs/ + +# Visual Studio 2015/2017 cache/options directory +.vs/ +# Uncomment if you have tasks that create the project's static files in wwwroot +#wwwroot/ + +# Visual Studio 2017 auto generated files +Generated\ Files/ + +# MSTest test Results +[Tt]est[Rr]esult*/ +[Bb]uild[Ll]og.* + +# NUnit +*.VisualState.xml +TestResult.xml +nunit-*.xml + +# Build Results of an ATL Project +[Dd]ebugPS/ +[Rr]eleasePS/ +dlldata.c + +# Benchmark Results +BenchmarkDotNet.Artifacts/ + +# .NET +project.lock.json +project.fragment.lock.json +artifacts/ + +# Tye +.tye/ + +# ASP.NET Scaffolding +ScaffoldingReadMe.txt + +# StyleCop +StyleCopReport.xml + +# Files built by Visual Studio +*_i.c +*_p.c +*_h.h +*.ilk +*.meta +*.obj +*.iobj +*.pch +*.pdb +*.ipdb +*.pgc +*.pgd +*.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.tmp_proj +*_wpftmp.csproj +*.log +*.tlog +*.vspscc +*.vssscc +.builds +*.pidb +*.svclog +*.scc + +# Chutzpah Test files +_Chutzpah* + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opendb +*.opensdf +*.sdf +*.cachefile +*.VC.db +*.VC.VC.opendb + +# Visual Studio profiler +*.psess +*.vsp +*.vspx +*.sap + +# Visual Studio Trace Files +*.e2e + +# TFS 2012 Local Workspace +$tf/ + +# Guidance Automation Toolkit +*.gpState + +# ReSharper is a .NET coding add-in +_ReSharper*/ +*.[Rr]e[Ss]harper +*.DotSettings.user + +# TeamCity is a build add-in +_TeamCity* + +# DotCover is a Code Coverage Tool +*.dotCover + +# AxoCover is a Code Coverage Tool +.axoCover/* +!.axoCover/settings.json + +# Coverlet is a free, cross platform Code Coverage Tool +coverage*.json +coverage*.xml +coverage*.info + +# Visual Studio code coverage results +*.coverage +*.coveragexml + +# NCrunch +_NCrunch_* +.*crunch*.local.xml +nCrunchTemp_* + +# MightyMoose +*.mm.* +AutoTest.Net/ + +# Web workbench (sass) +.sass-cache/ + +# Installshield output folder +[Ee]xpress/ + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish/ + +# Publish Web Output +*.[Pp]ublish.xml +*.azurePubxml +# Note: Comment the next line if you want to checkin your web deploy settings, +# but database connection strings (with potential passwords) will be unencrypted +*.pubxml +*.publishproj + +# Microsoft Azure Web App publish settings. Comment the next line if you want to +# checkin your Azure Web App publish settings, but sensitive information contained +# in these scripts will be unencrypted +PublishScripts/ + +# NuGet Packages +*.nupkg +# NuGet Symbol Packages +*.snupkg +# The packages folder can be ignored because of Package Restore +**/[Pp]ackages/* +# except build/, which is used as an MSBuild target. +!**/[Pp]ackages/build/ +# Uncomment if necessary however generally it will be regenerated when needed +#!**/[Pp]ackages/repositories.config +# NuGet v3's project.json files produces more ignorable files +*.nuget.props +*.nuget.targets + +# Microsoft Azure Build Output +csx/ +*.build.csdef + +# Microsoft Azure Emulator +ecf/ +rcf/ + +# Windows Store app package directories and files +AppPackages/ +BundleArtifacts/ +Package.StoreAssociation.xml +_pkginfo.txt +*.appx +*.appxbundle +*.appxupload + +# Visual Studio cache files +# files ending in .cache can be ignored +*.[Cc]ache +# but keep track of directories ending in .cache +!?*.[Cc]ache/ + +# Others +ClientBin/ +~$* +*~ +*.dbmdl +*.dbproj.schemaview +*.jfm +*.pfx +*.publishsettings +orleans.codegen.cs + +# Including strong name files can present a security risk +# (https://github.com/github/gitignore/pull/2483#issue-259490424) +#*.snk + +# Since there are multiple workflows, uncomment next line to ignore bower_components +# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) +#bower_components/ + +# RIA/Silverlight projects +Generated_Code/ + +# Backup & report files from converting an old project file +# to a newer Visual Studio version. Backup files are not needed, +# because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML +UpgradeLog*.htm +ServiceFabricBackup/ +*.rptproj.bak + +# SQL Server files +*.mdf +*.ldf +*.ndf + +# Business Intelligence projects +*.rdl.data +*.bim.layout +*.bim_*.settings +*.rptproj.rsuser +*- [Bb]ackup.rdl +*- [Bb]ackup ([0-9]).rdl +*- [Bb]ackup ([0-9][0-9]).rdl + +# Microsoft Fakes +FakesAssemblies/ + +# GhostDoc plugin setting file +*.GhostDoc.xml + +# Node.js Tools for Visual Studio +.ntvs_analysis.dat +node_modules/ + +# Visual Studio 6 build log +*.plg + +# Visual Studio 6 workspace options file +*.opt + +# Visual Studio 6 auto-generated workspace file (contains which files were open etc.) +*.vbw + +# Visual Studio 6 auto-generated project file (contains which files were open etc.) +*.vbp + +# Visual Studio 6 workspace and project file (working project files containing files to include in project) +*.dsw +*.dsp + +# Visual Studio 6 technical files +*.ncb +*.aps + +# Visual Studio LightSwitch build output +**/*.HTMLClient/GeneratedArtifacts +**/*.DesktopClient/GeneratedArtifacts +**/*.DesktopClient/ModelManifest.xml +**/*.Server/GeneratedArtifacts +**/*.Server/ModelManifest.xml +_Pvt_Extensions + +# Paket dependency manager +.paket/paket.exe +paket-files/ + +# FAKE - F# Make +.fake/ + +# CodeRush personal settings +.cr/personal + +# Python Tools for Visual Studio (PTVS) +__pycache__/ +*.pyc + +# Cake - Uncomment if you are using it +# tools/** +# !tools/packages.config + +# Tabs Studio +*.tss + +# Telerik's JustMock configuration file +*.jmconfig + +# BizTalk build output +*.btp.cs +*.btm.cs +*.odx.cs +*.xsd.cs + +# OpenCover UI analysis results +OpenCover/ + +# Azure Stream Analytics local run output +ASALocalRun/ + +# MSBuild Binary and Structured Log +*.binlog + +# NVidia Nsight GPU debugger configuration file +*.nvuser + +# MFractors (Xamarin productivity tool) working folder +.mfractor/ + +# Local History for Visual Studio +.localhistory/ + +# Visual Studio History (VSHistory) files +.vshistory/ + +# BeatPulse healthcheck temp database +healthchecksdb + +# Backup folder for Package Reference Convert tool in Visual Studio 2017 +MigrationBackup/ + +# Ionide (cross platform F# VS Code tools) working folder +.ionide/ + +# Fody - auto-generated XML schema +FodyWeavers.xsd + +# VS Code files for those working on multiple tools +.vscode/* +!.vscode/settings.json +!.vscode/tasks.json +!.vscode/launch.json +!.vscode/extensions.json +*.code-workspace + +# Local History for Visual Studio Code +.history/ + +# Windows Installer files from build outputs +*.cab +*.msi +*.msix +*.msm +*.msp + +# JetBrains Rider +*.sln.iml +.idea + +## +## Visual studio for Mac +## + + +# globs +Makefile.in +*.userprefs +*.usertasks +config.make +config.status +aclocal.m4 +install-sh +autom4te.cache/ +*.tar.gz +tarballs/ +test-results/ + +# Mac bundle stuff +*.dmg +*.app + +# content below from: https://github.com/github/gitignore/blob/master/Global/macOS.gitignore +# General +.DS_Store +.AppleDouble +.LSOverride + +# Icon must end with two \r +Icon + + +# Thumbnails +._* + +# Files that might appear in the root of a volume +.DocumentRevisions-V100 +.fseventsd +.Spotlight-V100 +.TemporaryItems +.Trashes +.VolumeIcon.icns +.com.apple.timemachine.donotpresent + +# Directories potentially created on remote AFP share +.AppleDB +.AppleDesktop +Network Trash Folder +Temporary Items +.apdisk + +# content below from: https://github.com/github/gitignore/blob/master/Global/Windows.gitignore +# Windows thumbnail cache files +Thumbs.db +ehthumbs.db +ehthumbs_vista.db + +# Dump file +*.stackdump + +# Folder config file +[Dd]esktop.ini + +# Recycle Bin used on file shares +$RECYCLE.BIN/ + +# Windows Installer files +*.cab +*.msi +*.msix +*.msm +*.msp + +# Windows shortcuts +*.lnk + +# Vim temporary swap files +*.swp diff --git a/ExpenseTracker.Api/Controllers/AccountController.cs b/ExpenseTracker.Api/Controllers/AccountController.cs new file mode 100644 index 0000000..a54959e --- /dev/null +++ b/ExpenseTracker.Api/Controllers/AccountController.cs @@ -0,0 +1,155 @@ +using Microsoft.AspNetCore.Mvc; +using ExpenseTracker.Application.Common.Models; +using ExpenseTracker.Application.Accounts; +using ExpenseTracker.Application.Accounts.Commands.Create; +using ExpenseTracker.Application.Accounts.Queries.GetWithPagination; +using ExpenseTracker.Application.Accounts.Queries.Get; +using ExpenseTracker.Application.Accounts.Commands.Delete; +using ExpenseTracker.Application.Accounts.Commands.Update; +using ExpenseTracker.Application.Accounts.Queries.Charts; +using ExpenseTracker.Application.Accounts.Queries.Charts.GetExpenseBarChart; +using ExpenseTracker.Application.Accounts.Queries.Charts.GetIncomeBarChart; +using ExpenseTracker.Application.Accounts.Queries.Charts.GetProfitBarChart; +using ExpenseTracker.Application.Accounts.Queries.Charts.GetExpenseByCategoryPieChart; +using ExpenseTracker.Application.Accounts.Queries.Export.Json.One; +using ExpenseTracker.Application.Accounts.Queries.Export.Json.Many; +using ExpenseTracker.Application.Accounts.Queries.Export.Csv.One; +using ExpenseTracker.Application.Accounts.Commands.Import.Json.One; +using ExpenseTracker.Application.Accounts.Commands.Import.Json.Many; + +namespace ExpenseTracker.Api.Controllers; + +[Route("accounts")] +public class AccountController : BaseController +{ + [HttpPost] + public async Task Create([FromBody] CreateAccountCommand command, CancellationToken cancellationToken) + { + return await Mediator.Send(command, cancellationToken); + } + + [HttpGet] + public async Task> GetPage([FromQuery] GetAccountsWithPaginationQuery query, CancellationToken cancellationToken) + { + return await Mediator.Send(query, cancellationToken); + } + + [HttpGet("{id}")] + public async Task Get(string id, CancellationToken cancellationToken) + { + var query = new GetAccountQuery() { Id = id }; + return await Mediator.Send(query, cancellationToken); + } + + [HttpPut] + public async Task Update([FromBody] UpdateAccountCommand command, CancellationToken cancellationToken) + { + return await Mediator.Send(command, cancellationToken); + } + + [HttpDelete] + public async Task Delete([FromBody] DeleteAccountCommand command, CancellationToken cancellationToken) + { + await Mediator.Send(command, cancellationToken); + } + + [HttpGet("{id}/export/json")] + public async Task ExportJsonOne(string id, CancellationToken cancellationToken) + { + var query = new ExportJsonAccountQuery() { Id = id }; + var fileBytes = await Mediator.Send(query, cancellationToken); + var mimeType = "application/json"; + var fileName = $"account_{id}.json"; + + return new FileContentResult(fileBytes, mimeType) + { + FileDownloadName = fileName + }; + } + + [HttpGet("export/json")] + public async Task ExportJsonMany(CancellationToken cancellationToken) + { + var query = new ExportJsonAccountsQuery(); + var fileBytes = await Mediator.Send(query, cancellationToken); + var mimeType = "application/json"; + var fileName = $"accounts.json"; + + return new FileContentResult(fileBytes, mimeType) + { + FileDownloadName = fileName + }; + } + + [HttpGet("{id}/export/csv")] + public async Task ExportCsvOne(string id, CancellationToken cancellationToken) + { + var query = new ExportCsvAccountQuery() { Id = id }; + var fileBytes = await Mediator.Send(query, cancellationToken); + var mimeType = "text/json"; + var fileName = $"account_transactions_{id}.csv"; + + return new FileContentResult(fileBytes, mimeType) + { + FileDownloadName = fileName + }; + } + + [HttpPost("import/json/one")] + public async Task ImportOneJson(IFormFile file, CancellationToken cancellationToken) + { + byte[] fileBytes; + + using (var binaryReader = new BinaryReader(file.OpenReadStream())) + { + fileBytes = binaryReader.ReadBytes((int)file.Length); + } + + var query = new ImportJsonAccountQuery() { File = fileBytes }; + await Mediator.Send(query, cancellationToken); + } + + [HttpPost("import/json/many")] + public async Task ImportManyJson(IFormFile file, CancellationToken cancellationToken) + { + byte[] fileBytes; + + using (var binaryReader = new BinaryReader(file.OpenReadStream())) + { + fileBytes = binaryReader.ReadBytes((int)file.Length); + } + + var query = new ImportJsonAccountsQuery() { File = fileBytes }; + await Mediator.Send(query, cancellationToken); + } + + [HttpGet("{id}/expenseBarChart")] + public async Task GetExpenseBarChart(string id, [FromQuery] GetExpenseBarChartQuery query, CancellationToken cancellationToken) + { + query.AccountId = id; + return await Mediator.Send(query, cancellationToken); + } + + [HttpGet("{id}/incomeBarChart")] + public async Task GetIncomeBarChart(string id, [FromQuery] GetIncomeBarChartQuery query, CancellationToken cancellationToken) + { + query.AccountId = id; + return await Mediator.Send(query, cancellationToken); + } + + [HttpGet("{id}/profitBarChart")] + public async Task GetProfitBarChart(string id, [FromQuery] GetProfitBarChartQuery query, CancellationToken cancellationToken) + { + query.AccountId = id; + return await Mediator.Send(query, cancellationToken); + } + + [HttpGet("{id}/expenseByCategoryPieChart")] + public async Task> GetExpenseByCategoryPieChart(string id, [FromQuery] GetExpenseByCategoryPieChartQuery query, CancellationToken cancellationToken) + { + query.AccountId = id; + var pieChart = await Mediator.Send(query, cancellationToken); + var result = pieChart.ToDictionary(item => item.Key.ToString(), item => item.Value); + return result; + } +} diff --git a/ExpenseTracker.Api/Controllers/AuthenticationController.cs b/ExpenseTracker.Api/Controllers/AuthenticationController.cs new file mode 100644 index 0000000..5b72e76 --- /dev/null +++ b/ExpenseTracker.Api/Controllers/AuthenticationController.cs @@ -0,0 +1,88 @@ +using ExpenseTracker.Application.Authentication; +using ExpenseTracker.Application.Authentication.Commands.RegisterWithEmail; +using ExpenseTracker.Application.Authentication.Commands.RegisterWithEmailAndPassword; +using ExpenseTracker.Application.Authentication.Queries.Login; +using ExpenseTracker.Application.Authentication.Commands.RenewAccessTokenWithBody; +using ExpenseTracker.Application.Authentication.Commands.RenewAccessTokenWithCookie; +using ExpenseTracker.Application.Authentication.Commands.RevokeRefreshTokenWithCookie; +using ExpenseTracker.Application.Authentication.Commands.RevokeRefreshTokenWithBody; +using Microsoft.AspNetCore.Mvc; + +namespace ExpenseTracker.Api.Controllers; + +[Route("authentication")] +public class AuthenticationController : BaseController +{ + [HttpPost("registerWithEmail")] + public async Task RegisterWithEmail([FromBody] RegisterWithEmailCommand command, CancellationToken cancellationToken) + { + await Mediator.Send(command, cancellationToken); + } + + [HttpPost("registerWithEmailAndPassword")] + public async Task RegisterWithEmailAndPassword([FromBody] RegisterWithEmailAndPasswordCommand command, CancellationToken cancellationToken) + { + await Mediator.Send(command, cancellationToken); + } + + [HttpPost("loginWithBody")] + public async Task LoginWithBody([FromBody] LoginQuery query, CancellationToken cancellationToken) + { + return await Mediator.Send(query, cancellationToken); + } + + [HttpPost("loginWithCookie")] + public async Task LoginWithCookie([FromBody] LoginQuery query, CancellationToken cancellationToken) + { + var tokens = await Mediator.Send(query, cancellationToken); + + HttpContext.Response.Cookies.Delete("accessToken"); + HttpContext.Response.Cookies.Delete("refreshToken"); + + var cookieOptions = new CookieOptions() { Path = "/", Expires = DateTimeOffset.MaxValue, HttpOnly = true }; + HttpContext.Response.Cookies.Append("accessToken", tokens.AccessToken, cookieOptions); + HttpContext.Response.Cookies.Append("refreshToken", tokens.RefreshToken, cookieOptions); + + return tokens; + } + + [HttpPost("renewAccessTokenWithBody")] + public async Task RenewAccessTokenWithBody([FromBody] RenewAccessTokenWithBodyCommand command, CancellationToken cancellationToken) + { + var tokens = await Mediator.Send(command, cancellationToken); + + HttpContext.Response.Cookies.Delete("accessToken"); + + var cookieOptions = new CookieOptions() { Path = "/", Expires = DateTimeOffset.MaxValue, HttpOnly = true }; + HttpContext.Response.Cookies.Append("accessToken", tokens.AccessToken, cookieOptions); + + return tokens; + } + + [HttpPost("renewAccessTokenWithCookie")] + public async Task RenewAccessTokenWithCookie([FromBody] RenewAccessTokenWithCookieCommand command, CancellationToken cancellationToken) + { + var tokens = await Mediator.Send(command, cancellationToken); + + HttpContext.Response.Cookies.Delete("accessToken"); + + var cookieOptions = new CookieOptions() { Path = "/", Expires = DateTimeOffset.MaxValue, HttpOnly = true }; + HttpContext.Response.Cookies.Append("accessToken", tokens.AccessToken, cookieOptions); + + return tokens; + } + + [HttpPost("revokeRefreshTokenWithBody")] + public async Task RevokeRefreshTokenWithBody([FromBody] RevokeRefreshTokenWithBodyCommand command, CancellationToken cancellationToken) + { + await Mediator.Send(command, cancellationToken); + } + + [HttpPost("revokeRefreshTokenWithCookie")] + public async Task RevokeRefreshTokenWithCookie([FromBody] RevokeRefreshTokenWithCookieCommand command, CancellationToken cancellationToken) + { + await Mediator.Send(command, cancellationToken); + HttpContext.Response.Cookies.Delete("accessToken"); + HttpContext.Response.Cookies.Delete("refreshToken"); + } +} diff --git a/ExpenseTracker.Api/Controllers/BaseController.cs b/ExpenseTracker.Api/Controllers/BaseController.cs new file mode 100644 index 0000000..8fbbd45 --- /dev/null +++ b/ExpenseTracker.Api/Controllers/BaseController.cs @@ -0,0 +1,11 @@ +using MediatR; +using Microsoft.AspNetCore.Mvc; + +namespace ExpenseTracker.Api.Controllers; + +[ApiController] +public class BaseController : ControllerBase +{ + private IMediator _mediator; + protected IMediator Mediator => _mediator ??= HttpContext.RequestServices.GetService(); +} diff --git a/ExpenseTracker.Api/Controllers/TransactionController.cs b/ExpenseTracker.Api/Controllers/TransactionController.cs new file mode 100644 index 0000000..1e8ab04 --- /dev/null +++ b/ExpenseTracker.Api/Controllers/TransactionController.cs @@ -0,0 +1,45 @@ +using Microsoft.AspNetCore.Mvc; +using ExpenseTracker.Application.Transactions; +using ExpenseTracker.Application.Transactions.Commands.Create; +using ExpenseTracker.Application.Transactions.Commands.Delete; +using ExpenseTracker.Application.Transactions.Commands.Update; +using ExpenseTracker.Application.Transactions.Queries.Get; +using ExpenseTracker.Application.Common.Models; +using ExpenseTracker.Application.Transactions.Queries.GetWithPagination; + +namespace ExpenseTracker.Api.Controllers; + +[Route("transactions")] +public class TransactionController : BaseController +{ + [HttpPost] + public async Task Create([FromBody] CreateTransactionCommand command, CancellationToken cancellationToken) + { + return await Mediator.Send(command, cancellationToken); + } + + [HttpGet] + public async Task> GetPage([FromQuery] GetTransactionsWithPaginationQuery query, CancellationToken cancellationToken) + { + return await Mediator.Send(query, cancellationToken); + } + + [HttpGet("{id}")] + public async Task Get(string id, CancellationToken cancellationToken) + { + var query = new GetTransactionQuery() { Id = id }; + return await Mediator.Send(query, cancellationToken); + } + + [HttpPut] + public async Task Update([FromBody] UpdateTransactionCommand command, CancellationToken cancellationToken) + { + return await Mediator.Send(command, cancellationToken); + } + + [HttpDelete] + public async Task Delete([FromBody] DeleteTransactionCommand command, CancellationToken cancellationToken) + { + await Mediator.Send(command, cancellationToken); + } +} diff --git a/ExpenseTracker.Api/ExpenseTracker.Api.csproj b/ExpenseTracker.Api/ExpenseTracker.Api.csproj new file mode 100644 index 0000000..616d9cf --- /dev/null +++ b/ExpenseTracker.Api/ExpenseTracker.Api.csproj @@ -0,0 +1,25 @@ + + + + + + + + + + + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + + + + + + + net8.0 + enable + enable + + + diff --git a/ExpenseTracker.Api/Middlewares/GlobalExceptionHandlerMiddleware.cs b/ExpenseTracker.Api/Middlewares/GlobalExceptionHandlerMiddleware.cs new file mode 100644 index 0000000..f520960 --- /dev/null +++ b/ExpenseTracker.Api/Middlewares/GlobalExceptionHandlerMiddleware.cs @@ -0,0 +1,212 @@ +using ExpenseTracker.Application.Common.Exceptions; +using Microsoft.AspNetCore.Mvc; +using System.Diagnostics; + +namespace ExpenseTracker.Api.Middlewares; + +public class GlobalExceptionHandlerMiddleware : IMiddleware +{ + class ProblemDetailsWithTraceId : ProblemDetails + { + public string TraceId { get; init; } = Activity.Current?.TraceId.ToString(); + } + + private readonly Dictionary> _exceptionHandlers; + private readonly ILogger _logger; + + public GlobalExceptionHandlerMiddleware(ILogger logger) + { + // Register known exception types and handlers. + _exceptionHandlers = new() + { + { typeof(ValidationException), HandleValidationException }, + { typeof(RegistrationException), HandleRegistrationException }, + { typeof(LoginException), HandleLoginException }, + { typeof(RenewAccessTokenException), HandleRenewAccessTokenException }, + { typeof(RevokeRefreshTokenException), HandleRevokeRefreshTokenException }, + { typeof(NotFoundException), HandleNotFoundException }, + { typeof(UnAuthorizedException), HandleUnAuthorizedException }, + { typeof(ForbiddenException), HandleForbiddenException }, + { typeof(CurrencyConverterException), HandleCurrencyConverterException }, + }; + + _logger = logger; + } + + public async Task InvokeAsync(HttpContext context, RequestDelegate next) + { + try + { + await next(context); + } + catch (Exception exception) + { + var exceptionType = exception.GetType(); + + _logger.LogInformation( + "{@DateUtc} {@TimeUtc} {@TraceId} {@SpanId} Interrupted with {@ExceptionType}.", + DateTime.UtcNow.ToString("yyyy-MM-dd"), + DateTime.UtcNow.ToString("HH:mm:ss.FFF"), + Activity.Current?.TraceId.ToString(), + Activity.Current?.SpanId.ToString(), + exceptionType); + + if (_exceptionHandlers.ContainsKey(exceptionType)) + { + await _exceptionHandlers[exceptionType].Invoke(context, exception); + return; + } + + await HandleUnhandledExceptionException(context, exception); + } + } + + private async Task HandleValidationException(HttpContext context, Exception exception) + { + var ex = (ValidationException)exception; + + context.Response.StatusCode = StatusCodes.Status400BadRequest; + context.Response.ContentType = "application/problem+json"; + + await context.Response.WriteAsJsonAsync(new HttpValidationProblemDetails(ex.Errors) + { + Status = StatusCodes.Status400BadRequest, + Type = "https://datatracker.ietf.org/doc/html/rfc7231#section-6.5.1", + Title = "One or more validation errors occurred.", + Detail = "Provided data doesn't satisfy validation requirements." + }); + } + + private async Task HandleRegistrationException(HttpContext context, Exception exception) + { + context.Response.StatusCode = StatusCodes.Status400BadRequest; + context.Response.ContentType = "application/problem+json"; + + await context.Response.WriteAsJsonAsync(new ProblemDetailsWithTraceId() + { + Status = StatusCodes.Status400BadRequest, + Type = "https://datatracker.ietf.org/doc/html/rfc9110#name-400-bad-request", + Title = "Registration failed.", + Detail = "Check your credentials." + }); + } + + private async Task HandleLoginException(HttpContext context, Exception exception) + { + context.Response.StatusCode = StatusCodes.Status400BadRequest; + context.Response.ContentType = "application/problem+json"; + + await context.Response.WriteAsJsonAsync(new ProblemDetailsWithTraceId() + { + Status = StatusCodes.Status400BadRequest, + Type = "https://datatracker.ietf.org/doc/html/rfc9110#name-400-bad-request", + Title = "Login failed.", + Detail = "Provided email and/or password are invalid." + }); + } + + private async Task HandleRenewAccessTokenException(HttpContext context, Exception exception) + { + context.Response.StatusCode = StatusCodes.Status400BadRequest; + context.Response.ContentType = "application/problem+json"; + + await context.Response.WriteAsJsonAsync(new ProblemDetailsWithTraceId() + { + Status = StatusCodes.Status400BadRequest, + Type = "https://datatracker.ietf.org/doc/html/rfc9110#name-400-bad-request", + Title = "Access token renewal failed.", + Detail = "Check validity of your refresh token." + }); + } + + private async Task HandleRevokeRefreshTokenException(HttpContext context, Exception exception) + { + context.Response.StatusCode = StatusCodes.Status400BadRequest; + context.Response.ContentType = "application/problem+json"; + + await context.Response.WriteAsJsonAsync(new ProblemDetailsWithTraceId() + { + Status = StatusCodes.Status400BadRequest, + Type = "https://datatracker.ietf.org/doc/html/rfc9110#name-400-bad-request", + Title = "Refresh token revocation failed.", + Detail = "Check validity of your refresh token." + }); + } + + private async Task HandleNotFoundException(HttpContext context, Exception exception) + { + context.Response.StatusCode = StatusCodes.Status404NotFound; + context.Response.ContentType = "application/problem+json"; + + await context.Response.WriteAsJsonAsync(new ProblemDetailsWithTraceId() + { + Status = StatusCodes.Status404NotFound, + Type = "https://datatracker.ietf.org/doc/html/rfc9110#name-404-not-found", + Title = "One or more resources was not found.", + Detail = "Check validity of input data." + }); + } + + private async Task HandleUnAuthorizedException(HttpContext context, Exception exception) + { + context.Response.StatusCode = StatusCodes.Status401Unauthorized; + context.Response.ContentType = "application/problem+json"; + + await context.Response.WriteAsJsonAsync(new ProblemDetailsWithTraceId() + { + Status = StatusCodes.Status401Unauthorized, + Type = "https://datatracker.ietf.org/doc/html/rfc9110#name-401-unauthorized", + Title = "Request lacks valid authentication credentials for the target resource.", + }); + } + + private async Task HandleForbiddenException(HttpContext context, Exception exception) + { + context.Response.StatusCode = StatusCodes.Status403Forbidden; + context.Response.ContentType = "application/problem+json"; + + await context.Response.WriteAsJsonAsync(new ProblemDetailsWithTraceId() + { + Status = StatusCodes.Status403Forbidden, + Type = "https://datatracker.ietf.org/doc/html/rfc9110#name-403-forbidden", + Title = "Server refuses to fulfill the request.", + }); + } + + private async Task HandleCurrencyConverterException(HttpContext context, Exception exception) + { + context.Response.StatusCode = StatusCodes.Status500InternalServerError; + context.Response.ContentType = "application/problem+json"; + + await context.Response.WriteAsJsonAsync(new ProblemDetailsWithTraceId() + { + Status = StatusCodes.Status500InternalServerError, + Type = "https://datatracker.ietf.org/doc/html/rfc9110#name-500-internal-server-error", + Title = "Unable to communicate with currency exchage api.", + Detail = "Use default currency to query items without conversion." + }); + } + + private async Task HandleUnhandledExceptionException(HttpContext context, Exception exception) + { + context.Response.StatusCode = StatusCodes.Status500InternalServerError; + context.Response.ContentType = "application/problem+json"; + + await context.Response.WriteAsJsonAsync(new ProblemDetailsWithTraceId() + { + Status = StatusCodes.Status500InternalServerError, + Type = "https://datatracker.ietf.org/doc/html/rfc9110#name-500-internal-server-error", + Title = "One or more internal server errors occured.", + Detail = "Report this error to service's support team.", + }); + + _logger.LogError( + "{@DateUtc} {@TimeUtc} {@TraceId} {@SpanId} Unhandled exception.\n{@ExceptionMessage}.\n{@ExceptionStackTrace}.", + DateTime.UtcNow.ToString("yyyy-MM-dd"), + DateTime.UtcNow.ToString("HH:mm:ss.FFF"), + Activity.Current?.TraceId.ToString(), + Activity.Current?.SpanId.ToString(), + exception.Message, + exception.StackTrace); + } +} diff --git a/ExpenseTracker.Api/Program.cs b/ExpenseTracker.Api/Program.cs new file mode 100644 index 0000000..cfaf740 --- /dev/null +++ b/ExpenseTracker.Api/Program.cs @@ -0,0 +1,71 @@ +using Microsoft.OpenApi.Models; +using ExpenseTracker.Api.Middlewares; +using ExpenseTracker.Infrastructure; +using ExpenseTracker.Application; +using ExpenseTracker.Persistence; +using ExpenseTracker.Infrastructure.Identity; +using ExpenseTracker.Api.Services; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Api.Swashbuckle.OperationFilters; + +var builder = WebApplication.CreateBuilder(args); + + +builder.Services.AddPersistence(builder.Configuration); +builder.Services.AddInfrastructure(builder.Configuration); +builder.Services.AddApplication(); + +builder.Services.AddAuthorization(); +builder.Services.AddControllers(); + +builder.Services.AddSwaggerGen(options => +{ + options.OperationFilter(); + options.EnableAnnotations(); + options.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme + { + Scheme = "Bearer", + BearerFormat = "Json Web Token", + In = ParameterLocation.Header, + Name = "Authorization", + Description = "Bearer Authentication With Json Web Token", + Type = SecuritySchemeType.Http + }); + options.AddSecurityRequirement(new OpenApiSecurityRequirement + { + { + new OpenApiSecurityScheme + { + Reference = new OpenApiReference + { + Id = "Bearer", + Type = ReferenceType.SecurityScheme + } + }, + new List() + } + }); +}); + +builder.Services.AddTransient(); +builder.Services.AddScoped(); +builder.Services.AddScoped(); + + +var app = builder.Build(); + + +app.UseAuthentication(); +app.UseAuthorization(); + +app.UseMiddleware(); + +app.MapControllers(); + +app.UseSwagger(); +app.UseSwaggerUI(); + +var scope = app.Services.CreateScope(); +IdentitySeeder.SeedIdentity(scope); + +app.Run(); diff --git a/ExpenseTracker.Api/Services/InternationalizationService.cs b/ExpenseTracker.Api/Services/InternationalizationService.cs new file mode 100644 index 0000000..5213245 --- /dev/null +++ b/ExpenseTracker.Api/Services/InternationalizationService.cs @@ -0,0 +1,18 @@ +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Domain.Enums; + +namespace ExpenseTracker.Api.Services; + +public class InternationalizationService : IInternationalizationService +{ + private readonly HttpContext _httpContext; + + public InternationalizationService(IHttpContextAccessor httpContextAccessor) + { + _httpContext = httpContextAccessor.HttpContext!; + + Currency = Currency.FromName(_httpContext.Request.Headers["Accept-Currency"]) ?? Currency.Default; + } + + public Currency Currency { get; init; } +} diff --git a/ExpenseTracker.Api/Services/SessionUserService.cs b/ExpenseTracker.Api/Services/SessionUserService.cs new file mode 100644 index 0000000..aecceba --- /dev/null +++ b/ExpenseTracker.Api/Services/SessionUserService.cs @@ -0,0 +1,38 @@ +using System.IdentityModel.Tokens.Jwt; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Application.Common.Models; + +namespace ExpenseTracker.Api.Services; + +public class SessionUserService : ISessionUserService +{ + private readonly HttpContext _httpContext; + + public SessionUserService(IHttpContextAccessor httpContextAccessor) + { + _httpContext = httpContextAccessor.HttpContext!; + } + + public string? Id => _httpContext.User.Claims + .FirstOrDefault(c => c.Properties + .Any(p => p.Value == JwtRegisteredClaimNames.Sub)) + ?.Value; + + public string? Email => _httpContext.User.Claims + .FirstOrDefault(c => c.Properties + .Any(p => p.Value == JwtRegisteredClaimNames.Email)) + ?.Value; + + public ICollection Roles => _httpContext.User.Claims + .Where(c => c.Properties + .Any(p => p.Value == "roles")) + .Select(c => c.Value) + .ToArray(); + + public bool IsAdministrator => Roles.Contains(IdentityRoles.Administrator.ToString()); + + public bool IsAuthenticated => Id != null; + + public string? AccessToken => _httpContext.Request.Cookies["accessToken"]; + public string? RefreshToken => _httpContext.Request.Cookies["refreshToken"]; +} diff --git a/ExpenseTracker.Api/Swashbuckle/OperationFilters/AcceptCurrencyHeaderFilter.cs b/ExpenseTracker.Api/Swashbuckle/OperationFilters/AcceptCurrencyHeaderFilter.cs new file mode 100644 index 0000000..65cb02a --- /dev/null +++ b/ExpenseTracker.Api/Swashbuckle/OperationFilters/AcceptCurrencyHeaderFilter.cs @@ -0,0 +1,21 @@ +using Microsoft.OpenApi.Models; +using Swashbuckle.AspNetCore.SwaggerGen; + +namespace ExpenseTracker.Api.Swashbuckle.OperationFilters; + +public class AcceptCurrencyHeaderFilter : IOperationFilter +{ + public void Apply(OpenApiOperation operation, OperationFilterContext context) + { + if (operation.Parameters == null) + operation.Parameters = new List(); + + operation.Parameters.Add(new OpenApiParameter + { + Name = "Accept-Currency", + In = ParameterLocation.Header, + Schema = new OpenApiSchema { Type = "String" }, + Required = false + }); + } +} diff --git a/ExpenseTracker.Api/appsettings.json b/ExpenseTracker.Api/appsettings.json new file mode 100644 index 0000000..10f68b8 --- /dev/null +++ b/ExpenseTracker.Api/appsettings.json @@ -0,0 +1,9 @@ +{ + "Logging": { + "LogLevel": { + "Default": "Information", + "Microsoft.AspNetCore": "Warning" + } + }, + "AllowedHosts": "*" +} diff --git a/ExpenseTracker.Application/Accounts/AccountDto.cs b/ExpenseTracker.Application/Accounts/AccountDto.cs new file mode 100644 index 0000000..3ad3288 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/AccountDto.cs @@ -0,0 +1,27 @@ +using AutoMapper; +using ExpenseTracker.Application.Common.Mappings; +using ExpenseTracker.Domain.Entities; + +namespace ExpenseTracker.Application.Accounts; + +public class AccountDto : IMapFrom +{ + public string Id { get; set; } + + public string Name { get; set; } + + public string? Description { get; set; } + + public string Currency { get; set; } + + public string UserId { get; set; } + + public void Mapping(Profile profile) + { + profile.CreateMap() + .ForMember(d => d.Currency, opt => opt.MapFrom(s => s.Currency.Name)); + + profile.CreateMap() + .ForMember(d => d.Currency, opt => opt.MapFrom(s => Domain.Enums.Currency.FromName(s.Currency))); + } +} diff --git a/ExpenseTracker.Application/Accounts/AccountJsonDto.cs b/ExpenseTracker.Application/Accounts/AccountJsonDto.cs new file mode 100644 index 0000000..78df3c6 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/AccountJsonDto.cs @@ -0,0 +1,26 @@ +using AutoMapper; +using ExpenseTracker.Application.Common.Mappings; +using ExpenseTracker.Application.Transactions; +using ExpenseTracker.Domain.Entities; + +namespace ExpenseTracker.Application.Accounts; + +public class AccountJsonDto : IMapFrom +{ + public string Name { get; set; } + + public string? Description { get; set; } + + public string Currency { get; set; } + + public IEnumerable? Transactions { get; set; } + + public void Mapping(Profile profile) + { + profile.CreateMap() + .ForMember(d => d.Currency, opt => opt.MapFrom(s => s.Currency.Name)); + + profile.CreateMap() + .ForMember(d => d.Currency, opt => opt.MapFrom(s => Domain.Enums.Currency.FromName(s.Currency))); + } +} diff --git a/ExpenseTracker.Application/Accounts/Commands/Create/CreateAccountCommand.cs b/ExpenseTracker.Application/Accounts/Commands/Create/CreateAccountCommand.cs new file mode 100644 index 0000000..2cc1ca8 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Commands/Create/CreateAccountCommand.cs @@ -0,0 +1,16 @@ +using MediatR; + +namespace ExpenseTracker.Application.Accounts.Commands.Create; + +public record CreateAccountCommand : IRequest +{ + public string Name { get; set; } + + public string? Description { get; set; } + + public double InitialBalance { get; set; } + + public string Currency { get; set; } + + public string? UserId { get; set; } +} diff --git a/ExpenseTracker.Application/Accounts/Commands/Create/CreateAccountCommandAuthorizer.cs b/ExpenseTracker.Application/Accounts/Commands/Create/CreateAccountCommandAuthorizer.cs new file mode 100644 index 0000000..47f306e --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Commands/Create/CreateAccountCommandAuthorizer.cs @@ -0,0 +1,32 @@ +using MediatR.Behaviors.Authorization; +using ExpenseTracker.Application.Common.Authorization; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Application.Common.Models; + +namespace ExpenseTracker.Application.Accounts.Commands.Create; + +public class CreateAccountCommandAuthorizer : AbstractRequestAuthorizer +{ + private readonly ISessionUserService _sessionUserService; + + public CreateAccountCommandAuthorizer(ISessionUserService currentUserService) + { + _sessionUserService = currentUserService; + } + + public override void BuildPolicy(CreateAccountCommand request) + { + UseRequirement(new MustBeAuthenticatedRequirement + { + IsAuthenticated = _sessionUserService.IsAuthenticated + }); + + UseRequirement(new MustBeInRolesWhenInteractingWithUnOwnedEntityRequirement + { + UserId = _sessionUserService.Id, + UserRoles = _sessionUserService.Roles, + RequiredUserId = request.UserId ?? _sessionUserService.Id, + RequiredRoles = new[] { IdentityRoles.Administrator.ToString() } + }); + } +} diff --git a/ExpenseTracker.Application/Accounts/Commands/Create/CreateAccountCommandHandler.cs b/ExpenseTracker.Application/Accounts/Commands/Create/CreateAccountCommandHandler.cs new file mode 100644 index 0000000..a334234 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Commands/Create/CreateAccountCommandHandler.cs @@ -0,0 +1,59 @@ +using AutoMapper; +using MediatR; +using ExpenseTracker.Domain.Entities; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Domain.Enums; +using ExpenseTracker.Application.Common.Interfaces; + +namespace ExpenseTracker.Application.Accounts.Commands.Create; + +public class CreateAccountCommandHandler : IRequestHandler +{ + private readonly IMapper _mapper; + private readonly IUnitOfWork _unitOfWork; + private readonly ISessionUserService _sessionUserService; + + public CreateAccountCommandHandler( + IMapper mapper, + IUnitOfWork unitOfWork, + ISessionUserService sessionUserService) + { + _mapper = mapper; + _unitOfWork = unitOfWork; + _sessionUserService = sessionUserService; + } + + public async Task Handle(CreateAccountCommand request, CancellationToken cancellationToken) + { + // TODO: Add UserId validation. Throw ValidationException when there is no user with given UserId + + var parentUuid = Guid.NewGuid().ToString(); + var childUuid = Guid.NewGuid().ToString(); + + var newAccount = new Account() + { + Id = parentUuid, + Name = request.Name, + Description = request.Description, + Currency = Currency.FromName(request.Currency), + UserId = request.UserId ?? _sessionUserService.Id + }; + + var databaseAccount = await _unitOfWork.AccountRepository.AddOneAsync(newAccount, cancellationToken); + + var newTransaction = new Transaction() + { + Id = childUuid, + Amount = request.InitialBalance, + Category = Domain.Enums.Category.InitialBalance, + Time = DateTimeOffset.UtcNow, + AccountId = parentUuid + }; + + var databaseTransaction = await _unitOfWork.TransactionRepository.AddOneAsync(newTransaction, cancellationToken); + + await _unitOfWork.SaveAsync(cancellationToken); + + return _mapper.Map(databaseAccount); + } +} diff --git a/ExpenseTracker.Application/Accounts/Commands/Create/CreateAccountCommandValidator.cs b/ExpenseTracker.Application/Accounts/Commands/Create/CreateAccountCommandValidator.cs new file mode 100644 index 0000000..3b89d04 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Commands/Create/CreateAccountCommandValidator.cs @@ -0,0 +1,20 @@ +using FluentValidation; +using ExpenseTracker.Domain.Enums; + +namespace ExpenseTracker.Application.Accounts.Commands.Create; + +public class CreateAccountCommandValidator : AbstractValidator +{ + public CreateAccountCommandValidator() + { + RuleFor(e => e.Name) + .NotEmpty(); + + RuleFor(e => e.InitialBalance) + .NotNull(); + + RuleFor(e => e.Currency) + .Must(c => Currency.FromName(c) is not null) + .WithMessage(c => $"'{nameof(c.Currency)}' must be one of the following: '{String.Join("', ", Currency.Enumerations.Values.Select(v => v.Name))}'."); + } +} diff --git a/ExpenseTracker.Application/Accounts/Commands/Delete/DeleteAccountCommand.cs b/ExpenseTracker.Application/Accounts/Commands/Delete/DeleteAccountCommand.cs new file mode 100644 index 0000000..bdd7bd9 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Commands/Delete/DeleteAccountCommand.cs @@ -0,0 +1,8 @@ +using MediatR; + +namespace ExpenseTracker.Application.Accounts.Commands.Delete; + +public record DeleteAccountCommand : IRequest +{ + public string Id { get; set; } +} diff --git a/ExpenseTracker.Application/Accounts/Commands/Delete/DeleteAccountCommandAuthorizer.cs b/ExpenseTracker.Application/Accounts/Commands/Delete/DeleteAccountCommandAuthorizer.cs new file mode 100644 index 0000000..38e78a6 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Commands/Delete/DeleteAccountCommandAuthorizer.cs @@ -0,0 +1,37 @@ +using MediatR.Behaviors.Authorization; +using ExpenseTracker.Application.Common.Authorization; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Application.Common.Models; + +namespace ExpenseTracker.Application.Accounts.Commands.Delete; + +public class DeleteAccountCommandAuthorizer : AbstractRequestAuthorizer +{ + private readonly ISessionUserService _sessionUserService; + private readonly IAccountRepository _repository; + + public DeleteAccountCommandAuthorizer(ISessionUserService currentUserService, IAccountRepository repository) + { + _sessionUserService = currentUserService; + _repository = repository; + } + + public override void BuildPolicy(DeleteAccountCommand request) + { + UseRequirement(new MustBeAuthenticatedRequirement + { + IsAuthenticated = _sessionUserService.IsAuthenticated + }); + + var requiredUserId = _repository.Queryable.FirstOrDefault(e => e.Id == request.Id)?.UserId; + + UseRequirement(new MustBeInRolesWhenInteractingWithUnOwnedEntityRequirement + { + UserId = _sessionUserService.Id, + UserRoles = _sessionUserService.Roles, + RequiredUserId = requiredUserId, + RequiredRoles = new[] { IdentityRoles.Administrator.ToString() } + }); + } +} diff --git a/ExpenseTracker.Application/Accounts/Commands/Delete/DeleteAccountCommandHandler.cs b/ExpenseTracker.Application/Accounts/Commands/Delete/DeleteAccountCommandHandler.cs new file mode 100644 index 0000000..6cd4cd3 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Commands/Delete/DeleteAccountCommandHandler.cs @@ -0,0 +1,31 @@ +using MediatR; +using ExpenseTracker.Application.Common.Exceptions; +using ExpenseTracker.Application.Accounts.Commands.Delete; +using ExpenseTracker.Application.Common.Interfaces; + +namespace ExpenseTracker.Application.Accountes.Commands.Delete; + +public class DeleteAccountCommandHandler : IRequestHandler +{ + private readonly IUnitOfWork _unitOfWork; + + public DeleteAccountCommandHandler(IUnitOfWork unitOfWork) + { + _unitOfWork = unitOfWork; + } + + public async Task Handle(DeleteAccountCommand request, CancellationToken cancellationToken) + { + var isEntityPresentInDatabase = _unitOfWork.AccountRepository.Queryable.Any(e => e.Id == request.Id); + + if (!isEntityPresentInDatabase) + { + throw new NotFoundException(); + } + + await _unitOfWork.AccountRepository.DeleteOneAsync(request.Id, cancellationToken); + await _unitOfWork.TransactionRepository.DeleteManyAsync(e => e.AccountId.Equals(request.Id), cancellationToken); + + await _unitOfWork.SaveAsync(cancellationToken); + } +} diff --git a/ExpenseTracker.Application/Accounts/Commands/Delete/DeleteAccountCommandValidator.cs b/ExpenseTracker.Application/Accounts/Commands/Delete/DeleteAccountCommandValidator.cs new file mode 100644 index 0000000..5e64705 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Commands/Delete/DeleteAccountCommandValidator.cs @@ -0,0 +1,12 @@ +using FluentValidation; + +namespace ExpenseTracker.Application.Accounts.Commands.Delete; + +public class DeleteAccountCommandValidator : AbstractValidator +{ + public DeleteAccountCommandValidator() + { + RuleFor(e => e.Id) + .NotEmpty(); + } +} diff --git a/ExpenseTracker.Application/Accounts/Commands/Import/Json/Many/ImportJsonAccountsQuery.cs b/ExpenseTracker.Application/Accounts/Commands/Import/Json/Many/ImportJsonAccountsQuery.cs new file mode 100644 index 0000000..4ae6cd1 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Commands/Import/Json/Many/ImportJsonAccountsQuery.cs @@ -0,0 +1,8 @@ +using MediatR; + +namespace ExpenseTracker.Application.Accounts.Commands.Import.Json.Many; + +public record ImportJsonAccountsQuery : IRequest +{ + public byte[] File { get; set; } +} diff --git a/ExpenseTracker.Application/Accounts/Commands/Import/Json/Many/ImportJsonAccountsQueryAuthorizer.cs b/ExpenseTracker.Application/Accounts/Commands/Import/Json/Many/ImportJsonAccountsQueryAuthorizer.cs new file mode 100644 index 0000000..e41c1ce --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Commands/Import/Json/Many/ImportJsonAccountsQueryAuthorizer.cs @@ -0,0 +1,23 @@ +using MediatR.Behaviors.Authorization; +using ExpenseTracker.Application.Common.Authorization; +using ExpenseTracker.Application.Common.Interfaces.Services; + +namespace ExpenseTracker.Application.Accounts.Commands.Import.Json.Many; + +public class ImportJsonAccountsQueryAuthorizer : AbstractRequestAuthorizer +{ + private readonly ISessionUserService _sessionUserService; + + public ImportJsonAccountsQueryAuthorizer(ISessionUserService currentUserService) + { + _sessionUserService = currentUserService; + } + + public override void BuildPolicy(ImportJsonAccountsQuery request) + { + UseRequirement(new MustBeAuthenticatedRequirement + { + IsAuthenticated = _sessionUserService.IsAuthenticated + }); + } +} diff --git a/ExpenseTracker.Application/Accounts/Commands/Import/Json/Many/ImportJsonAccountsQueryHandler.cs b/ExpenseTracker.Application/Accounts/Commands/Import/Json/Many/ImportJsonAccountsQueryHandler.cs new file mode 100644 index 0000000..9aa9cd4 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Commands/Import/Json/Many/ImportJsonAccountsQueryHandler.cs @@ -0,0 +1,67 @@ +using System.Text; +using AutoMapper; +using MediatR; +using Newtonsoft.Json; +using Newtonsoft.Json.Serialization; +using ExpenseTracker.Application.Common.Interfaces; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Domain.Entities; + +namespace ExpenseTracker.Application.Accounts.Commands.Import.Json.Many; + +public class ImportJsonAccountsQueryHandler : IRequestHandler +{ + private readonly IMapper _mapper; + private readonly IUnitOfWork _unitOfWork; + private readonly ISessionUserService _sessionUserService; + + public ImportJsonAccountsQueryHandler( + IMapper mapper, + IUnitOfWork unitOfWork, + ISessionUserService sessionUserService) + { + _mapper = mapper; + _unitOfWork = unitOfWork; + _sessionUserService = sessionUserService; + } + + public async Task Handle(ImportJsonAccountsQuery request, CancellationToken cancellationToken) + { + string json; + + using (var memoryStream = new MemoryStream(request.File)) + { + using (var streamReader = new StreamReader(memoryStream, Encoding.UTF8)) + { + json = await streamReader.ReadToEndAsync(cancellationToken); + } + } + + var jsonSerializerSettings = new JsonSerializerSettings() + { + ContractResolver = new CamelCasePropertyNamesContractResolver() + }; + + var accountDtos = JsonConvert.DeserializeObject>(json, jsonSerializerSettings); + + var accounts = _mapper.ProjectTo(accountDtos.AsQueryable()); + + foreach (var account in accounts) + { + account.Id = Guid.NewGuid().ToString(); + account.UserId = _sessionUserService.Id; + + foreach (var transaction in account.Transactions) + { + transaction.Id = Guid.NewGuid().ToString(); + transaction.AccountId = account.Id; + + await _unitOfWork.TransactionRepository.AddOneAsync(transaction, cancellationToken); + } + + await _unitOfWork.AccountRepository.AddOneAsync(account, cancellationToken); + } + + await _unitOfWork.SaveAsync(cancellationToken); + } +} diff --git a/ExpenseTracker.Application/Accounts/Commands/Import/Json/Many/ImportJsonAccountsQueryValidator.cs b/ExpenseTracker.Application/Accounts/Commands/Import/Json/Many/ImportJsonAccountsQueryValidator.cs new file mode 100644 index 0000000..5300a77 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Commands/Import/Json/Many/ImportJsonAccountsQueryValidator.cs @@ -0,0 +1,11 @@ +using FluentValidation; + +namespace ExpenseTracker.Application.Accounts.Commands.Import.Json.Many; + +public class ImportJsonAccountsQueryValidator : AbstractValidator +{ + public ImportJsonAccountsQueryValidator() + { + RuleFor(e => e.File.Length).GreaterThan(0); + } +} diff --git a/ExpenseTracker.Application/Accounts/Commands/Import/Json/One/ImportJsonAccountQuery.cs b/ExpenseTracker.Application/Accounts/Commands/Import/Json/One/ImportJsonAccountQuery.cs new file mode 100644 index 0000000..4c7e3d7 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Commands/Import/Json/One/ImportJsonAccountQuery.cs @@ -0,0 +1,8 @@ +using MediatR; + +namespace ExpenseTracker.Application.Accounts.Commands.Import.Json.One; + +public record ImportJsonAccountQuery : IRequest +{ + public byte[] File { get; set; } +} diff --git a/ExpenseTracker.Application/Accounts/Commands/Import/Json/One/ImportJsonAccountQueryAuthorizer.cs b/ExpenseTracker.Application/Accounts/Commands/Import/Json/One/ImportJsonAccountQueryAuthorizer.cs new file mode 100644 index 0000000..d5a99e1 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Commands/Import/Json/One/ImportJsonAccountQueryAuthorizer.cs @@ -0,0 +1,23 @@ +using MediatR.Behaviors.Authorization; +using ExpenseTracker.Application.Common.Authorization; +using ExpenseTracker.Application.Common.Interfaces.Services; + +namespace ExpenseTracker.Application.Accounts.Commands.Import.Json.One; + +public class ImportJsonAccountQueryAuthorizer : AbstractRequestAuthorizer +{ + private readonly ISessionUserService _sessionUserService; + + public ImportJsonAccountQueryAuthorizer(ISessionUserService currentUserService) + { + _sessionUserService = currentUserService; + } + + public override void BuildPolicy(ImportJsonAccountQuery request) + { + UseRequirement(new MustBeAuthenticatedRequirement + { + IsAuthenticated = _sessionUserService.IsAuthenticated + }); + } +} diff --git a/ExpenseTracker.Application/Accounts/Commands/Import/Json/One/ImportJsonAccountQueryHandler.cs b/ExpenseTracker.Application/Accounts/Commands/Import/Json/One/ImportJsonAccountQueryHandler.cs new file mode 100644 index 0000000..c3806b2 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Commands/Import/Json/One/ImportJsonAccountQueryHandler.cs @@ -0,0 +1,71 @@ +using System.Text; +using AutoMapper; +using MediatR; +using Newtonsoft.Json; +using Newtonsoft.Json.Serialization; +using ExpenseTracker.Application.Common.Interfaces; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Domain.Entities; + +namespace ExpenseTracker.Application.Accounts.Commands.Import.Json.One; + +public class ImportJsonAccountQueryHandler : IRequestHandler +{ + private readonly IMapper _mapper; + private readonly IUnitOfWork _unitOfWork; + private readonly ISessionUserService _sessionUserService; + + public ImportJsonAccountQueryHandler( + IMapper mapper, + IUnitOfWork unitOfWork, + ISessionUserService sessionUserService) + { + _mapper = mapper; + _unitOfWork = unitOfWork; + _sessionUserService = sessionUserService; + } + + public async Task Handle(ImportJsonAccountQuery request, CancellationToken cancellationToken) + { + string json; + + using (var memoryStream = new MemoryStream(request.File)) + { + using (var streamReader = new StreamReader(memoryStream, Encoding.UTF8)) + { + json = await streamReader.ReadToEndAsync(cancellationToken); + } + } + + var jsonSerializerSettings = new JsonSerializerSettings() + { + ContractResolver = new CamelCasePropertyNamesContractResolver() + }; + + var accountDto = JsonConvert.DeserializeObject(json, jsonSerializerSettings); + + var account = _mapper.Map(accountDto); + + account.Id = Guid.NewGuid().ToString(); + account.UserId = _sessionUserService.Id; + + foreach (var transaction in account.Transactions) + { + transaction.Id = Guid.NewGuid().ToString(); + transaction.AccountId = account.Id; + } + + var tasks = new List(); + + tasks.Add(_unitOfWork.AccountRepository.AddOneAsync(account, cancellationToken)); + + if (account.Transactions.Count() != 0) + { + tasks.Add(_unitOfWork.TransactionRepository.AddManyAsync(account.Transactions, cancellationToken)); + } + + await Task.WhenAll(tasks); + + await _unitOfWork.SaveAsync(cancellationToken); + } +} diff --git a/ExpenseTracker.Application/Accounts/Commands/Import/Json/One/ImportJsonAccountQueryValidator.cs b/ExpenseTracker.Application/Accounts/Commands/Import/Json/One/ImportJsonAccountQueryValidator.cs new file mode 100644 index 0000000..eaeb1f2 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Commands/Import/Json/One/ImportJsonAccountQueryValidator.cs @@ -0,0 +1,11 @@ +using FluentValidation; + +namespace ExpenseTracker.Application.Accounts.Commands.Import.Json.One; + +public class ImportJsonAccountQueryValidator : AbstractValidator +{ + public ImportJsonAccountQueryValidator() + { + RuleFor(e => e.File.Length).GreaterThan(0); + } +} diff --git a/ExpenseTracker.Application/Accounts/Commands/Update/UpdateAccountCommand.cs b/ExpenseTracker.Application/Accounts/Commands/Update/UpdateAccountCommand.cs new file mode 100644 index 0000000..18a430e --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Commands/Update/UpdateAccountCommand.cs @@ -0,0 +1,14 @@ +using MediatR; + +namespace ExpenseTracker.Application.Accounts.Commands.Update; + +public record UpdateAccountCommand : IRequest +{ + public string Id { get; set; } + + public string? Name { get; set; } + + public string? Description { get; set; } + + public string UserId { get; set; } +} diff --git a/ExpenseTracker.Application/Accounts/Commands/Update/UpdateAccountCommandAuthorized.cs b/ExpenseTracker.Application/Accounts/Commands/Update/UpdateAccountCommandAuthorized.cs new file mode 100644 index 0000000..f9edce3 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Commands/Update/UpdateAccountCommandAuthorized.cs @@ -0,0 +1,32 @@ +using MediatR.Behaviors.Authorization; +using ExpenseTracker.Application.Common.Authorization; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Application.Common.Models; + +namespace ExpenseTracker.Application.Accounts.Commands.Update; + +public class UpdateAccountCommandAuthorizer : AbstractRequestAuthorizer +{ + private readonly ISessionUserService _sessionUserService; + + public UpdateAccountCommandAuthorizer(ISessionUserService currentUserService) + { + _sessionUserService = currentUserService; + } + + public override void BuildPolicy(UpdateAccountCommand request) + { + UseRequirement(new MustBeAuthenticatedRequirement + { + IsAuthenticated = _sessionUserService.IsAuthenticated + }); + + UseRequirement(new MustBeInRolesWhenInteractingWithUnOwnedEntityRequirement + { + UserId = _sessionUserService.Id, + UserRoles = _sessionUserService.Roles, + RequiredUserId = request.UserId, + RequiredRoles = new[] { IdentityRoles.Administrator.ToString() } + }); + } +} diff --git a/ExpenseTracker.Application/Accounts/Commands/Update/UpdateAccountCommandHandler.cs b/ExpenseTracker.Application/Accounts/Commands/Update/UpdateAccountCommandHandler.cs new file mode 100644 index 0000000..8038a38 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Commands/Update/UpdateAccountCommandHandler.cs @@ -0,0 +1,45 @@ +using AutoMapper; +using MediatR; +using ExpenseTracker.Application.Common.Exceptions; +using ExpenseTracker.Application.Common.Interfaces; +using ExpenseTracker.Domain.Entities; + +namespace ExpenseTracker.Application.Accounts.Commands.Update; + +public class UpdateAccountCommandHandler : IRequestHandler +{ + private readonly IMapper _mapper; + private readonly IUnitOfWork _unitOfWork; + + public UpdateAccountCommandHandler(IMapper mapper, IUnitOfWork unitOfWork) + { + _mapper = mapper; + _unitOfWork = unitOfWork; + } + + public async Task Handle(UpdateAccountCommand request, CancellationToken cancellationToken) + { + var databaseEntity = _unitOfWork.AccountRepository.Queryable.FirstOrDefault(e => e.Id == request.Id); + + if (databaseEntity == null) + { + throw new NotFoundException(); + } + + // TODO: Add UserId validation. Throw NotFoundException when there is no user with given UserId + + var updatedEntity = new Account() + { + Id = request.Id, + Name = request.Name ?? databaseEntity.Name, + Description = request.Description, + UserId = request.UserId + }; + + databaseEntity = await _unitOfWork.AccountRepository.UpdateOneAsync(updatedEntity, cancellationToken); + + await _unitOfWork.SaveAsync(cancellationToken); + + return _mapper.Map(databaseEntity); + } +} diff --git a/ExpenseTracker.Application/Accounts/Commands/Update/UpdateAccountCommandValidator.cs b/ExpenseTracker.Application/Accounts/Commands/Update/UpdateAccountCommandValidator.cs new file mode 100644 index 0000000..5b204bb --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Commands/Update/UpdateAccountCommandValidator.cs @@ -0,0 +1,17 @@ +using FluentValidation; + +namespace ExpenseTracker.Application.Accounts.Commands.Update; + +public class UpdateAccountCommandValidator : AbstractValidator +{ + public UpdateAccountCommandValidator() + { + RuleFor(e => e.Id) + .NotEmpty(); + + RuleFor(e => e.Name); + + RuleFor(e => e.UserId) + .NotEmpty(); + } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Charts/DailyTransactionsBarChart.cs b/ExpenseTracker.Application/Accounts/Queries/Charts/DailyTransactionsBarChart.cs new file mode 100644 index 0000000..0ba6d35 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Charts/DailyTransactionsBarChart.cs @@ -0,0 +1,39 @@ +namespace ExpenseTracker.Application.Accounts.Queries.Charts; + +public class DailyTransactionsBarChart +{ + public DailyTransactionsBarChart(IEnumerable> groupings, DateOnly fromDate, DateOnly toDate) + { + var days = toDate.DayNumber - fromDate.DayNumber; + + var dateAmount = new Dictionary(days); + + for (int i = 0; i < days; i++) + { + dateAmount.Add(fromDate.AddDays(i), 0); + } + + foreach (var group in groupings) + { + var date = DateOnly.FromDateTime(group.Key); + var amount = group.Aggregate(0.0, (a, x) => a + x); + + dateAmount[date] = amount; + } + + Dates = dateAmount.Keys.ToList(); + Amounts = dateAmount.Values.ToList(); + } + + public double MinimumAmount => Amounts.Min(); + + public double MaximumAmount => Amounts.Max(); + + public double AverageAmount => Double.Round(TotalAmount / Amounts.Count(), 4); + + public double TotalAmount => Amounts.Aggregate(0.0, (a, x) => a +x); + + public IEnumerable Dates { get; set; } + + public IEnumerable Amounts { get; set; } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseBarChart/GetExpenseBarChartQuery.cs b/ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseBarChart/GetExpenseBarChartQuery.cs new file mode 100644 index 0000000..bfb21b1 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseBarChart/GetExpenseBarChartQuery.cs @@ -0,0 +1,12 @@ +using MediatR; + +namespace ExpenseTracker.Application.Accounts.Queries.Charts.GetExpenseBarChart; + +public record GetExpenseBarChartQuery : IRequest +{ + public string? AccountId { get; set; } + + public DateOnly FromDate { get; set; } + + public DateOnly ToDate { get; set; } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseBarChart/GetExpenseBarChartQueryAuthorizer.cs b/ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseBarChart/GetExpenseBarChartQueryAuthorizer.cs new file mode 100644 index 0000000..ec2bf3a --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseBarChart/GetExpenseBarChartQueryAuthorizer.cs @@ -0,0 +1,37 @@ +using MediatR.Behaviors.Authorization; +using ExpenseTracker.Application.Common.Authorization; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Application.Common.Models; + +namespace ExpenseTracker.Application.Accounts.Queries.Charts.GetExpenseBarChart; + +public class GetExpenseBarChartQueryAuthorizer : AbstractRequestAuthorizer +{ + private readonly ISessionUserService _sessionUserService; + private readonly IAccountRepository _repository; + + public GetExpenseBarChartQueryAuthorizer(ISessionUserService currentUserService, IAccountRepository repository) + { + _sessionUserService = currentUserService; + _repository = repository; + } + + public override void BuildPolicy(GetExpenseBarChartQuery request) + { + UseRequirement(new MustBeAuthenticatedRequirement + { + IsAuthenticated = _sessionUserService.IsAuthenticated + }); + + var requiredUserId = _repository.Queryable.FirstOrDefault(e => e.Id == request.AccountId)?.UserId; + + UseRequirement(new MustBeInRolesWhenInteractingWithUnOwnedEntityRequirement + { + UserId = _sessionUserService.Id, + UserRoles = _sessionUserService.Roles, + RequiredUserId = requiredUserId, + RequiredRoles = new[] { IdentityRoles.Administrator.ToString() } + }); + } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseBarChart/GetExpenseBarChartQueryHandler.cs b/ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseBarChart/GetExpenseBarChartQueryHandler.cs new file mode 100644 index 0000000..06044c7 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseBarChart/GetExpenseBarChartQueryHandler.cs @@ -0,0 +1,43 @@ +using AutoMapper; +using MediatR; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Application.Common.Interfaces.Services; + +namespace ExpenseTracker.Application.Accounts.Queries.Charts.GetExpenseBarChart; + +public class GetExpenseBarChartQueryHandler : IRequestHandler +{ + private readonly IMapper _mapper; + private readonly IAccountRepository _accountRepository; + private readonly ITransactionRepository _transactionRepository; + private readonly ISessionUserService _sessionUserService; + + public GetExpenseBarChartQueryHandler( + IMapper mapper, + IAccountRepository repository, + ITransactionRepository transactionRepository, + ISessionUserService sessionUserService) + { + _mapper = mapper; + _accountRepository = repository; + _sessionUserService = sessionUserService; + _transactionRepository = transactionRepository; + } + + public async Task Handle(GetExpenseBarChartQuery request, CancellationToken cancellationToken) + { + var entities = _transactionRepository.Queryable + .Where(e => + e.AccountId == request.AccountId && + e.Amount < 0) + .ToList() + .Where(e => + DateOnly.FromDateTime(e.Time.DateTime) >= request.FromDate && + DateOnly.FromDateTime(e.Time.DateTime) < request.ToDate) + .OrderBy(e => e.Time); + + var groupsByDate = entities.GroupBy(e => e.Time.Date, t => t.Amount); + + return new DailyTransactionsBarChart(groupsByDate, request.FromDate, request.ToDate); + } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseBarChart/GetExpenseBarChartQueryValidator.cs b/ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseBarChart/GetExpenseBarChartQueryValidator.cs new file mode 100644 index 0000000..2b1e7ca --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseBarChart/GetExpenseBarChartQueryValidator.cs @@ -0,0 +1,15 @@ +using FluentValidation; + +namespace ExpenseTracker.Application.Accounts.Queries.Charts.GetExpenseBarChart; + +public class GetExpenseBarChartQueryValidator : AbstractValidator +{ + public GetExpenseBarChartQueryValidator() + { + // RuleFor(v => v.AccountId).NotEmpty(); + + RuleFor(v => v.FromDate).NotEmpty(); + + RuleFor(v => v.ToDate).GreaterThan(v => v.FromDate).NotEmpty(); + } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseByCategoryPieChart/GetExpenseByCategoryPieChartQuery.cs b/ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseByCategoryPieChart/GetExpenseByCategoryPieChartQuery.cs new file mode 100644 index 0000000..b4a1b4e --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseByCategoryPieChart/GetExpenseByCategoryPieChartQuery.cs @@ -0,0 +1,13 @@ +using MediatR; +using ExpenseTracker.Domain.Enums; + +namespace ExpenseTracker.Application.Accounts.Queries.Charts.GetExpenseByCategoryPieChart; + +public record GetExpenseByCategoryPieChartQuery : IRequest> +{ + public string? AccountId { get; set; } + + public DateOnly FromDate { get; set; } + + public DateOnly ToDate { get; set; } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseByCategoryPieChart/GetExpenseByCategoryPieChartQueryAuthorizer.cs b/ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseByCategoryPieChart/GetExpenseByCategoryPieChartQueryAuthorizer.cs new file mode 100644 index 0000000..b7f7c5e --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseByCategoryPieChart/GetExpenseByCategoryPieChartQueryAuthorizer.cs @@ -0,0 +1,37 @@ +using MediatR.Behaviors.Authorization; +using ExpenseTracker.Application.Common.Authorization; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Application.Common.Models; + +namespace ExpenseTracker.Application.Accounts.Queries.Charts.GetExpenseByCategoryPieChart; + +public class GetExpenseByCategoryPieChartQueryAuthorizer : AbstractRequestAuthorizer +{ + private readonly ISessionUserService _sessionUserService; + private readonly IAccountRepository _repository; + + public GetExpenseByCategoryPieChartQueryAuthorizer(ISessionUserService currentUserService, IAccountRepository repository) + { + _sessionUserService = currentUserService; + _repository = repository; + } + + public override void BuildPolicy(GetExpenseByCategoryPieChartQuery request) + { + UseRequirement(new MustBeAuthenticatedRequirement + { + IsAuthenticated = _sessionUserService.IsAuthenticated + }); + + var requiredUserId = _repository.Queryable.FirstOrDefault(e => e.Id == request.AccountId)?.UserId; + + UseRequirement(new MustBeInRolesWhenInteractingWithUnOwnedEntityRequirement + { + UserId = _sessionUserService.Id, + UserRoles = _sessionUserService.Roles, + RequiredUserId = requiredUserId, + RequiredRoles = new[] { IdentityRoles.Administrator.ToString() } + }); + } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseByCategoryPieChart/GetExpenseByCategoryPieChartQueryHandler.cs b/ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseByCategoryPieChart/GetExpenseByCategoryPieChartQueryHandler.cs new file mode 100644 index 0000000..4a0f248 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseByCategoryPieChart/GetExpenseByCategoryPieChartQueryHandler.cs @@ -0,0 +1,57 @@ +using AutoMapper; +using MediatR; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Domain.Enums; + +namespace ExpenseTracker.Application.Accounts.Queries.Charts.GetExpenseByCategoryPieChart; + +public class GetExpenseByCategoryPieChartQueryHandler : IRequestHandler> +{ + private readonly IMapper _mapper; + private readonly IAccountRepository _accountRepository; + private readonly ITransactionRepository _transactionRepository; + private readonly ISessionUserService _sessionUserService; + + public GetExpenseByCategoryPieChartQueryHandler( + IMapper mapper, + IAccountRepository repository, + ITransactionRepository transactionRepository, + ISessionUserService sessionUserService) + { + _mapper = mapper; + _accountRepository = repository; + _sessionUserService = sessionUserService; + _transactionRepository = transactionRepository; + } + + public async Task> Handle(GetExpenseByCategoryPieChartQuery request, CancellationToken cancellationToken) + { + var entities = _transactionRepository.Queryable + .Where(e => + e.AccountId == request.AccountId && + e.Amount < 0) + .ToList() + .Where(e => + DateOnly.FromDateTime(e.Time.DateTime) >= request.FromDate && + DateOnly.FromDateTime(e.Time.DateTime) < request.ToDate) + .OrderBy(e => e.Time); + + var groupsByCategory = entities.GroupBy(e => e.Category, t => t.Amount); + + var pieChart = new Dictionary(); + + var totalAmount = groupsByCategory.Aggregate(0.0, (a, x) => a + x.Aggregate(0.0, (b, y) => b + y)); + + foreach (var group in groupsByCategory) + { + var category = group.Key; + var amount = group.Aggregate(0.0, (a, x) => a + x); + var percent = Double.Round(amount / totalAmount, 4); + + pieChart.Add(category, percent); + } + + return pieChart; + } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseByCategoryPieChart/GetExpenseByCategoryPieChartQueryValidator.cs b/ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseByCategoryPieChart/GetExpenseByCategoryPieChartQueryValidator.cs new file mode 100644 index 0000000..0a52acd --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Charts/GetExpenseByCategoryPieChart/GetExpenseByCategoryPieChartQueryValidator.cs @@ -0,0 +1,15 @@ +using FluentValidation; + +namespace ExpenseTracker.Application.Accounts.Queries.Charts.GetExpenseByCategoryPieChart; + +public class GetExpenseByCategoryPieChartQueryValidator : AbstractValidator +{ + public GetExpenseByCategoryPieChartQueryValidator() + { + // RuleFor(v => v.AccountId).NotEmpty(); + + RuleFor(v => v.FromDate).NotEmpty(); + + RuleFor(v => v.ToDate).GreaterThan(v => v.FromDate).NotEmpty(); + } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Charts/GetIncomeBarChart/GetIncomeBarChartQuery.cs b/ExpenseTracker.Application/Accounts/Queries/Charts/GetIncomeBarChart/GetIncomeBarChartQuery.cs new file mode 100644 index 0000000..ff6f592 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Charts/GetIncomeBarChart/GetIncomeBarChartQuery.cs @@ -0,0 +1,12 @@ +using MediatR; + +namespace ExpenseTracker.Application.Accounts.Queries.Charts.GetIncomeBarChart; + +public record GetIncomeBarChartQuery : IRequest +{ + public string? AccountId { get; set; } + + public DateOnly FromDate { get; set; } + + public DateOnly ToDate { get; set; } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Charts/GetIncomeBarChart/GetIncomeBarChartQueryAuthorizer.cs b/ExpenseTracker.Application/Accounts/Queries/Charts/GetIncomeBarChart/GetIncomeBarChartQueryAuthorizer.cs new file mode 100644 index 0000000..aa354b1 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Charts/GetIncomeBarChart/GetIncomeBarChartQueryAuthorizer.cs @@ -0,0 +1,37 @@ +using MediatR.Behaviors.Authorization; +using ExpenseTracker.Application.Common.Authorization; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Application.Common.Models; + +namespace ExpenseTracker.Application.Accounts.Queries.Charts.GetIncomeBarChart; + +public class GetIncomeBarChartQueryAuthorizer : AbstractRequestAuthorizer +{ + private readonly ISessionUserService _sessionUserService; + private readonly IAccountRepository _repository; + + public GetIncomeBarChartQueryAuthorizer(ISessionUserService currentUserService, IAccountRepository repository) + { + _sessionUserService = currentUserService; + _repository = repository; + } + + public override void BuildPolicy(GetIncomeBarChartQuery request) + { + UseRequirement(new MustBeAuthenticatedRequirement + { + IsAuthenticated = _sessionUserService.IsAuthenticated + }); + + var requiredUserId = _repository.Queryable.FirstOrDefault(e => e.Id == request.AccountId)?.UserId; + + UseRequirement(new MustBeInRolesWhenInteractingWithUnOwnedEntityRequirement + { + UserId = _sessionUserService.Id, + UserRoles = _sessionUserService.Roles, + RequiredUserId = requiredUserId, + RequiredRoles = new[] { IdentityRoles.Administrator.ToString() } + }); + } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Charts/GetIncomeBarChart/GetIncomeBarChartQueryHandler.cs b/ExpenseTracker.Application/Accounts/Queries/Charts/GetIncomeBarChart/GetIncomeBarChartQueryHandler.cs new file mode 100644 index 0000000..9e2eb09 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Charts/GetIncomeBarChart/GetIncomeBarChartQueryHandler.cs @@ -0,0 +1,43 @@ +using AutoMapper; +using MediatR; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Application.Common.Interfaces.Services; + +namespace ExpenseTracker.Application.Accounts.Queries.Charts.GetIncomeBarChart; + +public class GetIncomeBarChartQueryHandler : IRequestHandler +{ + private readonly IMapper _mapper; + private readonly IAccountRepository _accountRepository; + private readonly ITransactionRepository _transactionRepository; + private readonly ISessionUserService _sessionUserService; + + public GetIncomeBarChartQueryHandler( + IMapper mapper, + IAccountRepository repository, + ITransactionRepository transactionRepository, + ISessionUserService sessionUserService) + { + _mapper = mapper; + _accountRepository = repository; + _sessionUserService = sessionUserService; + _transactionRepository = transactionRepository; + } + + public async Task Handle(GetIncomeBarChartQuery request, CancellationToken cancellationToken) + { + var entities = _transactionRepository.Queryable + .Where(e => + e.AccountId == request.AccountId && + e.Amount > 0) + .ToList() + .Where(e => + DateOnly.FromDateTime(e.Time.DateTime) >= request.FromDate && + DateOnly.FromDateTime(e.Time.DateTime) < request.ToDate) + .OrderBy(e => e.Time); + + var groupsByDate = entities.GroupBy(e => e.Time.Date, t => t.Amount); + + return new DailyTransactionsBarChart(groupsByDate, request.FromDate, request.ToDate); + } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Charts/GetIncomeBarChart/GetIncomeBarChartQueryValidator.cs b/ExpenseTracker.Application/Accounts/Queries/Charts/GetIncomeBarChart/GetIncomeBarChartQueryValidator.cs new file mode 100644 index 0000000..967d251 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Charts/GetIncomeBarChart/GetIncomeBarChartQueryValidator.cs @@ -0,0 +1,15 @@ +using FluentValidation; + +namespace ExpenseTracker.Application.Accounts.Queries.Charts.GetIncomeBarChart; + +public class GetIncomeBarChartQueryValidator : AbstractValidator +{ + public GetIncomeBarChartQueryValidator() + { + // RuleFor(v => v.AccountId).NotEmpty(); + + RuleFor(v => v.FromDate).NotEmpty(); + + RuleFor(v => v.ToDate).NotEmpty(); + } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Charts/GetProfitBarChart/GetProfitBarChartQuery.cs b/ExpenseTracker.Application/Accounts/Queries/Charts/GetProfitBarChart/GetProfitBarChartQuery.cs new file mode 100644 index 0000000..25a751d --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Charts/GetProfitBarChart/GetProfitBarChartQuery.cs @@ -0,0 +1,12 @@ +using MediatR; + +namespace ExpenseTracker.Application.Accounts.Queries.Charts.GetProfitBarChart; + +public record GetProfitBarChartQuery : IRequest +{ + public string? AccountId { get; set; } + + public DateOnly FromDate { get; set; } + + public DateOnly ToDate { get; set; } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Charts/GetProfitBarChart/GetProfitBarChartQueryAuthorizer.cs b/ExpenseTracker.Application/Accounts/Queries/Charts/GetProfitBarChart/GetProfitBarChartQueryAuthorizer.cs new file mode 100644 index 0000000..215aac1 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Charts/GetProfitBarChart/GetProfitBarChartQueryAuthorizer.cs @@ -0,0 +1,37 @@ +using MediatR.Behaviors.Authorization; +using ExpenseTracker.Application.Common.Authorization; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Application.Common.Models; + +namespace ExpenseTracker.Application.Accounts.Queries.Charts.GetProfitBarChart; + +public class GetProfitBarChartQueryAuthorizer : AbstractRequestAuthorizer +{ + private readonly ISessionUserService _sessionUserService; + private readonly IAccountRepository _repository; + + public GetProfitBarChartQueryAuthorizer(ISessionUserService currentUserService, IAccountRepository repository) + { + _sessionUserService = currentUserService; + _repository = repository; + } + + public override void BuildPolicy(GetProfitBarChartQuery request) + { + UseRequirement(new MustBeAuthenticatedRequirement + { + IsAuthenticated = _sessionUserService.IsAuthenticated + }); + + var requiredUserId = _repository.Queryable.FirstOrDefault(e => e.Id == request.AccountId)?.UserId; + + UseRequirement(new MustBeInRolesWhenInteractingWithUnOwnedEntityRequirement + { + UserId = _sessionUserService.Id, + UserRoles = _sessionUserService.Roles, + RequiredUserId = requiredUserId, + RequiredRoles = new[] { IdentityRoles.Administrator.ToString() } + }); + } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Charts/GetProfitBarChart/GetProfitBarChartQueryHandler.cs b/ExpenseTracker.Application/Accounts/Queries/Charts/GetProfitBarChart/GetProfitBarChartQueryHandler.cs new file mode 100644 index 0000000..1f192f5 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Charts/GetProfitBarChart/GetProfitBarChartQueryHandler.cs @@ -0,0 +1,41 @@ +using AutoMapper; +using MediatR; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Application.Common.Interfaces.Services; + +namespace ExpenseTracker.Application.Accounts.Queries.Charts.GetProfitBarChart; + +public class GetProfitBarChartQueryHandler : IRequestHandler +{ + private readonly IMapper _mapper; + private readonly IAccountRepository _accountRepository; + private readonly ITransactionRepository _transactionRepository; + private readonly ISessionUserService _sessionUserService; + + public GetProfitBarChartQueryHandler( + IMapper mapper, + IAccountRepository repository, + ITransactionRepository transactionRepository, + ISessionUserService sessionUserService) + { + _mapper = mapper; + _accountRepository = repository; + _sessionUserService = sessionUserService; + _transactionRepository = transactionRepository; + } + + public async Task Handle(GetProfitBarChartQuery request, CancellationToken cancellationToken) + { + var entities = _transactionRepository.Queryable + .Where(e => e.AccountId == request.AccountId) + .ToList() + .Where(e => + DateOnly.FromDateTime(e.Time.DateTime) >= request.FromDate && + DateOnly.FromDateTime(e.Time.DateTime) < request.ToDate) + .OrderBy(e => e.Time); + + var groupsByDate = entities.GroupBy(e => e.Time.Date, t => t.Amount); + + return new DailyTransactionsBarChart(groupsByDate, request.FromDate, request.ToDate); + } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Charts/GetProfitBarChart/GetProfitBarChartQueryValidator.cs b/ExpenseTracker.Application/Accounts/Queries/Charts/GetProfitBarChart/GetProfitBarChartQueryValidator.cs new file mode 100644 index 0000000..0974fca --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Charts/GetProfitBarChart/GetProfitBarChartQueryValidator.cs @@ -0,0 +1,15 @@ +using FluentValidation; + +namespace ExpenseTracker.Application.Accounts.Queries.Charts.GetProfitBarChart; + +public class GetProfitBarChartQueryValidator : AbstractValidator +{ + public GetProfitBarChartQueryValidator() + { + // RuleFor(v => v.AccountId).NotEmpty(); + + RuleFor(v => v.FromDate).NotEmpty(); + + RuleFor(v => v.ToDate).GreaterThan(v => v.FromDate).NotEmpty(); + } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Export/Csv/One/ExportCsvAccountQuery.cs b/ExpenseTracker.Application/Accounts/Queries/Export/Csv/One/ExportCsvAccountQuery.cs new file mode 100644 index 0000000..00cf145 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Export/Csv/One/ExportCsvAccountQuery.cs @@ -0,0 +1,8 @@ +using MediatR; + +namespace ExpenseTracker.Application.Accounts.Queries.Export.Csv.One; + +public record ExportCsvAccountQuery : IRequest +{ + public string Id { get; set; } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Export/Csv/One/ExportCsvAccountQueryAuthorizer.cs b/ExpenseTracker.Application/Accounts/Queries/Export/Csv/One/ExportCsvAccountQueryAuthorizer.cs new file mode 100644 index 0000000..4404930 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Export/Csv/One/ExportCsvAccountQueryAuthorizer.cs @@ -0,0 +1,37 @@ +using MediatR.Behaviors.Authorization; +using ExpenseTracker.Application.Common.Authorization; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Application.Common.Models; + +namespace ExpenseTracker.Application.Accounts.Queries.Export.Csv.One; + +public class ExportCsvAccountQueryAuthorizer : AbstractRequestAuthorizer +{ + private readonly ISessionUserService _sessionUserService; + private readonly IAccountRepository _repository; + + public ExportCsvAccountQueryAuthorizer(ISessionUserService currentUserService, IAccountRepository repository) + { + _sessionUserService = currentUserService; + _repository = repository; + } + + public override void BuildPolicy(ExportCsvAccountQuery request) + { + UseRequirement(new MustBeAuthenticatedRequirement + { + IsAuthenticated = _sessionUserService.IsAuthenticated + }); + + var requiredUserId = _repository.Queryable.FirstOrDefault(e => e.Id == request.Id)?.UserId; + + UseRequirement(new MustBeInRolesWhenInteractingWithUnOwnedEntityRequirement + { + UserId = _sessionUserService.Id, + UserRoles = _sessionUserService.Roles, + RequiredUserId = requiredUserId, + RequiredRoles = new[] { IdentityRoles.Administrator.ToString() } + }); + } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Export/Csv/One/ExportCsvAccountQueryHandler.cs b/ExpenseTracker.Application/Accounts/Queries/Export/Csv/One/ExportCsvAccountQueryHandler.cs new file mode 100644 index 0000000..26433d8 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Export/Csv/One/ExportCsvAccountQueryHandler.cs @@ -0,0 +1,67 @@ +using System.Globalization; +using System.Text; +using AutoMapper; +using CsvHelper; +using MediatR; +using ExpenseTracker.Application.Common.Exceptions; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Domain.Entities; + +namespace ExpenseTracker.Application.Accounts.Queries.Export.Csv.One; + +public class ExportCsvAccountQueryHandler : IRequestHandler +{ + private readonly IMapper _mapper; + private readonly IAccountRepository _accountRepository; + private readonly ITransactionRepository _transactionRepository; + + public ExportCsvAccountQueryHandler( + IMapper mapper, + IAccountRepository repository, + ITransactionRepository transactionRepository) + { + _mapper = mapper; + _accountRepository = repository; + _transactionRepository = transactionRepository; + } + + public async Task Handle(ExportCsvAccountQuery request, CancellationToken cancellationToken) + { + var entity = _accountRepository.Queryable + .GroupJoin( + _transactionRepository.Queryable, + b => b.Id, + t => t.AccountId, + (account, transactions) => + new Account + { + Id = account.Id, + Name = account.Name, + Description = account.Description, + UserId = account.UserId, + Transactions = transactions + } + ) + .FirstOrDefault(e => e.Id == request.Id); + + // TODO: Mapping to DTO creates new objects therefore using more resources + // Create custom csv serializer to avoid mapping + + var entityDto = _mapper.Map(entity); + + using (var memoryStream = new MemoryStream()) + { + using (var streamWriter = new StreamWriter(memoryStream, Encoding.UTF8)) + { + using (var csvWriter = new CsvWriter(streamWriter, CultureInfo.InvariantCulture)) + { + csvWriter.Context.RegisterClassMap(); + await csvWriter.WriteRecordsAsync(entityDto.Transactions); + await csvWriter.FlushAsync(); + } + } + + return memoryStream.ToArray(); + } + } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Export/Csv/One/ExportCsvAccountQueryValidator.cs b/ExpenseTracker.Application/Accounts/Queries/Export/Csv/One/ExportCsvAccountQueryValidator.cs new file mode 100644 index 0000000..9bff980 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Export/Csv/One/ExportCsvAccountQueryValidator.cs @@ -0,0 +1,11 @@ +using FluentValidation; + +namespace ExpenseTracker.Application.Accounts.Queries.Export.Csv.One; + +public class ExportCsvAccountQueryValidator : AbstractValidator +{ + public ExportCsvAccountQueryValidator() + { + RuleFor(e => e.Id).NotEmpty(); + } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Export/Json/Many/ExportJsonAccountsQuery.cs b/ExpenseTracker.Application/Accounts/Queries/Export/Json/Many/ExportJsonAccountsQuery.cs new file mode 100644 index 0000000..5faeb95 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Export/Json/Many/ExportJsonAccountsQuery.cs @@ -0,0 +1,5 @@ +using MediatR; + +namespace ExpenseTracker.Application.Accounts.Queries.Export.Json.Many; + +public record ExportJsonAccountsQuery : IRequest { } diff --git a/ExpenseTracker.Application/Accounts/Queries/Export/Json/Many/ExportJsonAccountsQueryAuthorizer.cs b/ExpenseTracker.Application/Accounts/Queries/Export/Json/Many/ExportJsonAccountsQueryAuthorizer.cs new file mode 100644 index 0000000..ae8c4af --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Export/Json/Many/ExportJsonAccountsQueryAuthorizer.cs @@ -0,0 +1,24 @@ +using MediatR.Behaviors.Authorization; +using ExpenseTracker.Application.Common.Authorization; +using ExpenseTracker.Application.Common.Interfaces.Services; + +namespace ExpenseTracker.Application.Accounts.Queries.Export.Json.Many; + +public class ExportJsonAccountsQueryAuthorizer : AbstractRequestAuthorizer +{ + private readonly ISessionUserService _sessionUserService; + + public ExportJsonAccountsQueryAuthorizer(ISessionUserService currentUserService) + { + _sessionUserService = currentUserService; + } + + public override void BuildPolicy(ExportJsonAccountsQuery request) + { + UseRequirement(new MustBeAuthenticatedRequirement + { + IsAuthenticated = _sessionUserService.IsAuthenticated + }); + } +} + diff --git a/ExpenseTracker.Application/Accounts/Queries/Export/Json/Many/ExportJsonAccountsQueryHandler.cs b/ExpenseTracker.Application/Accounts/Queries/Export/Json/Many/ExportJsonAccountsQueryHandler.cs new file mode 100644 index 0000000..0d5ccf8 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Export/Json/Many/ExportJsonAccountsQueryHandler.cs @@ -0,0 +1,72 @@ +using System.Text; +using AutoMapper; +using MediatR; +using Newtonsoft.Json; +using Newtonsoft.Json.Serialization; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Domain.Entities; +using ExpenseTracker.Domain.Enums; + +namespace ExpenseTracker.Application.Accounts.Queries.Export.Json.Many; + +public class ExportJsonAccountsQueryHandler : IRequestHandler +{ + private readonly IMapper _mapper; + private readonly ISessionUserService _sessionUserService; + private readonly IAccountRepository _accountRepository; + private readonly ITransactionRepository _transactionRepository; + + public ExportJsonAccountsQueryHandler( + IMapper mapper, + ISessionUserService sessionUserService, + IAccountRepository repository, + ITransactionRepository transactionRepository) + { + _mapper = mapper; + _sessionUserService = sessionUserService; + _accountRepository = repository; + _transactionRepository = transactionRepository; + } + + public async Task Handle(ExportJsonAccountsQuery request, CancellationToken cancellationToken) + { + var entities = _accountRepository.Queryable + .Where(e => e.UserId == _sessionUserService.Id) + .GroupJoin( + _transactionRepository.Queryable, + b => b.Id, + t => t.AccountId, + (account, transactions) => + new Account + { + Id = account.Id, + Name = account.Name, + Description = account.Description, + Currency = account.Currency, + UserId = account.UserId, + Transactions = transactions + } + ) + .ToArray(); + + var entityDtos = _mapper.ProjectTo(entities.AsQueryable()); + + var jsonSerializerSettings = new JsonSerializerSettings() + { + ContractResolver = new CamelCasePropertyNamesContractResolver() + }; + var json = JsonConvert.SerializeObject(entityDtos, jsonSerializerSettings); + + using (var memoryStream = new MemoryStream()) + { + using (var streamWriter = new StreamWriter(memoryStream, Encoding.UTF8)) + { + await streamWriter.WriteAsync(json); + await streamWriter.FlushAsync(); + } + + return memoryStream.ToArray(); + } + } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Export/Json/Many/ExportJsonAccountsQueryValidator.cs b/ExpenseTracker.Application/Accounts/Queries/Export/Json/Many/ExportJsonAccountsQueryValidator.cs new file mode 100644 index 0000000..c4dbce5 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Export/Json/Many/ExportJsonAccountsQueryValidator.cs @@ -0,0 +1,10 @@ +using FluentValidation; + +namespace ExpenseTracker.Application.Accounts.Queries.Export.Json.Many; + +public class ExportJsonAccountsQueryValidator : AbstractValidator +{ + public ExportJsonAccountsQueryValidator() + { + } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Export/Json/One/ExportJsonAccountQuery.cs b/ExpenseTracker.Application/Accounts/Queries/Export/Json/One/ExportJsonAccountQuery.cs new file mode 100644 index 0000000..e11d70b --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Export/Json/One/ExportJsonAccountQuery.cs @@ -0,0 +1,8 @@ +using MediatR; + +namespace ExpenseTracker.Application.Accounts.Queries.Export.Json.One; + +public record ExportJsonAccountQuery : IRequest +{ + public string Id { get; set; } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Export/Json/One/ExportJsonAccountQueryAuthorizer.cs b/ExpenseTracker.Application/Accounts/Queries/Export/Json/One/ExportJsonAccountQueryAuthorizer.cs new file mode 100644 index 0000000..1e71cf2 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Export/Json/One/ExportJsonAccountQueryAuthorizer.cs @@ -0,0 +1,37 @@ +using MediatR.Behaviors.Authorization; +using ExpenseTracker.Application.Common.Authorization; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Application.Common.Models; + +namespace ExpenseTracker.Application.Accounts.Queries.Export.Json.One; + +public class ExportJsonAccountQueryAuthorizer : AbstractRequestAuthorizer +{ + private readonly ISessionUserService _sessionUserService; + private readonly IAccountRepository _repository; + + public ExportJsonAccountQueryAuthorizer(ISessionUserService currentUserService, IAccountRepository repository) + { + _sessionUserService = currentUserService; + _repository = repository; + } + + public override void BuildPolicy(ExportJsonAccountQuery request) + { + UseRequirement(new MustBeAuthenticatedRequirement + { + IsAuthenticated = _sessionUserService.IsAuthenticated + }); + + var requiredUserId = _repository.Queryable.FirstOrDefault(e => e.Id == request.Id)?.UserId; + + UseRequirement(new MustBeInRolesWhenInteractingWithUnOwnedEntityRequirement + { + UserId = _sessionUserService.Id, + UserRoles = _sessionUserService.Roles, + RequiredUserId = requiredUserId, + RequiredRoles = new[] { IdentityRoles.Administrator.ToString() } + }); + } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Export/Json/One/ExportJsonAccountQueryHandler.cs b/ExpenseTracker.Application/Accounts/Queries/Export/Json/One/ExportJsonAccountQueryHandler.cs new file mode 100644 index 0000000..cb53b8b --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Export/Json/One/ExportJsonAccountQueryHandler.cs @@ -0,0 +1,69 @@ +using System.Text; +using AutoMapper; +using MediatR; +using Newtonsoft.Json; +using Newtonsoft.Json.Serialization; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Domain.Entities; + +namespace ExpenseTracker.Application.Accounts.Queries.Export.Json.One; + +public class ExportJsonAccountQueryHandler : IRequestHandler +{ + private readonly IMapper _mapper; + private readonly IAccountRepository _accountRepository; + private readonly ITransactionRepository _transactionRepository; + + public ExportJsonAccountQueryHandler( + IMapper mapper, + IAccountRepository repository, + ITransactionRepository transactionRepository) + { + _mapper = mapper; + _accountRepository = repository; + _transactionRepository = transactionRepository; + } + + public async Task Handle(ExportJsonAccountQuery request, CancellationToken cancellationToken) + { + var entity = _accountRepository.Queryable + .GroupJoin( + _transactionRepository.Queryable, + b => b.Id, + t => t.AccountId, + (account, transactions) => + new Account + { + Id = account.Id, + Name = account.Name, + Description = account.Description, + Currency = account.Currency, + UserId = account.UserId, + Transactions = transactions + } + ) + .FirstOrDefault(e => e.Id == request.Id); + + // TODO: Mapping to DTO creates new objects therefore using more resources + // Create custom json serializer to avoid mapping + + var entityDto = _mapper.Map(entity); + + var jsonSerializerSettings = new JsonSerializerSettings() + { + ContractResolver = new CamelCasePropertyNamesContractResolver() + }; + var json = JsonConvert.SerializeObject(entityDto, jsonSerializerSettings); + + using (var memoryStream = new MemoryStream()) + { + using (var streamWriter = new StreamWriter(memoryStream, Encoding.UTF8)) + { + await streamWriter.WriteAsync(json); + await streamWriter.FlushAsync(); + } + + return memoryStream.ToArray(); + } + } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Export/Json/One/ExportJsonAccountQueryValidator.cs b/ExpenseTracker.Application/Accounts/Queries/Export/Json/One/ExportJsonAccountQueryValidator.cs new file mode 100644 index 0000000..38d8ba9 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Export/Json/One/ExportJsonAccountQueryValidator.cs @@ -0,0 +1,11 @@ +using FluentValidation; + +namespace ExpenseTracker.Application.Accounts.Queries.Export.Json.One; + +public class ExportJsonAccountQueryValidator : AbstractValidator +{ + public ExportJsonAccountQueryValidator() + { + RuleFor(e => e.Id).NotEmpty(); + } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Get/GetAccountQuery.cs b/ExpenseTracker.Application/Accounts/Queries/Get/GetAccountQuery.cs new file mode 100644 index 0000000..5e31a6f --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Get/GetAccountQuery.cs @@ -0,0 +1,8 @@ +using MediatR; + +namespace ExpenseTracker.Application.Accounts.Queries.Get; + +public record GetAccountQuery : IRequest +{ + public string Id { get; set; } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Get/GetAccountQueryAuthorizer.cs b/ExpenseTracker.Application/Accounts/Queries/Get/GetAccountQueryAuthorizer.cs new file mode 100644 index 0000000..25679aa --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Get/GetAccountQueryAuthorizer.cs @@ -0,0 +1,37 @@ +using MediatR.Behaviors.Authorization; +using ExpenseTracker.Application.Common.Authorization; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Application.Common.Models; + +namespace ExpenseTracker.Application.Accounts.Queries.Get; + +public class GetAccountQueryAuthorizer : AbstractRequestAuthorizer +{ + private readonly ISessionUserService _sessionUserService; + private readonly IAccountRepository _repository; + + public GetAccountQueryAuthorizer(ISessionUserService currentUserService, IAccountRepository repository) + { + _sessionUserService = currentUserService; + _repository = repository; + } + + public override void BuildPolicy(GetAccountQuery request) + { + UseRequirement(new MustBeAuthenticatedRequirement + { + IsAuthenticated = _sessionUserService.IsAuthenticated + }); + + var requiredUserId = _repository.Queryable.FirstOrDefault(e => e.Id == request.Id)?.UserId; + + UseRequirement(new MustBeInRolesWhenInteractingWithUnOwnedEntityRequirement + { + UserId = _sessionUserService.Id, + UserRoles = _sessionUserService.Roles, + RequiredUserId = requiredUserId, + RequiredRoles = new[] { IdentityRoles.Administrator.ToString() } + }); + } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Get/GetAccountQueryHandler.cs b/ExpenseTracker.Application/Accounts/Queries/Get/GetAccountQueryHandler.cs new file mode 100644 index 0000000..3479af9 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Get/GetAccountQueryHandler.cs @@ -0,0 +1,31 @@ +using AutoMapper; +using MediatR; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Domain.Entities; + +namespace ExpenseTracker.Application.Accounts.Queries.Get; + +public class GetAccountQueryHandler : IRequestHandler +{ + private readonly IMapper _mapper; + private readonly IAccountRepository _accountRepository; + private readonly ITransactionRepository _transactionRepository; + + public GetAccountQueryHandler( + IMapper mapper, + IAccountRepository repository, + ITransactionRepository transactionRepository) + { + _mapper = mapper; + _accountRepository = repository; + _transactionRepository = transactionRepository; + } + + public async Task Handle(GetAccountQuery request, CancellationToken cancellationToken) + { + var entity = _accountRepository.Queryable + .FirstOrDefault(e => e.Id == request.Id); + + return _mapper.Map(entity); + } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/Get/GetAccountQueryValidator.cs b/ExpenseTracker.Application/Accounts/Queries/Get/GetAccountQueryValidator.cs new file mode 100644 index 0000000..3f523da --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/Get/GetAccountQueryValidator.cs @@ -0,0 +1,12 @@ +using FluentValidation; + +namespace ExpenseTracker.Application.Accounts.Queries.Get; + +public class GetAccountQueryValidator : AbstractValidator +{ + public GetAccountQueryValidator() + { + RuleFor(e => e.Id) + .NotEmpty(); + } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/GetWithPagination/GetAccountsWithPaginationQuery.cs b/ExpenseTracker.Application/Accounts/Queries/GetWithPagination/GetAccountsWithPaginationQuery.cs new file mode 100644 index 0000000..01f2748 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/GetWithPagination/GetAccountsWithPaginationQuery.cs @@ -0,0 +1,13 @@ +using ExpenseTracker.Application.Common.Models; +using MediatR; + +namespace ExpenseTracker.Application.Accounts.Queries.GetWithPagination; + +public record GetAccountsWithPaginationQuery : IRequest> +{ + public int PageNumber { get; set; } = 1; + + public int PageSize { get; set; } = 10; + + public bool GetAll { get; set; } = false; +} diff --git a/ExpenseTracker.Application/Accounts/Queries/GetWithPagination/GetAccountsWithPaginationQueryAuthorizer.cs b/ExpenseTracker.Application/Accounts/Queries/GetWithPagination/GetAccountsWithPaginationQueryAuthorizer.cs new file mode 100644 index 0000000..6383d7b --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/GetWithPagination/GetAccountsWithPaginationQueryAuthorizer.cs @@ -0,0 +1,33 @@ +using MediatR.Behaviors.Authorization; +using ExpenseTracker.Application.Common.Authorization; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Application.Common.Models; + +namespace ExpenseTracker.Application.Accounts.Queries.GetWithPagination; + +public class GetAccountsWithPaginationQueryAuthorizer : AbstractRequestAuthorizer +{ + private readonly ISessionUserService _sessionUserService; + + public GetAccountsWithPaginationQueryAuthorizer(ISessionUserService currentUserService) + { + _sessionUserService = currentUserService; + } + + public override void BuildPolicy(GetAccountsWithPaginationQuery request) + { + UseRequirement(new MustBeAuthenticatedRequirement + { + IsAuthenticated = _sessionUserService.IsAuthenticated + }); + + if (request.GetAll) + { + UseRequirement(new MustBeInRolesRequirement + { + UserRoles = _sessionUserService.Roles, + RequiredRoles = new[] { IdentityRoles.Administrator.ToString() } + }); + } + } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/GetWithPagination/GetAccountsWithPaginationQueryHandler.cs b/ExpenseTracker.Application/Accounts/Queries/GetWithPagination/GetAccountsWithPaginationQueryHandler.cs new file mode 100644 index 0000000..333abb0 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/GetWithPagination/GetAccountsWithPaginationQueryHandler.cs @@ -0,0 +1,42 @@ +using AutoMapper; +using MediatR; +using ExpenseTracker.Application.Common.Extensions; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Application.Common.Models; +using ExpenseTracker.Domain.Entities; + +namespace ExpenseTracker.Application.Accounts.Queries.GetWithPagination; + +public class GetAccountssWithPaginationQueryHandler : IRequestHandler> +{ + private readonly IMapper _mapper; + private readonly IAccountRepository _accountRepository; + private readonly ITransactionRepository _transactionRepository; + private readonly ISessionUserService _sessionUserService; + + public GetAccountssWithPaginationQueryHandler( + IMapper mapper, + IAccountRepository repository, + ITransactionRepository transactionRepository, + ISessionUserService sessionUserService) + { + _mapper = mapper; + _accountRepository = repository; + _sessionUserService = sessionUserService; + _transactionRepository = transactionRepository; + } + + public async Task> Handle(GetAccountsWithPaginationQuery request, CancellationToken cancellationToken) + { + var entities = _accountRepository.Queryable; + + if (!request.GetAll) + { + entities = entities.Where(e => e.UserId == _sessionUserService.Id); + } + + return entities + .ProjectToPaginatedList(request.PageNumber, request.PageSize, _mapper.ConfigurationProvider); + } +} diff --git a/ExpenseTracker.Application/Accounts/Queries/GetWithPagination/GetAccountsWithPaginationQueryValidator.cs b/ExpenseTracker.Application/Accounts/Queries/GetWithPagination/GetAccountsWithPaginationQueryValidator.cs new file mode 100644 index 0000000..f50d9e2 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/Queries/GetWithPagination/GetAccountsWithPaginationQueryValidator.cs @@ -0,0 +1,16 @@ +using FluentValidation; + +namespace ExpenseTracker.Application.Accounts.Queries.GetWithPagination; + +public class GetAccountsWithPaginationQueryValidator : AbstractValidator +{ + public GetAccountsWithPaginationQueryValidator() + { + RuleFor(v => v.PageNumber) + .GreaterThanOrEqualTo(1); + + RuleFor(v => v.PageSize) + .GreaterThanOrEqualTo(1) + .LessThanOrEqualTo(50); + } +} diff --git a/ExpenseTracker.Application/Accounts/TransactionCsvMap.cs b/ExpenseTracker.Application/Accounts/TransactionCsvMap.cs new file mode 100644 index 0000000..5199783 --- /dev/null +++ b/ExpenseTracker.Application/Accounts/TransactionCsvMap.cs @@ -0,0 +1,20 @@ +using System.Globalization; +using CsvHelper.Configuration; +using ExpenseTracker.Application.Common.Extensions; +using ExpenseTracker.Application.Transactions; + +namespace ExpenseTracker.Application.Accounts; + +public class TransactionCsvMap : ClassMap +{ + public TransactionCsvMap() + { + AutoMap(CultureInfo.InvariantCulture); + Map(e => e.Id).Ignore(); + Map(e => e.Amount).Name(nameof(TransactionDto.Amount).ToString().FirstCharacterToLower()); + Map(e => e.Category).Name(nameof(TransactionDto.Category).ToString().FirstCharacterToLower()); + Map(e => e.Time).Name(nameof(TransactionDto.Time).ToString().FirstCharacterToLower()); + Map(e => e.Description).Name(nameof(TransactionDto.Description).ToString().FirstCharacterToLower()); + Map(e => e.AccountId).Ignore(); + } +} diff --git a/ExpenseTracker.Application/Authentication/Commands/RegisterWithEmail/RegisterWithEmailCommand.cs b/ExpenseTracker.Application/Authentication/Commands/RegisterWithEmail/RegisterWithEmailCommand.cs new file mode 100644 index 0000000..d0231db --- /dev/null +++ b/ExpenseTracker.Application/Authentication/Commands/RegisterWithEmail/RegisterWithEmailCommand.cs @@ -0,0 +1,8 @@ +using MediatR; + +namespace ExpenseTracker.Application.Authentication.Commands.RegisterWithEmail; + +public record RegisterWithEmailCommand : IRequest +{ + public required string Email { get; set; } +} diff --git a/ExpenseTracker.Application/Authentication/Commands/RegisterWithEmail/RegisterWithEmailCommandHandler.cs b/ExpenseTracker.Application/Authentication/Commands/RegisterWithEmail/RegisterWithEmailCommandHandler.cs new file mode 100644 index 0000000..245f114 --- /dev/null +++ b/ExpenseTracker.Application/Authentication/Commands/RegisterWithEmail/RegisterWithEmailCommandHandler.cs @@ -0,0 +1,19 @@ +using ExpenseTracker.Application.Common.Interfaces.Services; +using MediatR; + +namespace ExpenseTracker.Application.Authentication.Commands.RegisterWithEmail; + +public class RegisterWithEmailCommandHandler : IRequestHandler +{ + private readonly IAuthenticationService _authenticationService; + + public RegisterWithEmailCommandHandler(IAuthenticationService authenticationService) + { + _authenticationService = authenticationService; + } + + public async Task Handle(RegisterWithEmailCommand request, CancellationToken cancellationToken) + { + await _authenticationService.RegisterWithEmailAsync(request.Email, cancellationToken); + } +} diff --git a/ExpenseTracker.Application/Authentication/Commands/RegisterWithEmail/RegisterWithEmailValidator.cs b/ExpenseTracker.Application/Authentication/Commands/RegisterWithEmail/RegisterWithEmailValidator.cs new file mode 100644 index 0000000..c0710f2 --- /dev/null +++ b/ExpenseTracker.Application/Authentication/Commands/RegisterWithEmail/RegisterWithEmailValidator.cs @@ -0,0 +1,16 @@ +using FluentValidation; + +namespace ExpenseTracker.Application.Authentication.Commands.RegisterWithEmail; + +public class RegisterWithEmailCommandValidator : AbstractValidator +{ + public RegisterWithEmailCommandValidator() + { + // https://regexr.com/2ri2c + RuleFor(v => v.Email) + .NotEmpty() + .WithMessage("Email address is required.") + .Matches(@"\b[\w\.-]+@[\w\.-]+\.\w{2,4}\b") + .WithMessage("Email address is invalid."); + } +} diff --git a/ExpenseTracker.Application/Authentication/Commands/RegisterWithEmailAndPassword/RegisterWithEmailAndPasswordCommand.cs b/ExpenseTracker.Application/Authentication/Commands/RegisterWithEmailAndPassword/RegisterWithEmailAndPasswordCommand.cs new file mode 100644 index 0000000..787fd54 --- /dev/null +++ b/ExpenseTracker.Application/Authentication/Commands/RegisterWithEmailAndPassword/RegisterWithEmailAndPasswordCommand.cs @@ -0,0 +1,10 @@ +using MediatR; + +namespace ExpenseTracker.Application.Authentication.Commands.RegisterWithEmailAndPassword; + +public record RegisterWithEmailAndPasswordCommand : IRequest +{ + public required string Email { get; set; } + + public required string Password { get; set; } +} diff --git a/ExpenseTracker.Application/Authentication/Commands/RegisterWithEmailAndPassword/RegisterWithEmailAndPasswordCommandHandler.cs b/ExpenseTracker.Application/Authentication/Commands/RegisterWithEmailAndPassword/RegisterWithEmailAndPasswordCommandHandler.cs new file mode 100644 index 0000000..f33b60b --- /dev/null +++ b/ExpenseTracker.Application/Authentication/Commands/RegisterWithEmailAndPassword/RegisterWithEmailAndPasswordCommandHandler.cs @@ -0,0 +1,19 @@ +using ExpenseTracker.Application.Common.Interfaces.Services; +using MediatR; + +namespace ExpenseTracker.Application.Authentication.Commands.RegisterWithEmailAndPassword; + +public class RegisterWithEmailAndPasswordCommandHandler : IRequestHandler +{ + private readonly IAuthenticationService _authenticationService; + + public RegisterWithEmailAndPasswordCommandHandler(IAuthenticationService authenticationService) + { + _authenticationService = authenticationService; + } + + public async Task Handle(RegisterWithEmailAndPasswordCommand request, CancellationToken cancellationToken) + { + await _authenticationService.RegisterWithEmailAndPasswordAsync(request.Email, request.Password, cancellationToken); + } +} diff --git a/ExpenseTracker.Application/Authentication/Commands/RegisterWithEmailAndPassword/RegisterWithEmailAndPasswordCommandValidator.cs b/ExpenseTracker.Application/Authentication/Commands/RegisterWithEmailAndPassword/RegisterWithEmailAndPasswordCommandValidator.cs new file mode 100644 index 0000000..b9403c9 --- /dev/null +++ b/ExpenseTracker.Application/Authentication/Commands/RegisterWithEmailAndPassword/RegisterWithEmailAndPasswordCommandValidator.cs @@ -0,0 +1,23 @@ +using FluentValidation; + +namespace ExpenseTracker.Application.Authentication.Commands.RegisterWithEmailAndPassword; + +public class RegisterWithEmailAndPasswordCommandValidator : AbstractValidator +{ + public RegisterWithEmailAndPasswordCommandValidator() + { + // https://regexr.com/2ri2c + RuleFor(v => v.Email) + .NotEmpty().WithMessage("Email address is required.") + .Matches(@"\b[\w\.-]+@[\w\.-]+\.\w{2,4}\b").WithMessage("Email address is invalid."); + + RuleFor(v => v.Password) + .NotEmpty().WithMessage("Password is required.") + .MinimumLength(8).WithMessage("Password must be at least 8 characters long.") + .MaximumLength(64).WithMessage("Password must be at most 64 characters long.") + .Matches(@"(?=.*[A-Z]).*").WithMessage("Password must contain at least one uppercase letter.") + .Matches(@"(?=.*[a-z]).*").WithMessage("Password must contain at least one lowercase letter.") + .Matches(@"(?=.*[\d]).*").WithMessage("Password must contain at least one digit.") + .Matches(@"(?=.*[!@#$%^&*()]).*").WithMessage("Password must contain at least one of the following special charactters: !@#$%^&*()."); + } +} diff --git a/ExpenseTracker.Application/Authentication/Commands/RenewAccessTokenWithBody/RenewAccessTokenWithBodyCommand.cs b/ExpenseTracker.Application/Authentication/Commands/RenewAccessTokenWithBody/RenewAccessTokenWithBodyCommand.cs new file mode 100644 index 0000000..42f0a5c --- /dev/null +++ b/ExpenseTracker.Application/Authentication/Commands/RenewAccessTokenWithBody/RenewAccessTokenWithBodyCommand.cs @@ -0,0 +1,8 @@ +using MediatR; + +namespace ExpenseTracker.Application.Authentication.Commands.RenewAccessTokenWithBody; + +public record RenewAccessTokenWithBodyCommand : IRequest +{ + public required string RefreshToken { get; set; } +} diff --git a/ExpenseTracker.Application/Authentication/Commands/RenewAccessTokenWithBody/RenewAccessTokenWithBodyCommandHandler.cs b/ExpenseTracker.Application/Authentication/Commands/RenewAccessTokenWithBody/RenewAccessTokenWithBodyCommandHandler.cs new file mode 100644 index 0000000..c815ff4 --- /dev/null +++ b/ExpenseTracker.Application/Authentication/Commands/RenewAccessTokenWithBody/RenewAccessTokenWithBodyCommandHandler.cs @@ -0,0 +1,19 @@ +using ExpenseTracker.Application.Common.Interfaces.Services; +using MediatR; + +namespace ExpenseTracker.Application.Authentication.Commands.RenewAccessTokenWithBody; + +public class RenewAccessTokenWithBodyCommandHandler : IRequestHandler +{ + private readonly IAuthenticationService _authenticationService; + + public RenewAccessTokenWithBodyCommandHandler(IAuthenticationService authenticationService) + { + _authenticationService = authenticationService; + } + + public async Task Handle(RenewAccessTokenWithBodyCommand request, CancellationToken cancellationToken) + { + return await _authenticationService.RenewAccessTokenAsync(request.RefreshToken, cancellationToken); + } +} diff --git a/ExpenseTracker.Application/Authentication/Commands/RenewAccessTokenWithBody/RenewAccessTokenWithBodyCommandValidator.cs b/ExpenseTracker.Application/Authentication/Commands/RenewAccessTokenWithBody/RenewAccessTokenWithBodyCommandValidator.cs new file mode 100644 index 0000000..e3d45b6 --- /dev/null +++ b/ExpenseTracker.Application/Authentication/Commands/RenewAccessTokenWithBody/RenewAccessTokenWithBodyCommandValidator.cs @@ -0,0 +1,11 @@ +using FluentValidation; + +namespace ExpenseTracker.Application.Authentication.Commands.RenewAccessTokenWithBody; + +public class RenewAccessTokenWithBodyCommandValidator : AbstractValidator +{ + public RenewAccessTokenWithBodyCommandValidator() + { + RuleFor(v => v.RefreshToken).NotEmpty(); + } +} diff --git a/ExpenseTracker.Application/Authentication/Commands/RenewAccessTokenWithCookie/RenewAccessTokenWithCookieCommand.cs b/ExpenseTracker.Application/Authentication/Commands/RenewAccessTokenWithCookie/RenewAccessTokenWithCookieCommand.cs new file mode 100644 index 0000000..cd9b46e --- /dev/null +++ b/ExpenseTracker.Application/Authentication/Commands/RenewAccessTokenWithCookie/RenewAccessTokenWithCookieCommand.cs @@ -0,0 +1,5 @@ +using MediatR; + +namespace ExpenseTracker.Application.Authentication.Commands.RenewAccessTokenWithCookie; + +public record RenewAccessTokenWithCookieCommand : IRequest { } diff --git a/ExpenseTracker.Application/Authentication/Commands/RenewAccessTokenWithCookie/RenewAccessTokenWithCookieCommandHandler.cs b/ExpenseTracker.Application/Authentication/Commands/RenewAccessTokenWithCookie/RenewAccessTokenWithCookieCommandHandler.cs new file mode 100644 index 0000000..20b846c --- /dev/null +++ b/ExpenseTracker.Application/Authentication/Commands/RenewAccessTokenWithCookie/RenewAccessTokenWithCookieCommandHandler.cs @@ -0,0 +1,23 @@ +using ExpenseTracker.Application.Common.Interfaces.Services; +using MediatR; + +namespace ExpenseTracker.Application.Authentication.Commands.RenewAccessTokenWithCookie; + +public class RenewAccessTokenWithCookieCommandHandler : IRequestHandler +{ + private readonly ISessionUserService _sessionUserService; + private readonly IAuthenticationService _authenticationService; + + public RenewAccessTokenWithCookieCommandHandler( + ISessionUserService sessionUserService, + IAuthenticationService authenticationService) + { + _sessionUserService = sessionUserService; + _authenticationService = authenticationService; + } + + public async Task Handle(RenewAccessTokenWithCookieCommand request, CancellationToken cancellationToken) + { + return await _authenticationService.RenewAccessTokenAsync(_sessionUserService.RefreshToken, cancellationToken); + } +} diff --git a/ExpenseTracker.Application/Authentication/Commands/RenewAccessTokenWithCookie/RenewAccessTokenWithCookieCommandValidator.cs b/ExpenseTracker.Application/Authentication/Commands/RenewAccessTokenWithCookie/RenewAccessTokenWithCookieCommandValidator.cs new file mode 100644 index 0000000..6095052 --- /dev/null +++ b/ExpenseTracker.Application/Authentication/Commands/RenewAccessTokenWithCookie/RenewAccessTokenWithCookieCommandValidator.cs @@ -0,0 +1,17 @@ +using ExpenseTracker.Application.Common.Interfaces.Services; +using FluentValidation; + +namespace ExpenseTracker.Application.Authentication.Commands.RenewAccessTokenWithCookie; + +public class RenewAccessTokenWithCookieCommandValidator : AbstractValidator +{ + private readonly ISessionUserService _sessionUserService; + + public RenewAccessTokenWithCookieCommandValidator(ISessionUserService sessionUserService) + { + _sessionUserService = sessionUserService; + + RuleFor(e => e) + .Must(_ => _sessionUserService.RefreshToken != null); + } +} diff --git a/ExpenseTracker.Application/Authentication/Commands/RevokeRefreshTokenWithBody/RevokeRefreshTokenWithBodyCommand.cs b/ExpenseTracker.Application/Authentication/Commands/RevokeRefreshTokenWithBody/RevokeRefreshTokenWithBodyCommand.cs new file mode 100644 index 0000000..ce33cf4 --- /dev/null +++ b/ExpenseTracker.Application/Authentication/Commands/RevokeRefreshTokenWithBody/RevokeRefreshTokenWithBodyCommand.cs @@ -0,0 +1,8 @@ +using MediatR; + +namespace ExpenseTracker.Application.Authentication.Commands.RevokeRefreshTokenWithBody; + +public record RevokeRefreshTokenWithBodyCommand : IRequest +{ + public required string RefreshToken { get; set; } +} diff --git a/ExpenseTracker.Application/Authentication/Commands/RevokeRefreshTokenWithBody/RevokeRefreshTokenWithBodyCommandHandler.cs b/ExpenseTracker.Application/Authentication/Commands/RevokeRefreshTokenWithBody/RevokeRefreshTokenWithBodyCommandHandler.cs new file mode 100644 index 0000000..86b6499 --- /dev/null +++ b/ExpenseTracker.Application/Authentication/Commands/RevokeRefreshTokenWithBody/RevokeRefreshTokenWithBodyCommandHandler.cs @@ -0,0 +1,19 @@ +using ExpenseTracker.Application.Common.Interfaces.Services; +using MediatR; + +namespace ExpenseTracker.Application.Authentication.Commands.RevokeRefreshTokenWithBody; + +public class RevokeRefreshTokenWithBodyCommandHandler : IRequestHandler +{ + private readonly IAuthenticationService _authenticationService; + + public RevokeRefreshTokenWithBodyCommandHandler(IAuthenticationService authenticationService) + { + _authenticationService = authenticationService; + } + + public async Task Handle(RevokeRefreshTokenWithBodyCommand request, CancellationToken cancellationToken) + { + await _authenticationService.RevokeRefreshTokenAsync(request.RefreshToken, cancellationToken); + } +} diff --git a/ExpenseTracker.Application/Authentication/Commands/RevokeRefreshTokenWithBody/RevokeRefreshTokenWithBodyCommandValidator.cs b/ExpenseTracker.Application/Authentication/Commands/RevokeRefreshTokenWithBody/RevokeRefreshTokenWithBodyCommandValidator.cs new file mode 100644 index 0000000..aafbbac --- /dev/null +++ b/ExpenseTracker.Application/Authentication/Commands/RevokeRefreshTokenWithBody/RevokeRefreshTokenWithBodyCommandValidator.cs @@ -0,0 +1,11 @@ +using FluentValidation; + +namespace ExpenseTracker.Application.Authentication.Commands.RevokeRefreshTokenWithBody; + +public class RevokeRefreshTokenWithBodyCommandValidator : AbstractValidator +{ + public RevokeRefreshTokenWithBodyCommandValidator() + { + RuleFor(v => v.RefreshToken).NotEmpty(); + } +} diff --git a/ExpenseTracker.Application/Authentication/Commands/RevokeRefreshTokenWithCookie/RevokeRefreshTokenWithBodyCommand.cs b/ExpenseTracker.Application/Authentication/Commands/RevokeRefreshTokenWithCookie/RevokeRefreshTokenWithBodyCommand.cs new file mode 100644 index 0000000..14b4c31 --- /dev/null +++ b/ExpenseTracker.Application/Authentication/Commands/RevokeRefreshTokenWithCookie/RevokeRefreshTokenWithBodyCommand.cs @@ -0,0 +1,5 @@ +using MediatR; + +namespace ExpenseTracker.Application.Authentication.Commands.RevokeRefreshTokenWithCookie; + +public record RevokeRefreshTokenWithCookieCommand : IRequest { } diff --git a/ExpenseTracker.Application/Authentication/Commands/RevokeRefreshTokenWithCookie/RevokeRefreshTokenWithBodyCommandHandler.cs b/ExpenseTracker.Application/Authentication/Commands/RevokeRefreshTokenWithCookie/RevokeRefreshTokenWithBodyCommandHandler.cs new file mode 100644 index 0000000..0bd153a --- /dev/null +++ b/ExpenseTracker.Application/Authentication/Commands/RevokeRefreshTokenWithCookie/RevokeRefreshTokenWithBodyCommandHandler.cs @@ -0,0 +1,23 @@ +using ExpenseTracker.Application.Common.Interfaces.Services; +using MediatR; + +namespace ExpenseTracker.Application.Authentication.Commands.RevokeRefreshTokenWithCookie; + +public class RevokeRefreshTokenWithCookieCommandHandler : IRequestHandler +{ + private readonly ISessionUserService _sessionUserService; + private readonly IAuthenticationService _authenticationService; + + public RevokeRefreshTokenWithCookieCommandHandler( + ISessionUserService sessionUserService, + IAuthenticationService authenticationService) + { + _sessionUserService = sessionUserService; + _authenticationService = authenticationService; + } + + public async Task Handle(RevokeRefreshTokenWithCookieCommand request, CancellationToken cancellationToken) + { + await _authenticationService.RevokeRefreshTokenAsync(_sessionUserService.RefreshToken, cancellationToken); + } +} diff --git a/ExpenseTracker.Application/Authentication/Commands/RevokeRefreshTokenWithCookie/RevokeRefreshTokenWithBodyCommandValidator.cs b/ExpenseTracker.Application/Authentication/Commands/RevokeRefreshTokenWithCookie/RevokeRefreshTokenWithBodyCommandValidator.cs new file mode 100644 index 0000000..2ebdd53 --- /dev/null +++ b/ExpenseTracker.Application/Authentication/Commands/RevokeRefreshTokenWithCookie/RevokeRefreshTokenWithBodyCommandValidator.cs @@ -0,0 +1,17 @@ +using ExpenseTracker.Application.Common.Interfaces.Services; +using FluentValidation; + +namespace ExpenseTracker.Application.Authentication.Commands.RevokeRefreshTokenWithCookie; + +public class RevokeRefreshTokenWithBodyCommandValidator : AbstractValidator +{ + private readonly ISessionUserService _sessionUserService; + + public RevokeRefreshTokenWithBodyCommandValidator(ISessionUserService sessionUserService) + { + _sessionUserService = sessionUserService; + + RuleFor(e => e) + .Must(_ => _sessionUserService.RefreshToken != null); + } +} diff --git a/ExpenseTracker.Application/Authentication/Queries/Login/LoginQuery.cs b/ExpenseTracker.Application/Authentication/Queries/Login/LoginQuery.cs new file mode 100644 index 0000000..9477163 --- /dev/null +++ b/ExpenseTracker.Application/Authentication/Queries/Login/LoginQuery.cs @@ -0,0 +1,10 @@ +using MediatR; + +namespace ExpenseTracker.Application.Authentication.Queries.Login; + +public record LoginQuery : IRequest +{ + public required string Email { get; set; } + + public required string Password { get; set; } +} diff --git a/ExpenseTracker.Application/Authentication/Queries/Login/LoginQueryHandler.cs b/ExpenseTracker.Application/Authentication/Queries/Login/LoginQueryHandler.cs new file mode 100644 index 0000000..927e5d0 --- /dev/null +++ b/ExpenseTracker.Application/Authentication/Queries/Login/LoginQueryHandler.cs @@ -0,0 +1,19 @@ +using ExpenseTracker.Application.Common.Interfaces.Services; +using MediatR; + +namespace ExpenseTracker.Application.Authentication.Queries.Login; + +public class LoginQueryHandler : IRequestHandler +{ + private readonly IAuthenticationService _authenticationService; + + public LoginQueryHandler(IAuthenticationService authenticationService) + { + _authenticationService = authenticationService; + } + + public async Task Handle(LoginQuery request, CancellationToken cancellationToken) + { + return await _authenticationService.LoginAsync(request.Email, request.Password, cancellationToken); + } +} diff --git a/ExpenseTracker.Application/Authentication/Queries/Login/LoginQueryValidator.cs b/ExpenseTracker.Application/Authentication/Queries/Login/LoginQueryValidator.cs new file mode 100644 index 0000000..9ff7e1f --- /dev/null +++ b/ExpenseTracker.Application/Authentication/Queries/Login/LoginQueryValidator.cs @@ -0,0 +1,16 @@ +using FluentValidation; + +namespace ExpenseTracker.Application.Authentication.Queries.Login; + +public class LoginQueryValidator : AbstractValidator +{ + public LoginQueryValidator() + { + RuleFor(v => v.Email) + .NotEmpty().WithMessage("Email address is required."); + // .EmailAddress().WithMessage("Email address is invalid."); + + RuleFor(v => v.Password) + .NotEmpty().WithMessage("Password is required."); + } +} diff --git a/ExpenseTracker.Application/Authentication/TokensModel.cs b/ExpenseTracker.Application/Authentication/TokensModel.cs new file mode 100644 index 0000000..0d88316 --- /dev/null +++ b/ExpenseTracker.Application/Authentication/TokensModel.cs @@ -0,0 +1,14 @@ +namespace ExpenseTracker.Application.Authentication; + +public class TokensModel +{ + public TokensModel(string accessToken, string refreshToken) + { + AccessToken = accessToken; + RefreshToken = refreshToken; + } + + public string AccessToken { get; protected set; } + + public string RefreshToken { get; protected set; } +} diff --git a/ExpenseTracker.Application/Common/Authorization/CustomUnAuthorizedResultHandler.cs b/ExpenseTracker.Application/Common/Authorization/CustomUnAuthorizedResultHandler.cs new file mode 100644 index 0000000..ff87127 --- /dev/null +++ b/ExpenseTracker.Application/Common/Authorization/CustomUnAuthorizedResultHandler.cs @@ -0,0 +1,13 @@ +using MediatR.Behaviors.Authorization; +using MediatR.Behaviors.Authorization.Interfaces; +using ExpenseTracker.Application.Common.Exceptions; + +namespace ExpenseTracker.Application.Common.Authorization; + +public class CustomUnauthorizedResultHandler : IUnauthorizedResultHandler + { + public Task Invoke(AuthorizationResult result) + { + throw new ForbiddenException(result.FailureMessage); + } + } diff --git a/ExpenseTracker.Application/Common/Authorization/MustBeAuthenticatedRequirement.cs b/ExpenseTracker.Application/Common/Authorization/MustBeAuthenticatedRequirement.cs new file mode 100644 index 0000000..d2a4cbc --- /dev/null +++ b/ExpenseTracker.Application/Common/Authorization/MustBeAuthenticatedRequirement.cs @@ -0,0 +1,22 @@ +using MediatR.Behaviors.Authorization; +using ExpenseTracker.Application.Common.Exceptions; + +namespace ExpenseTracker.Application.Common.Authorization; + +public class MustBeAuthenticatedRequirement : IAuthorizationRequirement +{ + public required bool IsAuthenticated { get; init; } = default!; + + class MustBeAuthenticatedRequirementHandler : IAuthorizationHandler + { + public async Task Handle(MustBeAuthenticatedRequirement request, CancellationToken cancellationToken) + { + if (!request.IsAuthenticated) + { + throw new UnAuthorizedException(); + } + + return AuthorizationResult.Succeed(); + } + } +} diff --git a/ExpenseTracker.Application/Common/Authorization/MustBeInRolesRequirement.cs b/ExpenseTracker.Application/Common/Authorization/MustBeInRolesRequirement.cs new file mode 100644 index 0000000..dca15d3 --- /dev/null +++ b/ExpenseTracker.Application/Common/Authorization/MustBeInRolesRequirement.cs @@ -0,0 +1,24 @@ +using MediatR.Behaviors.Authorization; + +namespace ExpenseTracker.Application.Common.Authorization; + +public class MustBeInRolesRequirement : IAuthorizationRequirement +{ + public required ICollection UserRoles { get; init; } = default!; + public required ICollection RequiredRoles { get; init; } = default!; + + class MustBeInAdministratorRoleRequirementHandler : IAuthorizationHandler + { + public async Task Handle(MustBeInRolesRequirement request, CancellationToken cancellationToken) + { + var isUserInRequiredRoles = request.UserRoles.Any(ur => request.RequiredRoles.Contains(ur)); + + if (isUserInRequiredRoles) + { + return AuthorizationResult.Succeed(); + } + + return AuthorizationResult.Fail($"You must be in one of the following roles: '{String.Join("', ", request.RequiredRoles)}'."); + } + } +} diff --git a/ExpenseTracker.Application/Common/Authorization/MustBeInRolesWhenInteractingWithUnOwnedEntityRequirement.cs b/ExpenseTracker.Application/Common/Authorization/MustBeInRolesWhenInteractingWithUnOwnedEntityRequirement.cs new file mode 100644 index 0000000..4b6c855 --- /dev/null +++ b/ExpenseTracker.Application/Common/Authorization/MustBeInRolesWhenInteractingWithUnOwnedEntityRequirement.cs @@ -0,0 +1,28 @@ +using MediatR.Behaviors.Authorization; + +namespace ExpenseTracker.Application.Common.Authorization; + +public class MustBeInRolesWhenInteractingWithUnOwnedEntityRequirement : IAuthorizationRequirement +{ + public required string UserId { get; init; } = default!; + public required ICollection UserRoles { get; init; } = default!; + + public required string RequiredUserId { get; init; } = default!; + public required ICollection RequiredRoles { get; init; } = default!; + + class MustBeInAdministratorRoleRequirementHandler : IAuthorizationHandler + { + public async Task Handle(MustBeInRolesWhenInteractingWithUnOwnedEntityRequirement request, CancellationToken cancellationToken) + { + var isUserOwner = request.UserId == request.RequiredUserId; + var isUserInRequiredRoles = request.UserRoles.Any(ur => request.RequiredRoles.Contains(ur)); + + if (isUserOwner || isUserInRequiredRoles) + { + return AuthorizationResult.Succeed(); + } + + return AuthorizationResult.Fail($"You must be the entity owner or be in one of the following roles: '{String.Join("', ", request.RequiredRoles)}'."); + } + } +} diff --git a/ExpenseTracker.Application/Common/Behaviours/LoggingBehaviour.cs b/ExpenseTracker.Application/Common/Behaviours/LoggingBehaviour.cs new file mode 100644 index 0000000..7291a28 --- /dev/null +++ b/ExpenseTracker.Application/Common/Behaviours/LoggingBehaviour.cs @@ -0,0 +1,46 @@ +using System.Diagnostics; +using MediatR; +using Microsoft.Extensions.Logging; +using ExpenseTracker.Application.Common.Interfaces.Services; + +namespace ExpenseTracker.Application.Common.Behaviours; + +public class LoggingBehaviour : IPipelineBehavior + where TRequest : notnull +{ + private readonly ILogger _logger; + private readonly ISessionUserService _sessionUserService; + + public LoggingBehaviour(ILogger logger, ISessionUserService sessionUserService) + { + _logger = logger; + _sessionUserService = sessionUserService; + } + + public async Task Handle(TRequest request, RequestHandlerDelegate next, CancellationToken cancellationToken) + { + _logger.LogInformation( + "{@DateUtc} {@TimeUtc} {@TraceId} {@SpanId} Handling {@RequestName} by user with Email: {@UserEmail} and UserId: {@UserId}.", + DateTime.UtcNow.ToString("yyyy-MM-dd"), + DateTime.UtcNow.ToString("HH:mm:ss.FFF"), + Activity.Current?.TraceId.ToString(), + Activity.Current?.SpanId.ToString(), + typeof(TRequest).Name, + _sessionUserService.Email, + _sessionUserService.Id); + + var response = await next(); + + _logger.LogInformation( + "{@DateUtc} {@TimeUtc} {@TraceId} {@SpanId} Handled {@RequestName} by user with Email: {@UserEmail} and UserId: {@UserId}.", + DateTime.UtcNow.ToString("yyyy-MM-dd"), + DateTime.UtcNow.ToString("HH:mm:ss.FFF"), + Activity.Current?.TraceId.ToString(), + Activity.Current?.SpanId.ToString(), + typeof(TRequest).Name, + _sessionUserService.Email, + _sessionUserService.Id); + + return response; + } +} diff --git a/ExpenseTracker.Application/Common/Behaviours/ValidationBehaviour.cs b/ExpenseTracker.Application/Common/Behaviours/ValidationBehaviour.cs new file mode 100644 index 0000000..5495ea7 --- /dev/null +++ b/ExpenseTracker.Application/Common/Behaviours/ValidationBehaviour.cs @@ -0,0 +1,37 @@ +using FluentValidation; +using MediatR; +using ValidationException = ExpenseTracker.Application.Common.Exceptions.ValidationException; + +namespace ExpenseTracker.Application.Common.Behaviours; + +public class ValidationBehaviour : IPipelineBehavior + where TRequest : notnull +{ + private readonly IEnumerable> _validators; + + public ValidationBehaviour(IEnumerable> validators) + { + _validators = validators; + } + + public async Task Handle(TRequest request, RequestHandlerDelegate next, CancellationToken cancellationToken) + { + if (_validators.Any()) + { + var context = new ValidationContext(request); + + var failures = _validators + .Select(v => v.Validate(context)) + .SelectMany(r => r.Errors) + .Where(f => f != null) + .ToList(); + + if (failures.Any()) + { + throw new ValidationException(failures); + } + } + + return await next(); + } +} diff --git a/ExpenseTracker.Application/Common/Exceptions/CurrencyConverterException.cs b/ExpenseTracker.Application/Common/Exceptions/CurrencyConverterException.cs new file mode 100644 index 0000000..036c038 --- /dev/null +++ b/ExpenseTracker.Application/Common/Exceptions/CurrencyConverterException.cs @@ -0,0 +1,11 @@ +namespace ExpenseTracker.Application.Common.Exceptions; + +public class CurrencyConverterException : Exception +{ + public CurrencyConverterException() + : base() { } + + public CurrencyConverterException(string message) + : base(message) { } +} + diff --git a/ExpenseTracker.Application/Common/Exceptions/ForbiddenException.cs b/ExpenseTracker.Application/Common/Exceptions/ForbiddenException.cs new file mode 100644 index 0000000..ecb165f --- /dev/null +++ b/ExpenseTracker.Application/Common/Exceptions/ForbiddenException.cs @@ -0,0 +1,11 @@ +namespace ExpenseTracker.Application.Common.Exceptions; + +public class ForbiddenException : Exception +{ + public ForbiddenException() + : base() { } + + public ForbiddenException(string message) + : base(message) { } +} + diff --git a/ExpenseTracker.Application/Common/Exceptions/LoginException.cs b/ExpenseTracker.Application/Common/Exceptions/LoginException.cs new file mode 100644 index 0000000..426bad0 --- /dev/null +++ b/ExpenseTracker.Application/Common/Exceptions/LoginException.cs @@ -0,0 +1,10 @@ +namespace ExpenseTracker.Application.Common.Exceptions; + +public class LoginException : Exception +{ + public LoginException() + : base() { } + + public LoginException(string message) + : base(message) { } +} diff --git a/ExpenseTracker.Application/Common/Exceptions/NotFoundException.cs b/ExpenseTracker.Application/Common/Exceptions/NotFoundException.cs new file mode 100644 index 0000000..583b91c --- /dev/null +++ b/ExpenseTracker.Application/Common/Exceptions/NotFoundException.cs @@ -0,0 +1,10 @@ +namespace ExpenseTracker.Application.Common.Exceptions; + +public class NotFoundException : Exception +{ + public NotFoundException() + : base() { } + + public NotFoundException(string message) + : base(message) { } +} diff --git a/ExpenseTracker.Application/Common/Exceptions/RegistrationException.cs b/ExpenseTracker.Application/Common/Exceptions/RegistrationException.cs new file mode 100644 index 0000000..e35172b --- /dev/null +++ b/ExpenseTracker.Application/Common/Exceptions/RegistrationException.cs @@ -0,0 +1,11 @@ +namespace ExpenseTracker.Application.Common.Exceptions; + +public class RegistrationException : Exception +{ + public RegistrationException() + : base() { } + + public RegistrationException(string message) + : base(message) { } +} + diff --git a/ExpenseTracker.Application/Common/Exceptions/RenewAccessTokenException.cs b/ExpenseTracker.Application/Common/Exceptions/RenewAccessTokenException.cs new file mode 100644 index 0000000..71b3123 --- /dev/null +++ b/ExpenseTracker.Application/Common/Exceptions/RenewAccessTokenException.cs @@ -0,0 +1,11 @@ +namespace ExpenseTracker.Application.Common.Exceptions; + +public class RenewAccessTokenException : Exception +{ + public RenewAccessTokenException() + : base() { } + + public RenewAccessTokenException(string message) + : base(message) { } +} + diff --git a/ExpenseTracker.Application/Common/Exceptions/RevokeRefreshTokenException.cs b/ExpenseTracker.Application/Common/Exceptions/RevokeRefreshTokenException.cs new file mode 100644 index 0000000..07f0e08 --- /dev/null +++ b/ExpenseTracker.Application/Common/Exceptions/RevokeRefreshTokenException.cs @@ -0,0 +1,10 @@ +namespace ExpenseTracker.Application.Common.Exceptions; + +public class RevokeRefreshTokenException : Exception +{ + public RevokeRefreshTokenException() + : base() { } + + public RevokeRefreshTokenException(string message) + : base(message) { } +} diff --git a/ExpenseTracker.Application/Common/Exceptions/UnAuthorizedException.cs b/ExpenseTracker.Application/Common/Exceptions/UnAuthorizedException.cs new file mode 100644 index 0000000..959880e --- /dev/null +++ b/ExpenseTracker.Application/Common/Exceptions/UnAuthorizedException.cs @@ -0,0 +1,10 @@ +namespace ExpenseTracker.Application.Common.Exceptions; + +public class UnAuthorizedException : Exception +{ + public UnAuthorizedException() + : base() { } + + public UnAuthorizedException(string message) + : base(message) { } +} diff --git a/ExpenseTracker.Application/Common/Exceptions/ValidationException.cs b/ExpenseTracker.Application/Common/Exceptions/ValidationException.cs new file mode 100644 index 0000000..881757e --- /dev/null +++ b/ExpenseTracker.Application/Common/Exceptions/ValidationException.cs @@ -0,0 +1,22 @@ +using FluentValidation.Results; + +namespace ExpenseTracker.Application.Common.Exceptions; + +public class ValidationException : Exception +{ + public ValidationException() + : base("One or more validation failures have occurred.") + { + Errors = new Dictionary(); + } + + public ValidationException(IEnumerable failures) + : this() + { + Errors = failures + .GroupBy(f => f.PropertyName, f => f.ErrorMessage) + .ToDictionary(fg => fg.Key, fg => fg.ToArray()); + } + + public IDictionary Errors { get; } +} diff --git a/ExpenseTracker.Application/Common/Extensions/QueryableExtensions.cs b/ExpenseTracker.Application/Common/Extensions/QueryableExtensions.cs new file mode 100644 index 0000000..12bd6ed --- /dev/null +++ b/ExpenseTracker.Application/Common/Extensions/QueryableExtensions.cs @@ -0,0 +1,135 @@ +using ExpenseTracker.Application.Common.Models; +using AutoMapper; + +namespace ExpenseTracker.Application.Common.Extensions; + +public static class QueryableExtensions +{ + public static PaginatedList ToPaginatedList(this IQueryable queryable, int pageNumber, int pageSize) + where T : class + { + return PaginatedList.Create(queryable, pageNumber, pageSize); + } + + public static PaginatedList ProjectToPaginatedList( + + this IQueryable queryable, + int pageNumber, + int pageSize, + IConfigurationProvider mappingConfigurationProvider) + + where TSource : class + where TDestination : class + { + return PaginatedList + .Create(queryable, pageNumber, pageSize, mappingConfigurationProvider); + } + + // public static IQueryable ApplySort(this IQueryable entities, string? orderByQueryString) + // { + // if (!entities.Any() || String.IsNullOrWhiteSpace(orderByQueryString)) + // { + // return entities; + // } + // + // var orderParams = orderByQueryString.Trim().Split(","); + // var propertyInfos = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance); + // var orderQueryBuilder = new StringBuilder(); + // + // foreach (var param in orderParams) + // { + // if (string.IsNullOrWhiteSpace(param)) + // { + // continue; + // } + // + // var propertyFromQueryName = param[0] == '-' || param[0] == '+' ? param.Substring(1) : param; + // var objectProperty = propertyInfos.FirstOrDefault(pi => + // pi.Name.Equals(propertyFromQueryName, StringComparison.InvariantCultureIgnoreCase)); + // + // if (objectProperty == null) + // { + // continue; + // } + // + // var sortingOrder = param[0] == '-' ? "descending" : "ascending"; + // + // orderQueryBuilder.Append($"{objectProperty.Name} {sortingOrder}, "); + // } + // + // var orderQuery = orderQueryBuilder.ToString().TrimEnd(',', ' '); + // + // return entities.OrderBy(orderQuery); + // } + + // public static IQueryable ShapeData(this IQueryable entities, string? fieldsString) + // { + // var allProperties = GetAllProperties(); + // var requiredProperties = GetRequiredProperties(fieldsString, allProperties); + // return FetchData(entities, requiredProperties); + // } + // + // public static ExpandoObject ShapeData(this T entity, string? fieldsString) + // { + // var allProperties = GetAllProperties(); + // var requiredProperties = GetRequiredProperties(fieldsString, allProperties); + // return FetchDataForEntity(entity, requiredProperties); + // } + // + // private static IEnumerable GetAllProperties() + // { + // return typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance); + // } + // + // private static IEnumerable GetRequiredProperties(string? fieldsString, IEnumerable properties) + // { + // var requiredProperties = new List(); + // + // if (!string.IsNullOrWhiteSpace(fieldsString)) + // { + // var fields = fieldsString.Split(',', StringSplitOptions.RemoveEmptyEntries); + // + // foreach (var field in fields) + // { + // var property = properties.FirstOrDefault(pi => pi.Name.Equals(field.Trim(), StringComparison.InvariantCultureIgnoreCase)); + // + // if (property == null) + // continue; + // + // requiredProperties.Add(property); + // } + // } + // else + // { + // requiredProperties = properties.ToList(); + // } + // + // return requiredProperties; + // } + // + // private static IQueryable FetchData(IQueryable entities, IEnumerable requiredProperties) + // { + // var shapedData = new List(); + // + // foreach (var entity in entities) + // { + // var shapedObject = FetchDataForEntity(entity, requiredProperties); + // shapedData.Add(shapedObject); + // } + // + // return shapedData.AsQueryable(); + // } + // + // private static ExpandoObject FetchDataForEntity(T entity, IEnumerable requiredProperties) + // { + // var shapedObject = new ExpandoObject(); + // + // foreach (var property in requiredProperties) + // { + // var objectPropertyValue = property.GetValue(entity); + // shapedObject.TryAdd(property.Name, objectPropertyValue); + // } + // + // return shapedObject; + // } +} diff --git a/ExpenseTracker.Application/Common/Extensions/StringExtensions.cs b/ExpenseTracker.Application/Common/Extensions/StringExtensions.cs new file mode 100644 index 0000000..9a925f6 --- /dev/null +++ b/ExpenseTracker.Application/Common/Extensions/StringExtensions.cs @@ -0,0 +1,14 @@ +namespace ExpenseTracker.Application.Common.Extensions; + +public static class StringExtensions +{ + public static string FirstCharacterToLower(this string input) + { + return string.Concat(input[0].ToString().ToLower(), input.AsSpan(1)); + } + + public static string FirstCharacterToUpper(this string input) + { + return string.Concat(input[0].ToString().ToUpper(), input.AsSpan(1)); + } +} diff --git a/ExpenseTracker.Application/Common/Interfaces/IUnitOfWork.cs b/ExpenseTracker.Application/Common/Interfaces/IUnitOfWork.cs new file mode 100644 index 0000000..829728a --- /dev/null +++ b/ExpenseTracker.Application/Common/Interfaces/IUnitOfWork.cs @@ -0,0 +1,12 @@ +using ExpenseTracker.Application.Common.Interfaces.Repositories; + +namespace ExpenseTracker.Application.Common.Interfaces; + +public interface IUnitOfWork : IDisposable +{ + IAccountRepository AccountRepository { get; } + ITransactionRepository TransactionRepository { get; } + + int Save(); + Task SaveAsync(CancellationToken cancellationToken); +} diff --git a/ExpenseTracker.Application/Common/Interfaces/Repositories/IAccountRepository.cs b/ExpenseTracker.Application/Common/Interfaces/Repositories/IAccountRepository.cs new file mode 100644 index 0000000..db4990f --- /dev/null +++ b/ExpenseTracker.Application/Common/Interfaces/Repositories/IAccountRepository.cs @@ -0,0 +1,5 @@ +using ExpenseTracker.Domain.Entities; + +namespace ExpenseTracker.Application.Common.Interfaces.Repositories; + +public interface IAccountRepository : IBaseRepository { } diff --git a/ExpenseTracker.Application/Common/Interfaces/Repositories/IBaseRepository.cs b/ExpenseTracker.Application/Common/Interfaces/Repositories/IBaseRepository.cs new file mode 100644 index 0000000..f17a459 --- /dev/null +++ b/ExpenseTracker.Application/Common/Interfaces/Repositories/IBaseRepository.cs @@ -0,0 +1,21 @@ +using System.Linq.Expressions; +using ExpenseTracker.Domain.Entities; + +namespace ExpenseTracker.Application.Common.Interfaces.Repositories; + +public interface IBaseRepository + where TKey : IEquatable + where TEntity : EntityBase +{ + public IQueryable Queryable { get; } + + Task AddOneAsync(TEntity entity, CancellationToken cancellationToken); + + Task> AddManyAsync(IEnumerable entities, CancellationToken cancellationToken); + + Task UpdateOneAsync(TEntity entity, CancellationToken cancellationToken); + + Task DeleteOneAsync(TKey id, CancellationToken cancellationToken); + + Task DeleteManyAsync(Expression> predicate, CancellationToken cancellationToken); +} diff --git a/ExpenseTracker.Application/Common/Interfaces/Repositories/ITransactionRepository.cs b/ExpenseTracker.Application/Common/Interfaces/Repositories/ITransactionRepository.cs new file mode 100644 index 0000000..e58cf0d --- /dev/null +++ b/ExpenseTracker.Application/Common/Interfaces/Repositories/ITransactionRepository.cs @@ -0,0 +1,5 @@ +using ExpenseTracker.Domain.Entities; + +namespace ExpenseTracker.Application.Common.Interfaces.Repositories; + +public interface ITransactionRepository : IBaseRepository { } diff --git a/ExpenseTracker.Application/Common/Interfaces/Services/IAuthenticationService.cs b/ExpenseTracker.Application/Common/Interfaces/Services/IAuthenticationService.cs new file mode 100644 index 0000000..23d951a --- /dev/null +++ b/ExpenseTracker.Application/Common/Interfaces/Services/IAuthenticationService.cs @@ -0,0 +1,16 @@ +using ExpenseTracker.Application.Authentication; + +namespace ExpenseTracker.Application.Common.Interfaces.Services; + +public interface IAuthenticationService +{ + Task RegisterWithEmailAndPasswordAsync(string email, string password, CancellationToken cancellationToken); + + Task RegisterWithEmailAsync(string email, CancellationToken cancellationToken); + + Task LoginAsync(string email, string password, CancellationToken cancellationToken); + + Task RenewAccessTokenAsync(string refreshToken, CancellationToken cancellationToken); + + Task RevokeRefreshTokenAsync(string refreshToken, CancellationToken cancellationToken); +} diff --git a/ExpenseTracker.Application/Common/Interfaces/Services/ICurrencyConverterService.cs b/ExpenseTracker.Application/Common/Interfaces/Services/ICurrencyConverterService.cs new file mode 100644 index 0000000..71d8e2e --- /dev/null +++ b/ExpenseTracker.Application/Common/Interfaces/Services/ICurrencyConverterService.cs @@ -0,0 +1,10 @@ +using ExpenseTracker.Domain.Enums; + +namespace ExpenseTracker.Application.Common.Interfaces.Services; + +public interface ICurrencyConverterService +{ + Task GetLatestExchangeRate(Currency fromCurrency, Currency toCurrency, CancellationToken cancellationToken); + + Task GetHistoricalExchangeRate(Currency fromCurrency, Currency toCurrency, DateOnly date, CancellationToken cancellationToken); +} diff --git a/ExpenseTracker.Application/Common/Interfaces/Services/IEmailSenderService.cs b/ExpenseTracker.Application/Common/Interfaces/Services/IEmailSenderService.cs new file mode 100644 index 0000000..67d8741 --- /dev/null +++ b/ExpenseTracker.Application/Common/Interfaces/Services/IEmailSenderService.cs @@ -0,0 +1,6 @@ +namespace ExpenseTracker.Application.Common.Interfaces.Services; + +public interface IEmailSenderService +{ + Task SendAsync(ICollection recipientAddresses, string subject, string message, CancellationToken cancellationToken); +} diff --git a/ExpenseTracker.Application/Common/Interfaces/Services/IInternationalizationService.cs b/ExpenseTracker.Application/Common/Interfaces/Services/IInternationalizationService.cs new file mode 100644 index 0000000..5e7db3b --- /dev/null +++ b/ExpenseTracker.Application/Common/Interfaces/Services/IInternationalizationService.cs @@ -0,0 +1,8 @@ +using ExpenseTracker.Domain.Enums; + +namespace ExpenseTracker.Application.Common.Interfaces.Services; + +public interface IInternationalizationService +{ + Currency Currency { get; init; } +} diff --git a/ExpenseTracker.Application/Common/Interfaces/Services/ISessionUserService.cs b/ExpenseTracker.Application/Common/Interfaces/Services/ISessionUserService.cs new file mode 100644 index 0000000..d27fffb --- /dev/null +++ b/ExpenseTracker.Application/Common/Interfaces/Services/ISessionUserService.cs @@ -0,0 +1,14 @@ +namespace ExpenseTracker.Application.Common.Interfaces.Services; + +public interface ISessionUserService +{ + public string? Id { get; } + public string? Email { get; } + public ICollection Roles { get; } + + public bool IsAdministrator { get; } + public bool IsAuthenticated { get; } + + public string? AccessToken { get; } + public string? RefreshToken { get; } +} diff --git a/ExpenseTracker.Application/Common/Mappings/IMapFrom.cs b/ExpenseTracker.Application/Common/Mappings/IMapFrom.cs new file mode 100644 index 0000000..97a0454 --- /dev/null +++ b/ExpenseTracker.Application/Common/Mappings/IMapFrom.cs @@ -0,0 +1,12 @@ +using AutoMapper; + +namespace ExpenseTracker.Application.Common.Mappings; + +public interface IMapFrom +{ + void Mapping(Profile profile) + { + profile.CreateMap(typeof(T), GetType()); + profile.CreateMap(GetType(), typeof(T)); + } +} diff --git a/ExpenseTracker.Application/Common/Mappings/MappingProfile.cs b/ExpenseTracker.Application/Common/Mappings/MappingProfile.cs new file mode 100644 index 0000000..624b2dc --- /dev/null +++ b/ExpenseTracker.Application/Common/Mappings/MappingProfile.cs @@ -0,0 +1,35 @@ +using System.Reflection; +using AutoMapper; + +namespace ExpenseTracker.Application.Common.Mappings; + +public class MappingProfile : Profile +{ + public MappingProfile() + { + ApplyMappingsFromAssembly(Assembly.GetExecutingAssembly()); + } + + private void ApplyMappingsFromAssembly(Assembly assembly) + { + var types = assembly.GetExportedTypes() + .Where(t => t.GetInterfaces() + .Any(i => + i.IsGenericType && + i.GetGenericTypeDefinition() == typeof(IMapFrom<>) + ) + ) + .ToList(); + + foreach (var type in types) + { + var instance = Activator.CreateInstance(type); + + var methodInfo = + type.GetMethod("Mapping") ?? + type.GetInterface("IMapFrom`1")?.GetMethod("Mapping"); + + methodInfo?.Invoke(instance, new object[] { this }); + } + } +} diff --git a/ExpenseTracker.Application/Common/Models/IdentityRoles.cs b/ExpenseTracker.Application/Common/Models/IdentityRoles.cs new file mode 100644 index 0000000..33e2cfc --- /dev/null +++ b/ExpenseTracker.Application/Common/Models/IdentityRoles.cs @@ -0,0 +1,7 @@ +namespace ExpenseTracker.Application.Common.Models; + +public enum IdentityRoles +{ + User = 0, + Administrator = 1 +} diff --git a/ExpenseTracker.Application/Common/Models/PaginatedList.cs b/ExpenseTracker.Application/Common/Models/PaginatedList.cs new file mode 100644 index 0000000..12844fa --- /dev/null +++ b/ExpenseTracker.Application/Common/Models/PaginatedList.cs @@ -0,0 +1,47 @@ +using AutoMapper; +using AutoMapper.QueryableExtensions; + +namespace ExpenseTracker.Application.Common.Models; + +public class PaginatedList +{ + public IReadOnlyCollection Items { get; } + public int PageNumber { get; } + public int TotalPages { get; } + public int TotalCount { get; } + + public PaginatedList(IReadOnlyCollection items, int count, int pageNumber, int pageSize) + { + PageNumber = pageNumber; + TotalPages = (int) Math.Ceiling(count / (double) pageSize); + TotalCount = count; + Items = items; + } + + public bool HasPreviousPage => PageNumber > 1; + + public bool HasNextPage => PageNumber < TotalPages; + + public static PaginatedList Create(IQueryable source, int pageNumber, int pageSize) + { + var count = source.Count(); + var items = source.Skip((pageNumber - 1) * pageSize).Take(pageSize).ToList(); + + return new PaginatedList(items, count, pageNumber, pageSize); + } + + public static PaginatedList Create( + IQueryable source, + int pageNumber, + int pageSize, + IConfigurationProvider mappingConfigurationProvider) + { + var count = source.Count(); + var items = source.Skip((pageNumber - 1) * pageSize).Take(pageSize).ToList(); + + var mappedItems = items.AsQueryable() + .ProjectTo(mappingConfigurationProvider).ToList(); + + return new PaginatedList(mappedItems, count, pageNumber, pageSize); + } +} diff --git a/ExpenseTracker.Application/DependencyInjection.cs b/ExpenseTracker.Application/DependencyInjection.cs new file mode 100644 index 0000000..635d72a --- /dev/null +++ b/ExpenseTracker.Application/DependencyInjection.cs @@ -0,0 +1,54 @@ +using System.Reflection; +using FluentValidation; +using MediatR; +using MediatR.Behaviors.Authorization.Extensions.DependencyInjection; +using Microsoft.Extensions.DependencyInjection; +using ExpenseTracker.Application.Common.Authorization; +using ExpenseTracker.Application.Common.Behaviours; + +namespace ExpenseTracker.Application; + +public static class DependencyInjection +{ + public static IServiceCollection AddApplication(this IServiceCollection services) + { + services + .AddFluentValidation() + .AddAutoMapper() + .AddMediatR(); + + return services; + } + + private static IServiceCollection AddFluentValidation(this IServiceCollection services) + { + services.AddValidatorsFromAssembly(Assembly.GetExecutingAssembly()); + return services; + } + + private static IServiceCollection AddAutoMapper(this IServiceCollection services) + { + services.AddAutoMapper(Assembly.GetExecutingAssembly()); + return services; + } + + private static IServiceCollection AddMediatR(this IServiceCollection services) + { + // Adds the transient pipeline behavior and additionally registers all `IAuthorizationHandlers` for a given assembly + services.AddMediatorAuthorization( + Assembly.GetExecutingAssembly(), + options => options.UseUnauthorizedResultHandlerStrategy(new CustomUnauthorizedResultHandler()) + ); + // Register all `IAuthorizer` implementations for a given assembly + services.AddAuthorizersFromAssembly(Assembly.GetExecutingAssembly()); + + services.AddMediatR(configuration => + { + configuration.RegisterServicesFromAssembly(Assembly.GetExecutingAssembly()); + configuration.AddBehavior(typeof(IPipelineBehavior<,>), typeof(LoggingBehaviour<,>)); + configuration.AddBehavior(typeof(IPipelineBehavior<,>), typeof(ValidationBehaviour<,>)); + }); + + return services; + } +} diff --git a/ExpenseTracker.Application/ExpenseTracker.Application.csproj b/ExpenseTracker.Application/ExpenseTracker.Application.csproj new file mode 100644 index 0000000..7e2db60 --- /dev/null +++ b/ExpenseTracker.Application/ExpenseTracker.Application.csproj @@ -0,0 +1,28 @@ + + + + net8.0 + enable + enable + + + + + + + + + + + + + + + + + + + + + + diff --git a/ExpenseTracker.Application/Transactions/Commands/Create/CreateTransactionCommand.cs b/ExpenseTracker.Application/Transactions/Commands/Create/CreateTransactionCommand.cs new file mode 100644 index 0000000..82bc9e6 --- /dev/null +++ b/ExpenseTracker.Application/Transactions/Commands/Create/CreateTransactionCommand.cs @@ -0,0 +1,16 @@ +using MediatR; + +namespace ExpenseTracker.Application.Transactions.Commands.Create; + +public record CreateTransactionCommand : IRequest +{ + public double Amount { get; set; } + + public string Category { get; set; } + + public DateTimeOffset Time { get; set; } + + public string? Description { get; set; } + + public string? AccountId { get; set; } +} diff --git a/ExpenseTracker.Application/Transactions/Commands/Create/CreateTransactionCommandAuthorizer.cs b/ExpenseTracker.Application/Transactions/Commands/Create/CreateTransactionCommandAuthorizer.cs new file mode 100644 index 0000000..5efb4fc --- /dev/null +++ b/ExpenseTracker.Application/Transactions/Commands/Create/CreateTransactionCommandAuthorizer.cs @@ -0,0 +1,38 @@ +using MediatR.Behaviors.Authorization; +using ExpenseTracker.Application.Common.Authorization; +using ExpenseTracker.Application.Common.Exceptions; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Application.Common.Models; + +namespace ExpenseTracker.Application.Transactions.Commands.Create; + +public class CreateTransactionCommandAuthorizer : AbstractRequestAuthorizer +{ + private readonly ISessionUserService _sessionUserService; + private readonly IAccountRepository _repository; + + public CreateTransactionCommandAuthorizer(ISessionUserService currentUserService, IAccountRepository repository) + { + _sessionUserService = currentUserService; + _repository = repository; + } + + public override void BuildPolicy(CreateTransactionCommand request) + { + UseRequirement(new MustBeAuthenticatedRequirement + { + IsAuthenticated = _sessionUserService.IsAuthenticated + }); + + var requiredUserId = _repository.Queryable.FirstOrDefault(e => e.Id == request.AccountId)?.UserId; + + UseRequirement(new MustBeInRolesWhenInteractingWithUnOwnedEntityRequirement + { + UserId = _sessionUserService.Id, + UserRoles = _sessionUserService.Roles, + RequiredUserId = requiredUserId, + RequiredRoles = new[] { IdentityRoles.Administrator.ToString() } + }); + } +} diff --git a/ExpenseTracker.Application/Transactions/Commands/Create/CreateTransactionCommandHandler.cs b/ExpenseTracker.Application/Transactions/Commands/Create/CreateTransactionCommandHandler.cs new file mode 100644 index 0000000..9073a68 --- /dev/null +++ b/ExpenseTracker.Application/Transactions/Commands/Create/CreateTransactionCommandHandler.cs @@ -0,0 +1,44 @@ +using AutoMapper; +using MediatR; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Domain.Entities; +using ExpenseTracker.Domain.Enums; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Application.Common.Interfaces; + +namespace ExpenseTracker.Application.Transactions.Commands.Create; + +public class CreateTransactionCommandHandler : IRequestHandler +{ + private readonly IMapper _mapper; + private readonly IUnitOfWork _unitOfWork; + private readonly ISessionUserService _sessionUserService; + + public CreateTransactionCommandHandler(IMapper mapper, IUnitOfWork unitOfWork, ISessionUserService sessionUserService) + { + _mapper = mapper; + _unitOfWork = unitOfWork; + _sessionUserService = sessionUserService; + } + + public async Task Handle(CreateTransactionCommand request, CancellationToken cancellationToken) + { + // TODO: Add UserId validation. Throw NotFoundException when there is no user with given UserId + + var newEntity = new Transaction() + { + Id = Guid.NewGuid().ToString(), + Amount = request.Amount, + Category = Category.FromName(request.Category), + Time = request.Time, + AccountId = request.AccountId, + Description = request.Description, + }; + + var databaseEntity = await _unitOfWork.TransactionRepository.AddOneAsync(newEntity, cancellationToken); + + await _unitOfWork.SaveAsync(cancellationToken); + + return _mapper.Map(databaseEntity); + } +} diff --git a/ExpenseTracker.Application/Transactions/Commands/Create/CreateTransactionCommandValidator.cs b/ExpenseTracker.Application/Transactions/Commands/Create/CreateTransactionCommandValidator.cs new file mode 100644 index 0000000..b9a5283 --- /dev/null +++ b/ExpenseTracker.Application/Transactions/Commands/Create/CreateTransactionCommandValidator.cs @@ -0,0 +1,23 @@ +using FluentValidation; +using ExpenseTracker.Domain.Enums; + +namespace ExpenseTracker.Application.Transactions.Commands.Create; + +public class CreateTransactionCommandValidator : AbstractValidator +{ + public CreateTransactionCommandValidator() + { + RuleFor(e => e.Amount) + .NotEmpty(); + + RuleFor(e => e.Category) + .Must(c => Category.FromName(c) is not null) + .WithMessage(c => $"'{nameof(c.Category)}' must be one of the following: '{String.Join("', ", Category.Enumerations.Values.Select(v => v.Name))}'."); + + RuleFor(e => e.Time) + .NotEmpty(); + + RuleFor(e => e.Description) + .Length(0, 256); + } +} diff --git a/ExpenseTracker.Application/Transactions/Commands/Delete/DeleteTransactionCommand.cs b/ExpenseTracker.Application/Transactions/Commands/Delete/DeleteTransactionCommand.cs new file mode 100644 index 0000000..a6514f6 --- /dev/null +++ b/ExpenseTracker.Application/Transactions/Commands/Delete/DeleteTransactionCommand.cs @@ -0,0 +1,8 @@ +using MediatR; + +namespace ExpenseTracker.Application.Transactions.Commands.Delete; + +public record DeleteTransactionCommand : IRequest +{ + public string Id { get; set; } = null!; +} diff --git a/ExpenseTracker.Application/Transactions/Commands/Delete/DeleteTransactionCommandAuthorizer.cs b/ExpenseTracker.Application/Transactions/Commands/Delete/DeleteTransactionCommandAuthorizer.cs new file mode 100644 index 0000000..53c2d3a --- /dev/null +++ b/ExpenseTracker.Application/Transactions/Commands/Delete/DeleteTransactionCommandAuthorizer.cs @@ -0,0 +1,44 @@ +using MediatR.Behaviors.Authorization; +using ExpenseTracker.Application.Common.Authorization; +using ExpenseTracker.Application.Common.Exceptions; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Application.Common.Models; + +namespace ExpenseTracker.Application.Transactions.Commands.Delete; + +public class DeleteTransactionCommandAuthorizer : AbstractRequestAuthorizer +{ + private readonly ISessionUserService _sessionUserService; + private readonly IAccountRepository _accountRepository; + private readonly ITransactionRepository _transactionRepository; + + public DeleteTransactionCommandAuthorizer( + ISessionUserService currentUserService, + IAccountRepository accountRepository, + ITransactionRepository transactionRepository) + { + _sessionUserService = currentUserService; + _accountRepository = accountRepository; + _transactionRepository = transactionRepository; + } + + public override void BuildPolicy(DeleteTransactionCommand request) + { + UseRequirement(new MustBeAuthenticatedRequirement + { + IsAuthenticated = _sessionUserService.IsAuthenticated + }); + + var accountId = _transactionRepository.Queryable.FirstOrDefault(e => e.Id == request.Id)?.AccountId; + var requiredUserId = _accountRepository.Queryable.FirstOrDefault(e => e.Id == accountId)?.UserId; + + UseRequirement(new MustBeInRolesWhenInteractingWithUnOwnedEntityRequirement + { + UserId = _sessionUserService.Id, + UserRoles = _sessionUserService.Roles, + RequiredUserId = requiredUserId, + RequiredRoles = new[] { IdentityRoles.Administrator.ToString() } + }); + } +} diff --git a/ExpenseTracker.Application/Transactions/Commands/Delete/DeleteTransactionCommandHandler.cs b/ExpenseTracker.Application/Transactions/Commands/Delete/DeleteTransactionCommandHandler.cs new file mode 100644 index 0000000..c68d6ba --- /dev/null +++ b/ExpenseTracker.Application/Transactions/Commands/Delete/DeleteTransactionCommandHandler.cs @@ -0,0 +1,33 @@ +using AutoMapper; +using MediatR; +using ExpenseTracker.Application.Common.Exceptions; +using ExpenseTracker.Application.Common.Interfaces; +using ExpenseTracker.Application.Transactions.Commands.Delete; + +namespace ExpenseTracker.Application.Transactiones.Commands.Delete; + +public class DeleteTransactionCommandHandler : IRequestHandler +{ + private readonly IMapper _mapper; + private readonly IUnitOfWork _unitOfWork; + + public DeleteTransactionCommandHandler(IMapper mapper, IUnitOfWork unitOfWork) + { + _mapper = mapper; + _unitOfWork = unitOfWork; + } + + public async Task Handle(DeleteTransactionCommand request, CancellationToken cancellationToken) + { + var isEntityPresentInDatabase = _unitOfWork.TransactionRepository.Queryable.Any(e => e.Id == request.Id); + + if (!isEntityPresentInDatabase) + { + throw new NotFoundException(); + } + + await _unitOfWork.TransactionRepository.DeleteOneAsync(request.Id, cancellationToken); + + await _unitOfWork.SaveAsync(cancellationToken); + } +} diff --git a/ExpenseTracker.Application/Transactions/Commands/Delete/DeleteTransactionCommandValidator.cs b/ExpenseTracker.Application/Transactions/Commands/Delete/DeleteTransactionCommandValidator.cs new file mode 100644 index 0000000..fa0bc81 --- /dev/null +++ b/ExpenseTracker.Application/Transactions/Commands/Delete/DeleteTransactionCommandValidator.cs @@ -0,0 +1,12 @@ +using FluentValidation; + +namespace ExpenseTracker.Application.Transactions.Commands.Delete; + +public class DeleteTransactionCommandValidator : AbstractValidator +{ + public DeleteTransactionCommandValidator() + { + RuleFor(e => e.Id) + .NotEmpty(); + } +} diff --git a/ExpenseTracker.Application/Transactions/Commands/Update/UpdateTransactionCommand.cs b/ExpenseTracker.Application/Transactions/Commands/Update/UpdateTransactionCommand.cs new file mode 100644 index 0000000..57bb239 --- /dev/null +++ b/ExpenseTracker.Application/Transactions/Commands/Update/UpdateTransactionCommand.cs @@ -0,0 +1,18 @@ +using MediatR; + +namespace ExpenseTracker.Application.Transactions.Commands.Update; + +public record UpdateTransactionCommand : IRequest +{ + public string Id { get; set; } + + public double? Amount { get; set; } + + public string? Category { get; set; } + + public DateTimeOffset? Time { get; set; } + + public string? Description { get; set; } + + public string AccountId { get; set; } +} diff --git a/ExpenseTracker.Application/Transactions/Commands/Update/UpdateTransactionCommandAuthorized.cs b/ExpenseTracker.Application/Transactions/Commands/Update/UpdateTransactionCommandAuthorized.cs new file mode 100644 index 0000000..abe7a00 --- /dev/null +++ b/ExpenseTracker.Application/Transactions/Commands/Update/UpdateTransactionCommandAuthorized.cs @@ -0,0 +1,57 @@ +using MediatR.Behaviors.Authorization; +using ExpenseTracker.Application.Common.Authorization; +using ExpenseTracker.Application.Common.Exceptions; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Application.Common.Models; +using ExpenseTracker.Domain.Entities; +using ExpenseTracker.Domain.Enums; + +namespace ExpenseTracker.Application.Transactions.Commands.Update; + +public class UpdateTransactionCommandAuthorizer : AbstractRequestAuthorizer +{ + private readonly ISessionUserService _sessionUserService; + private readonly ITransactionRepository _transactionRepository; + private readonly IAccountRepository _accountRepository; + + public UpdateTransactionCommandAuthorizer( + ISessionUserService currentUserService, + ITransactionRepository repository, + IAccountRepository accountRepository) + { + _sessionUserService = currentUserService; + _transactionRepository = repository; + _accountRepository = accountRepository; + } + + public override void BuildPolicy(UpdateTransactionCommand request) + { + UseRequirement(new MustBeAuthenticatedRequirement + { + IsAuthenticated = _sessionUserService.IsAuthenticated + }); + + var requiredUserId = _transactionRepository.Queryable + .Join( + _accountRepository.Queryable, + t => t.AccountId, + b => b.Id, + (transaction, account) => + new Transaction + { + Id = transaction.Id, + Account = account, + } + ) + .FirstOrDefault(e => e.Id == request.Id)?.Account.UserId; + + UseRequirement(new MustBeInRolesWhenInteractingWithUnOwnedEntityRequirement + { + UserId = _sessionUserService.Id, + UserRoles = _sessionUserService.Roles, + RequiredUserId = requiredUserId, + RequiredRoles = new[] { IdentityRoles.Administrator.ToString() } + }); + } +} diff --git a/ExpenseTracker.Application/Transactions/Commands/Update/UpdateTransactionCommandHandler.cs b/ExpenseTracker.Application/Transactions/Commands/Update/UpdateTransactionCommandHandler.cs new file mode 100644 index 0000000..c8e3a77 --- /dev/null +++ b/ExpenseTracker.Application/Transactions/Commands/Update/UpdateTransactionCommandHandler.cs @@ -0,0 +1,47 @@ +using AutoMapper; +using MediatR; +using ExpenseTracker.Application.Common.Exceptions; +using ExpenseTracker.Application.Common.Interfaces; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Domain.Entities; +using ExpenseTracker.Domain.Enums; + +namespace ExpenseTracker.Application.Transactions.Commands.Update; + +public class UpdateTransactionCommandHandler : IRequestHandler +{ + private readonly IMapper _mapper; + private readonly IUnitOfWork _unitOfWork; + + public UpdateTransactionCommandHandler(IMapper mapper, IUnitOfWork unitOfWork) + { + _mapper = mapper; + _unitOfWork = unitOfWork; + } + + public async Task Handle(UpdateTransactionCommand request, CancellationToken cancellationToken) + { + var databaseEntity = _unitOfWork.TransactionRepository.Queryable.FirstOrDefault(e => e.Id == request.Id); + + if (databaseEntity == null) + { + throw new NotFoundException(); + } + + var updatedEntity = new Transaction() + { + Id = request.Id, + Amount = request.Amount ?? databaseEntity.Amount, + Category = Category.FromName(request.Category) ?? databaseEntity.Category, + Time = request.Time ?? databaseEntity.Time, + Description = request.Description, + AccountId = request.AccountId + }; + + databaseEntity = await _unitOfWork.TransactionRepository.UpdateOneAsync(updatedEntity, cancellationToken); + + await _unitOfWork.SaveAsync(cancellationToken); + + return _mapper.Map(databaseEntity); + } +} diff --git a/ExpenseTracker.Application/Transactions/Commands/Update/UpdateTransactionCommandValidator.cs b/ExpenseTracker.Application/Transactions/Commands/Update/UpdateTransactionCommandValidator.cs new file mode 100644 index 0000000..6b1766c --- /dev/null +++ b/ExpenseTracker.Application/Transactions/Commands/Update/UpdateTransactionCommandValidator.cs @@ -0,0 +1,29 @@ +using FluentValidation; +using ExpenseTracker.Domain.Enums; + +namespace ExpenseTracker.Application.Transactions.Commands.Update; + +public class UpdateTransactionCommandValidator : AbstractValidator +{ + public UpdateTransactionCommandValidator() + { + RuleFor(e => e.Id) + .NotEmpty(); + + RuleFor(e => e.Amount); + + RuleFor(e => e.Category) + .Must(c => + Category.Enumerations.Any(e => e.Value.Equals(Category.FromName(c))) || + c == null) + .WithMessage(c => $"'{nameof(c.Category)}' must be one of the following: '{String.Join("', ", Category.Enumerations.Values.Select(v => v.Name))}'."); + + RuleFor(e => e.Time); + + RuleFor(e => e.Description) + .Length(0, 256); + + RuleFor(e => e.AccountId) + .NotEmpty(); + } +} diff --git a/ExpenseTracker.Application/Transactions/Queries/Get/GetTransactionQuery.cs b/ExpenseTracker.Application/Transactions/Queries/Get/GetTransactionQuery.cs new file mode 100644 index 0000000..271e820 --- /dev/null +++ b/ExpenseTracker.Application/Transactions/Queries/Get/GetTransactionQuery.cs @@ -0,0 +1,8 @@ +using MediatR; + +namespace ExpenseTracker.Application.Transactions.Queries.Get; + +public record GetTransactionQuery : IRequest +{ + public string Id { get; set; } = null!; +} diff --git a/ExpenseTracker.Application/Transactions/Queries/Get/GetTransactionQueryAuthorizer.cs b/ExpenseTracker.Application/Transactions/Queries/Get/GetTransactionQueryAuthorizer.cs new file mode 100644 index 0000000..f6bbdb5 --- /dev/null +++ b/ExpenseTracker.Application/Transactions/Queries/Get/GetTransactionQueryAuthorizer.cs @@ -0,0 +1,44 @@ +using MediatR.Behaviors.Authorization; +using ExpenseTracker.Application.Common.Authorization; +using ExpenseTracker.Application.Common.Exceptions; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Application.Common.Models; + +namespace ExpenseTracker.Application.Transactions.Queries.Get; + +public class GetTransactionQueryAuthorizer : AbstractRequestAuthorizer +{ + private readonly ISessionUserService _sessionUserService; + private readonly IAccountRepository _accountRepository; + private readonly ITransactionRepository _transactionRepository; + + public GetTransactionQueryAuthorizer( + ISessionUserService currentUserService, + IAccountRepository accountRepository, + ITransactionRepository transactionRepository) + { + _sessionUserService = currentUserService; + _accountRepository = accountRepository; + _transactionRepository = transactionRepository; + } + + public override void BuildPolicy(GetTransactionQuery request) + { + UseRequirement(new MustBeAuthenticatedRequirement + { + IsAuthenticated = _sessionUserService.IsAuthenticated + }); + + var accountId = _transactionRepository.Queryable.FirstOrDefault(e => e.Id == request.Id)?.AccountId; + var requiredUserId = _accountRepository.Queryable.FirstOrDefault(e => e.Id == accountId)?.UserId; + + UseRequirement(new MustBeInRolesWhenInteractingWithUnOwnedEntityRequirement + { + UserId = _sessionUserService.Id, + UserRoles = _sessionUserService.Roles, + RequiredUserId = requiredUserId, + RequiredRoles = new[] { IdentityRoles.Administrator.ToString() } + }); + } +} diff --git a/ExpenseTracker.Application/Transactions/Queries/Get/GetTransactionQueryHandler.cs b/ExpenseTracker.Application/Transactions/Queries/Get/GetTransactionQueryHandler.cs new file mode 100644 index 0000000..2324b41 --- /dev/null +++ b/ExpenseTracker.Application/Transactions/Queries/Get/GetTransactionQueryHandler.cs @@ -0,0 +1,47 @@ +using AutoMapper; +using MediatR; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Domain.Entities; + +namespace ExpenseTracker.Application.Transactions.Queries.Get; + +public class GetTransactionQueryHandler : IRequestHandler +{ + private readonly IMapper _mapper; + private readonly ITransactionRepository _transactionRepository; + private readonly IAccountRepository _accountRepository; + + public GetTransactionQueryHandler( + IMapper mapper, + ITransactionRepository repository, + IAccountRepository accountRepository) + { + _mapper = mapper; + _transactionRepository = repository; + _accountRepository = accountRepository; + } + + public async Task Handle(GetTransactionQuery request, CancellationToken cancellationToken) + { + var entity = _transactionRepository.Queryable + .Join( + _accountRepository.Queryable, + t => t.AccountId, + b => b.Id, + (transaction, account) => + new Transaction + { + Id = transaction.Id, + Amount = transaction.Amount, + Category = transaction.Category, + Time = transaction.Time, + Description = transaction.Description, + Account = account, + AccountId = transaction.AccountId + } + ) + .FirstOrDefault(e => e.Id == request.Id); + + return _mapper.Map(entity); + } +} diff --git a/ExpenseTracker.Application/Transactions/Queries/Get/GetTransactionQueryValidator.cs b/ExpenseTracker.Application/Transactions/Queries/Get/GetTransactionQueryValidator.cs new file mode 100644 index 0000000..b235d16 --- /dev/null +++ b/ExpenseTracker.Application/Transactions/Queries/Get/GetTransactionQueryValidator.cs @@ -0,0 +1,12 @@ +using FluentValidation; + +namespace ExpenseTracker.Application.Transactions.Queries.Get; + +public class GetTransactionQueryValidator : AbstractValidator +{ + public GetTransactionQueryValidator() + { + RuleFor(e => e.Id) + .NotEmpty(); + } +} diff --git a/ExpenseTracker.Application/Transactions/Queries/GetWithPagination/GetTransactionsWithPaginationQuery.cs b/ExpenseTracker.Application/Transactions/Queries/GetWithPagination/GetTransactionsWithPaginationQuery.cs new file mode 100644 index 0000000..1307bd4 --- /dev/null +++ b/ExpenseTracker.Application/Transactions/Queries/GetWithPagination/GetTransactionsWithPaginationQuery.cs @@ -0,0 +1,13 @@ +using ExpenseTracker.Application.Common.Models; +using MediatR; + +namespace ExpenseTracker.Application.Transactions.Queries.GetWithPagination; + +public record GetTransactionsWithPaginationQuery : IRequest> +{ + public int PageNumber { get; set; } = 1; + + public int PageSize { get; set; } = 10; + + public string AccountId { get; set; } +} diff --git a/ExpenseTracker.Application/Transactions/Queries/GetWithPagination/GetTransactionsWithPaginationQueryAuthorizer.cs b/ExpenseTracker.Application/Transactions/Queries/GetWithPagination/GetTransactionsWithPaginationQueryAuthorizer.cs new file mode 100644 index 0000000..31a2131 --- /dev/null +++ b/ExpenseTracker.Application/Transactions/Queries/GetWithPagination/GetTransactionsWithPaginationQueryAuthorizer.cs @@ -0,0 +1,40 @@ +using MediatR.Behaviors.Authorization; +using ExpenseTracker.Application.Common.Authorization; +using ExpenseTracker.Application.Common.Exceptions; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Application.Common.Models; + +namespace ExpenseTracker.Application.Transactions.Queries.GetWithPagination; + +public class GetTransactionsWithPaginationQueryAuthorizer : AbstractRequestAuthorizer +{ + private readonly ISessionUserService _sessionUserService; + private readonly IAccountRepository _repository; + + public GetTransactionsWithPaginationQueryAuthorizer( + ISessionUserService currentUserService, + IAccountRepository repository) + { + _sessionUserService = currentUserService; + _repository = repository; + } + + public override void BuildPolicy(GetTransactionsWithPaginationQuery request) + { + UseRequirement(new MustBeAuthenticatedRequirement + { + IsAuthenticated = _sessionUserService.IsAuthenticated + }); + + var requiredUserId = _repository.Queryable.FirstOrDefault(e => e.Id == request.AccountId)?.UserId; + + UseRequirement(new MustBeInRolesWhenInteractingWithUnOwnedEntityRequirement() + { + UserId = _sessionUserService.Id, + UserRoles = _sessionUserService.Roles, + RequiredUserId = requiredUserId, + RequiredRoles = new[] { IdentityRoles.Administrator.ToString() } + }); + } +} diff --git a/ExpenseTracker.Application/Transactions/Queries/GetWithPagination/GetTransactionsWithPaginationQueryHandler.cs b/ExpenseTracker.Application/Transactions/Queries/GetWithPagination/GetTransactionsWithPaginationQueryHandler.cs new file mode 100644 index 0000000..c4f61a4 --- /dev/null +++ b/ExpenseTracker.Application/Transactions/Queries/GetWithPagination/GetTransactionsWithPaginationQueryHandler.cs @@ -0,0 +1,42 @@ +using AutoMapper; +using MediatR; +using ExpenseTracker.Application.Common.Extensions; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Application.Common.Models; +using ExpenseTracker.Domain.Entities; + +namespace ExpenseTracker.Application.Transactions.Queries.GetWithPagination; + +public class GetTransactionsWithPaginationQueryHandler : IRequestHandler> +{ + private readonly IMapper _mapper; + private readonly ITransactionRepository _transactionRepository; + + public GetTransactionsWithPaginationQueryHandler( + IMapper mapper, + ITransactionRepository repository) + { + _mapper = mapper; + _transactionRepository = repository; + } + + public async Task> Handle( + GetTransactionsWithPaginationQuery request, + CancellationToken cancellationToken) + { + // TODO: This is unoptimized. Pagination is being applied + // on the side of the application + // and not on the side of the database + + Func func = t => t.Time; + + var entities = _transactionRepository.Queryable + .Where(e => e.AccountId == request.AccountId) + .OrderByDescending(func) + .AsQueryable(); + + + return entities + .ProjectToPaginatedList(request.PageNumber, request.PageSize, _mapper.ConfigurationProvider); + } +} diff --git a/ExpenseTracker.Application/Transactions/Queries/GetWithPagination/GetTransactionsWithPaginationQueryValidator.cs b/ExpenseTracker.Application/Transactions/Queries/GetWithPagination/GetTransactionsWithPaginationQueryValidator.cs new file mode 100644 index 0000000..3b612a3 --- /dev/null +++ b/ExpenseTracker.Application/Transactions/Queries/GetWithPagination/GetTransactionsWithPaginationQueryValidator.cs @@ -0,0 +1,16 @@ +using FluentValidation; + +namespace ExpenseTracker.Application.Transactions.Queries.GetWithPagination; + +public class GetTransactionsWithPaginationQueryValidator : AbstractValidator +{ + public GetTransactionsWithPaginationQueryValidator() + { + RuleFor(v => v.PageNumber) + .GreaterThanOrEqualTo(1); + + RuleFor(v => v.PageSize) + .GreaterThanOrEqualTo(1) + .LessThanOrEqualTo(50); + } +} diff --git a/ExpenseTracker.Application/Transactions/TransactionDto.cs b/ExpenseTracker.Application/Transactions/TransactionDto.cs new file mode 100644 index 0000000..25c1ae9 --- /dev/null +++ b/ExpenseTracker.Application/Transactions/TransactionDto.cs @@ -0,0 +1,29 @@ +using AutoMapper; +using ExpenseTracker.Application.Common.Mappings; +using ExpenseTracker.Domain.Entities; + +namespace ExpenseTracker.Application.Transactions; + +public class TransactionDto : IMapFrom +{ + public string Id { get; set; } + + public double Amount { get; set; } + + public string Category { get; set; } + + public DateTimeOffset Time { get; set; } + + public string? Description { get; set; } + + public string? AccountId { get; set; } + + public void Mapping(Profile profile) + { + profile.CreateMap() + .ForMember(d => d.Category, opt => opt.MapFrom(s => s.Category.Name)); + + profile.CreateMap() + .ForMember(d => d.Category, opt => opt.MapFrom(s => Domain.Enums.Category.FromName(s.Category))); + } +} diff --git a/ExpenseTracker.Application/Transactions/TransactionJsonDto.cs b/ExpenseTracker.Application/Transactions/TransactionJsonDto.cs new file mode 100644 index 0000000..ba1606b --- /dev/null +++ b/ExpenseTracker.Application/Transactions/TransactionJsonDto.cs @@ -0,0 +1,25 @@ +using AutoMapper; +using ExpenseTracker.Application.Common.Mappings; +using ExpenseTracker.Domain.Entities; + +namespace ExpenseTracker.Application.Transactions; + +public class TransactionJsonDto : IMapFrom +{ + public double Amount { get; set; } + + public string Category { get; set; } + + public DateTimeOffset Time { get; set; } + + public string? Description { get; set; } + + public void Mapping(Profile profile) + { + profile.CreateMap() + .ForMember(d => d.Category, opt => opt.MapFrom(s => s.Category.Name)); + + profile.CreateMap() + .ForMember(d => d.Category, opt => opt.MapFrom(s => Domain.Enums.Category.FromName(s.Category))); + } +} diff --git a/ExpenseTracker.Application/Users/Commands/Create/CreateUserCommand.cs b/ExpenseTracker.Application/Users/Commands/Create/CreateUserCommand.cs new file mode 100644 index 0000000..97b5c0f --- /dev/null +++ b/ExpenseTracker.Application/Users/Commands/Create/CreateUserCommand.cs @@ -0,0 +1,12 @@ +using MediatR; + +namespace ExpenseTracker.Application.Users.Commands.Create; + +public record CreateUserCommand : IRequest +{ + public string Email { get; set; } + + public string Password { get; set; } + + public List Roles { get; set; } +} diff --git a/ExpenseTracker.Application/Users/Commands/Create/CreateUserCommandAuthorizer.cs b/ExpenseTracker.Application/Users/Commands/Create/CreateUserCommandAuthorizer.cs new file mode 100644 index 0000000..3b8f65d --- /dev/null +++ b/ExpenseTracker.Application/Users/Commands/Create/CreateUserCommandAuthorizer.cs @@ -0,0 +1,31 @@ +using MediatR.Behaviors.Authorization; +using ExpenseTracker.Application.Common.Authorization; +using ExpenseTracker.Application.Common.Exceptions; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Application.Common.Models; + +namespace ExpenseTracker.Application.Users.Commands.Create; + +public class CreateUserCommandAuthorizer : AbstractRequestAuthorizer +{ + private readonly ISessionUserService _sessionUserService; + + public CreateUserCommandAuthorizer(ISessionUserService currentUserService) + { + _sessionUserService = currentUserService; + } + + public override void BuildPolicy(CreateUserCommand request) + { + UseRequirement(new MustBeAuthenticatedRequirement + { + IsAuthenticated = _sessionUserService.IsAuthenticated + }); + + UseRequirement(new MustBeInRolesRequirement + { + UserRoles = _sessionUserService.Roles, + RequiredRoles = new string[] { IdentityRoles.Administrator.ToString() } + }); + } +} diff --git a/ExpenseTracker.Application/Users/Commands/Create/CreateUserCommandHandler.cs b/ExpenseTracker.Application/Users/Commands/Create/CreateUserCommandHandler.cs new file mode 100644 index 0000000..204c369 --- /dev/null +++ b/ExpenseTracker.Application/Users/Commands/Create/CreateUserCommandHandler.cs @@ -0,0 +1,15 @@ +using MediatR; + +namespace ExpenseTracker.Application.Users.Commands.Create; + +public class CreateUserCommandHandler : IRequestHandler +{ + public CreateUserCommandHandler() + { + } + + public async Task Handle(CreateUserCommand request, CancellationToken cancellationToken) + { + throw new NotImplementedException(); + } +} diff --git a/ExpenseTracker.Application/Users/Commands/Create/CreateUserCommandValidator.cs b/ExpenseTracker.Application/Users/Commands/Create/CreateUserCommandValidator.cs new file mode 100644 index 0000000..d59927f --- /dev/null +++ b/ExpenseTracker.Application/Users/Commands/Create/CreateUserCommandValidator.cs @@ -0,0 +1,11 @@ +using FluentValidation; + +namespace ExpenseTracker.Application.Users.Commands.Create; + +public class CreateUserCommandValidator : AbstractValidator +{ + public CreateUserCommandValidator() + { + + } +} diff --git a/ExpenseTracker.Application/Users/Commands/Delete/DeleteUserCommand.cs b/ExpenseTracker.Application/Users/Commands/Delete/DeleteUserCommand.cs new file mode 100644 index 0000000..4ff49b9 --- /dev/null +++ b/ExpenseTracker.Application/Users/Commands/Delete/DeleteUserCommand.cs @@ -0,0 +1,8 @@ +using MediatR; + +namespace ExpenseTracker.Application.Users.Commands.Delete; + +public record DeleteUserCommand : IRequest +{ + public string Id { get; set; } +} diff --git a/ExpenseTracker.Application/Users/Commands/Delete/DeleteUserCommandAuthorizer.cs b/ExpenseTracker.Application/Users/Commands/Delete/DeleteUserCommandAuthorizer.cs new file mode 100644 index 0000000..79e3986 --- /dev/null +++ b/ExpenseTracker.Application/Users/Commands/Delete/DeleteUserCommandAuthorizer.cs @@ -0,0 +1,31 @@ +using MediatR.Behaviors.Authorization; +using ExpenseTracker.Application.Common.Authorization; +using ExpenseTracker.Application.Common.Exceptions; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Application.Common.Models; + +namespace ExpenseTracker.Application.Users.Commands.Delete; + +public class DeleteUserCommandAuthorizer : AbstractRequestAuthorizer +{ + private readonly ISessionUserService _sessionUserService; + + public DeleteUserCommandAuthorizer(ISessionUserService currentUserService) + { + _sessionUserService = currentUserService; + } + + public override void BuildPolicy(DeleteUserCommand request) + { + UseRequirement(new MustBeAuthenticatedRequirement + { + IsAuthenticated = _sessionUserService.IsAuthenticated + }); + + UseRequirement(new MustBeInRolesRequirement + { + UserRoles = _sessionUserService.Roles, + RequiredRoles = new string[] { IdentityRoles.Administrator.ToString() } + }); + } +} diff --git a/ExpenseTracker.Application/Users/Commands/Delete/DeleteUserCommandHandler.cs b/ExpenseTracker.Application/Users/Commands/Delete/DeleteUserCommandHandler.cs new file mode 100644 index 0000000..2c55227 --- /dev/null +++ b/ExpenseTracker.Application/Users/Commands/Delete/DeleteUserCommandHandler.cs @@ -0,0 +1,15 @@ +using MediatR; + +namespace ExpenseTracker.Application.Users.Commands.Delete; + +public class DeleteUserCommandHandler : IRequestHandler +{ + public DeleteUserCommandHandler() + { + } + + public async Task Handle(DeleteUserCommand request, CancellationToken cancellationToken) + { + throw new NotImplementedException(); + } +} diff --git a/ExpenseTracker.Application/Users/Commands/Delete/DeleteUserCommandValidator.cs b/ExpenseTracker.Application/Users/Commands/Delete/DeleteUserCommandValidator.cs new file mode 100644 index 0000000..ec8b24e --- /dev/null +++ b/ExpenseTracker.Application/Users/Commands/Delete/DeleteUserCommandValidator.cs @@ -0,0 +1,12 @@ +using FluentValidation; + +namespace ExpenseTracker.Application.Users.Commands.Delete; + +public class DeleteUserCommandValidator : AbstractValidator +{ + public DeleteUserCommandValidator() + { + RuleFor(e => e.Id) + .NotEmpty(); + } +} diff --git a/ExpenseTracker.Application/Users/Commands/Update/UpdateUserCommand.cs b/ExpenseTracker.Application/Users/Commands/Update/UpdateUserCommand.cs new file mode 100644 index 0000000..2f122df --- /dev/null +++ b/ExpenseTracker.Application/Users/Commands/Update/UpdateUserCommand.cs @@ -0,0 +1,12 @@ +using MediatR; + +namespace ExpenseTracker.Application.Users.Commands.Update; + +public record UpdateUserCommand : IRequest +{ + public string Email { get; set; } + + public string Password { get; set; } + + public List Roles { get; set; } +} diff --git a/ExpenseTracker.Application/Users/Commands/Update/UpdateUserCommandAuthorizer.cs b/ExpenseTracker.Application/Users/Commands/Update/UpdateUserCommandAuthorizer.cs new file mode 100644 index 0000000..bd1c206 --- /dev/null +++ b/ExpenseTracker.Application/Users/Commands/Update/UpdateUserCommandAuthorizer.cs @@ -0,0 +1,31 @@ +using MediatR.Behaviors.Authorization; +using ExpenseTracker.Application.Common.Authorization; +using ExpenseTracker.Application.Common.Exceptions; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Application.Common.Models; + +namespace ExpenseTracker.Application.Users.Commands.Update; + +public class UpdateUserCommandAuthorizer : AbstractRequestAuthorizer +{ + private readonly ISessionUserService _sessionUserService; + + public UpdateUserCommandAuthorizer(ISessionUserService currentUserService) + { + _sessionUserService = currentUserService; + } + + public override void BuildPolicy(UpdateUserCommand request) + { + UseRequirement(new MustBeAuthenticatedRequirement + { + IsAuthenticated = _sessionUserService.IsAuthenticated + }); + + UseRequirement(new MustBeInRolesRequirement + { + UserRoles = _sessionUserService.Roles, + RequiredRoles = new string[] { IdentityRoles.Administrator.ToString() } + }); + } +} diff --git a/ExpenseTracker.Application/Users/Commands/Update/UpdateUserCommandHandler.cs b/ExpenseTracker.Application/Users/Commands/Update/UpdateUserCommandHandler.cs new file mode 100644 index 0000000..45d5ae1 --- /dev/null +++ b/ExpenseTracker.Application/Users/Commands/Update/UpdateUserCommandHandler.cs @@ -0,0 +1,15 @@ +using MediatR; + +namespace ExpenseTracker.Application.Users.Commands.Update; + +public class UpdateUserCommandHandler : IRequestHandler +{ + public UpdateUserCommandHandler() + { + } + + public async Task Handle(UpdateUserCommand request, CancellationToken cancellationToken) + { + throw new NotImplementedException(); + } +} diff --git a/ExpenseTracker.Application/Users/Commands/Update/UpdateUserCommandValidator.cs b/ExpenseTracker.Application/Users/Commands/Update/UpdateUserCommandValidator.cs new file mode 100644 index 0000000..708af0b --- /dev/null +++ b/ExpenseTracker.Application/Users/Commands/Update/UpdateUserCommandValidator.cs @@ -0,0 +1,11 @@ +using FluentValidation; + +namespace ExpenseTracker.Application.Users.Commands.Update; + +public class UpdateUserCommandValidator : AbstractValidator +{ + public UpdateUserCommandValidator() + { + + } +} diff --git a/ExpenseTracker.Application/Users/Queries/Get/GetUserQuery.cs b/ExpenseTracker.Application/Users/Queries/Get/GetUserQuery.cs new file mode 100644 index 0000000..860f78e --- /dev/null +++ b/ExpenseTracker.Application/Users/Queries/Get/GetUserQuery.cs @@ -0,0 +1,8 @@ +using MediatR; + +namespace ExpenseTracker.Application.Users.Queries.Get; + +public record GetUserQuery : IRequest +{ + public string Id { get; set; } +} diff --git a/ExpenseTracker.Application/Users/Queries/Get/GetUserQueryAuthorizer.cs b/ExpenseTracker.Application/Users/Queries/Get/GetUserQueryAuthorizer.cs new file mode 100644 index 0000000..328ac39 --- /dev/null +++ b/ExpenseTracker.Application/Users/Queries/Get/GetUserQueryAuthorizer.cs @@ -0,0 +1,30 @@ +using MediatR.Behaviors.Authorization; +using ExpenseTracker.Application.Common.Authorization; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Application.Common.Models; + +namespace ExpenseTracker.Application.Users.Queries.Get; + +public class GetUserQueryAuthorizer : AbstractRequestAuthorizer +{ + private readonly ISessionUserService _sessionUserService; + + public GetUserQueryAuthorizer(ISessionUserService currentUserService) + { + _sessionUserService = currentUserService; + } + + public override void BuildPolicy(GetUserQuery request) + { + UseRequirement(new MustBeAuthenticatedRequirement + { + IsAuthenticated = _sessionUserService.IsAuthenticated + }); + + UseRequirement(new MustBeInRolesRequirement + { + UserRoles = _sessionUserService.Roles, + RequiredRoles = new[] { IdentityRoles.Administrator.ToString() } + }); + } +} diff --git a/ExpenseTracker.Application/Users/Queries/Get/GetUserQueryHandler.cs b/ExpenseTracker.Application/Users/Queries/Get/GetUserQueryHandler.cs new file mode 100644 index 0000000..8fbf4a9 --- /dev/null +++ b/ExpenseTracker.Application/Users/Queries/Get/GetUserQueryHandler.cs @@ -0,0 +1,20 @@ +using AutoMapper; +using MediatR; + +namespace ExpenseTracker.Application.Users.Queries.Get; + +public class GetUserQueryHandler : IRequestHandler +{ + private readonly IMapper _mapper; + + public GetUserQueryHandler( + IMapper mapper) + { + _mapper = mapper; + } + + public async Task Handle(GetUserQuery request, CancellationToken cancellationToken) + { + throw new NotImplementedException(); + } +} diff --git a/ExpenseTracker.Application/Users/Queries/Get/GetUserQueryValidator.cs b/ExpenseTracker.Application/Users/Queries/Get/GetUserQueryValidator.cs new file mode 100644 index 0000000..87089fb --- /dev/null +++ b/ExpenseTracker.Application/Users/Queries/Get/GetUserQueryValidator.cs @@ -0,0 +1,12 @@ +using FluentValidation; + +namespace ExpenseTracker.Application.Users.Queries.Get; + +public class GetUserQueryValidator : AbstractValidator +{ + public GetUserQueryValidator() + { + RuleFor(e => e.Id) + .NotEmpty(); + } +} diff --git a/ExpenseTracker.Application/Users/Queries/GetWithPagination/GetUsersWithPaginationQuery.cs b/ExpenseTracker.Application/Users/Queries/GetWithPagination/GetUsersWithPaginationQuery.cs new file mode 100644 index 0000000..eefbd25 --- /dev/null +++ b/ExpenseTracker.Application/Users/Queries/GetWithPagination/GetUsersWithPaginationQuery.cs @@ -0,0 +1,11 @@ +using ExpenseTracker.Application.Common.Models; +using MediatR; + +namespace ExpenseTracker.Application.Users.Queries.GetWithPagination; + +public record GetUsersWithPaginationQuery : IRequest> +{ + public int PageNumber { get; set; } = 1; + + public int PageSize { get; set; } = 10; +} diff --git a/ExpenseTracker.Application/Users/Queries/GetWithPagination/GetUsersWithPaginationQueryAuthorizer.cs b/ExpenseTracker.Application/Users/Queries/GetWithPagination/GetUsersWithPaginationQueryAuthorizer.cs new file mode 100644 index 0000000..b6aa851 --- /dev/null +++ b/ExpenseTracker.Application/Users/Queries/GetWithPagination/GetUsersWithPaginationQueryAuthorizer.cs @@ -0,0 +1,30 @@ +using MediatR.Behaviors.Authorization; +using ExpenseTracker.Application.Common.Authorization; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Application.Common.Models; + +namespace ExpenseTracker.Application.Users.Queries.GetWithPagination; + +public class GetUsersWithPaginationQueryAuthorizer : AbstractRequestAuthorizer +{ + private readonly ISessionUserService _sessionUserService; + + public GetUsersWithPaginationQueryAuthorizer(ISessionUserService currentUserService) + { + _sessionUserService = currentUserService; + } + + public override void BuildPolicy(GetUsersWithPaginationQuery request) + { + UseRequirement(new MustBeAuthenticatedRequirement + { + IsAuthenticated = _sessionUserService.IsAuthenticated + }); + + UseRequirement(new MustBeInRolesRequirement + { + UserRoles = _sessionUserService.Roles, + RequiredRoles = new[] { IdentityRoles.Administrator.ToString() } + }); + } +} diff --git a/ExpenseTracker.Application/Users/Queries/GetWithPagination/GetUsersWithPaginationQueryHandler.cs b/ExpenseTracker.Application/Users/Queries/GetWithPagination/GetUsersWithPaginationQueryHandler.cs new file mode 100644 index 0000000..0fc4cc4 --- /dev/null +++ b/ExpenseTracker.Application/Users/Queries/GetWithPagination/GetUsersWithPaginationQueryHandler.cs @@ -0,0 +1,21 @@ +using AutoMapper; +using MediatR; +using ExpenseTracker.Application.Common.Models; + +namespace ExpenseTracker.Application.Users.Queries.GetWithPagination; + +public class GetUserssWithPaginationQueryHandler : IRequestHandler> +{ + private readonly IMapper _mapper; + + public GetUserssWithPaginationQueryHandler( + IMapper mapper) + { + _mapper = mapper; + } + + public async Task> Handle(GetUsersWithPaginationQuery request, CancellationToken cancellationToken) + { + throw new NotImplementedException(); + } +} diff --git a/ExpenseTracker.Application/Users/Queries/GetWithPagination/GetUsersWithPaginationQueryValidator.cs b/ExpenseTracker.Application/Users/Queries/GetWithPagination/GetUsersWithPaginationQueryValidator.cs new file mode 100644 index 0000000..cd5af2e --- /dev/null +++ b/ExpenseTracker.Application/Users/Queries/GetWithPagination/GetUsersWithPaginationQueryValidator.cs @@ -0,0 +1,16 @@ +using FluentValidation; + +namespace ExpenseTracker.Application.Users.Queries.GetWithPagination; + +public class GetUsersWithPaginationQueryValidator : AbstractValidator +{ + public GetUsersWithPaginationQueryValidator() + { + RuleFor(v => v.PageNumber) + .GreaterThanOrEqualTo(1); + + RuleFor(v => v.PageSize) + .GreaterThanOrEqualTo(1) + .LessThanOrEqualTo(50); + } +} diff --git a/ExpenseTracker.Application/Users/UserDto.cs b/ExpenseTracker.Application/Users/UserDto.cs new file mode 100644 index 0000000..d2da4b1 --- /dev/null +++ b/ExpenseTracker.Application/Users/UserDto.cs @@ -0,0 +1,12 @@ +namespace ExpenseTracker.Application.Users; + +public class UserDto +{ + public string Id { get; set; } + + public string Email { get; set; } + + public bool EmailConfirmed { get; set; } + + public List Roles { get; set; } +} diff --git a/ExpenseTracker.Domain/Entities/Account.cs b/ExpenseTracker.Domain/Entities/Account.cs new file mode 100644 index 0000000..438dfaa --- /dev/null +++ b/ExpenseTracker.Domain/Entities/Account.cs @@ -0,0 +1,17 @@ +using ExpenseTracker.Domain.Enums; + +namespace ExpenseTracker.Domain.Entities; + +public sealed class Account : EntityBase +{ + public string Name { get; set; } + + public string? Description { get; set; } + + public Currency Currency { get; set; } + + public string UserId { get; set; } + + public IEnumerable? Transactions { get; set; } +} + diff --git a/ExpenseTracker.Domain/Entities/EntityBase.cs b/ExpenseTracker.Domain/Entities/EntityBase.cs new file mode 100644 index 0000000..ef19f76 --- /dev/null +++ b/ExpenseTracker.Domain/Entities/EntityBase.cs @@ -0,0 +1,6 @@ +namespace ExpenseTracker.Domain.Entities; + +public abstract class EntityBase where TKey : IEquatable +{ + public TKey Id { get; set; } +} diff --git a/ExpenseTracker.Domain/Entities/Role.cs b/ExpenseTracker.Domain/Entities/Role.cs new file mode 100644 index 0000000..74333aa --- /dev/null +++ b/ExpenseTracker.Domain/Entities/Role.cs @@ -0,0 +1,8 @@ +namespace ExpenseTracker.Domain.Entities; + +public sealed class Role : EntityBase +{ + public string Name { get; set; } + + public ICollection RoleUsers { get; set; } +} diff --git a/ExpenseTracker.Domain/Entities/Transaction.cs b/ExpenseTracker.Domain/Entities/Transaction.cs new file mode 100644 index 0000000..38f43c0 --- /dev/null +++ b/ExpenseTracker.Domain/Entities/Transaction.cs @@ -0,0 +1,18 @@ +using ExpenseTracker.Domain.Enums; + +namespace ExpenseTracker.Domain.Entities; + +public sealed class Transaction : EntityBase +{ + public double Amount { get; set; } + + public Category Category { get; set; } + + public DateTimeOffset Time { get; set; } + + public string? Description { get; set; } + + public Account Account { get; set; } + + public string AccountId { get; set; } +} diff --git a/ExpenseTracker.Domain/Entities/User.cs b/ExpenseTracker.Domain/Entities/User.cs new file mode 100644 index 0000000..564676e --- /dev/null +++ b/ExpenseTracker.Domain/Entities/User.cs @@ -0,0 +1,12 @@ +namespace ExpenseTracker.Domain.Entities; + +public sealed class User : EntityBase +{ + public string Email { get; set; } + + public bool EmailConfirmed { get; set; } + + public string PasswordHash { get; set; } + + public ICollection UserRoles { get; set; } +} diff --git a/ExpenseTracker.Domain/Entities/UserRole.cs b/ExpenseTracker.Domain/Entities/UserRole.cs new file mode 100644 index 0000000..1f0a2be --- /dev/null +++ b/ExpenseTracker.Domain/Entities/UserRole.cs @@ -0,0 +1,12 @@ +namespace ExpenseTracker.Domain.Entities; + +public sealed class UserRole : EntityBase +{ + public string UserId { get; set; } + + public User User { get; set; } + + public string RoleId { get; set; } + + public Role Role { get; set; } +} diff --git a/ExpenseTracker.Domain/Enums/Category.cs b/ExpenseTracker.Domain/Enums/Category.cs new file mode 100644 index 0000000..b03a1ca --- /dev/null +++ b/ExpenseTracker.Domain/Enums/Category.cs @@ -0,0 +1,126 @@ +namespace ExpenseTracker.Domain.Enums; + +public abstract class Category : Enumeration +{ + public static readonly Category Savings = new SavingsCategory(); + public static readonly Category Investments = new InvestmentsCategory(); + public static readonly Category Housing = new HousingCategory(); + public static readonly Category Transportation = new TransportationCategory(); + public static readonly Category Groceries = new GroceriesCategory(); + public static readonly Category Utilities = new UtilitiesCategory(); + public static readonly Category HealthCare = new HealthCareCategory(); + public static readonly Category LifeInsurance = new LifeInsuranceCategory(); + public static readonly Category Childcare = new ChildcareCategory(); + public static readonly Category PersonalDebts = new PersonalDebtsCategory(); + public static readonly Category ClothingAndAccessories = new ClothingAndAccessoriesCategory(); + public static readonly Category GymMembership = new GymMembershipCategory(); + public static readonly Category PersonalProducts = new PersonalProductsCategory(); + public static readonly Category Entertainment = new EntertainmentCategory(); + public static readonly Category GadgetsAndElectronics = new GadgetsAndElectronicsCategory(); + public static readonly Category Gifts = new GiftsCategory(); + public static readonly Category Donations = new DonationsCategory(); + public static readonly Category Travel = new TravelCategory(); + public static readonly Category InitialBalance = new InitialBalanceCategory(); + + protected Category(int value, string name) : base(value, name) { } + + private sealed class AllCategory : Category + { + public AllCategory() : base(0, "Savings") { } + } + + private sealed class SavingsCategory : Category + { + public SavingsCategory() : base(1, "Savings") { } + } + + private sealed class InvestmentsCategory : Category + { + public InvestmentsCategory() : base(2, "Investments") { } + } + + private sealed class HousingCategory : Category + { + public HousingCategory() : base(3, "Housing") { } + } + + private sealed class TransportationCategory : Category + { + public TransportationCategory() : base(4, "Transportation") { } + } + + private sealed class GroceriesCategory : Category + { + public GroceriesCategory() : base(5, "Groceries") { } + } + + private sealed class UtilitiesCategory : Category + { + public UtilitiesCategory() : base(6, "Utilities") { } + } + + private sealed class HealthCareCategory : Category + { + public HealthCareCategory() : base(7, "Health") { } + } + + private sealed class LifeInsuranceCategory : Category + { + public LifeInsuranceCategory() : base(8, "LifeInsurance") { } + } + + private sealed class ChildcareCategory : Category + { + public ChildcareCategory() : base(9, "Childcare") { } + } + + private sealed class PersonalDebtsCategory : Category + { + public PersonalDebtsCategory() : base(10, "PersonalDebts") { } + } + + private sealed class ClothingAndAccessoriesCategory : Category + { + public ClothingAndAccessoriesCategory() : base(11, "ClothingAndAccessories") { } + } + + private sealed class GymMembershipCategory : Category + { + public GymMembershipCategory() : base(12, "GymMembership") { } + } + + private sealed class PersonalProductsCategory : Category + { + public PersonalProductsCategory() : base(13, "PersonalProducts") { } + } + + private sealed class EntertainmentCategory : Category + { + public EntertainmentCategory() : base(14, "Entertainment") { } + } + + private sealed class GadgetsAndElectronicsCategory : Category + { + public GadgetsAndElectronicsCategory() : base(15, "GadgetsAndElectronics") { } + } + + private sealed class GiftsCategory : Category + { + public GiftsCategory() : base(16, "Gifts") { } + } + + private sealed class DonationsCategory : Category + { + public DonationsCategory() : base(17, "Donations") { } + } + + private sealed class TravelCategory : Category + { + public TravelCategory() : base(18, "Travel") { } + } + + private sealed class InitialBalanceCategory : Category + { + public InitialBalanceCategory() : base(19, "InitialBalance") { } + } +} diff --git a/ExpenseTracker.Domain/Enums/Currency.cs b/ExpenseTracker.Domain/Enums/Currency.cs new file mode 100644 index 0000000..055b20a --- /dev/null +++ b/ExpenseTracker.Domain/Enums/Currency.cs @@ -0,0 +1,37 @@ +namespace ExpenseTracker.Domain.Enums; + +public abstract class Currency : Enumeration +{ + public static readonly Currency Default = new DefaultCurrency(); + public static readonly Currency AUD = new AudCurrency(); + public static readonly Currency USD = new UsdCurrency(); + public static readonly Currency EUR = new EurCurrency(); + public static readonly Currency UAH = new UahCurrency(); + + protected Currency(int value, string name) : base(value, name) { } + + private sealed class DefaultCurrency : Currency + { + public DefaultCurrency() : base(0, "Default") { } + } + + private sealed class AudCurrency : Currency + { + public AudCurrency() : base (036, "AUD") { } + } + + private sealed class UsdCurrency : Currency + { + public UsdCurrency() : base(840, "USD") { } + } + + private sealed class UahCurrency : Currency + { + public UahCurrency() : base(978, "UAH") { } + } + + private sealed class EurCurrency : Currency + { + public EurCurrency() : base(980, "EUR") { } + } +} diff --git a/ExpenseTracker.Domain/Enums/Enumeration.cs b/ExpenseTracker.Domain/Enums/Enumeration.cs new file mode 100644 index 0000000..f9ed4f7 --- /dev/null +++ b/ExpenseTracker.Domain/Enums/Enumeration.cs @@ -0,0 +1,78 @@ +namespace ExpenseTracker.Domain.Enums; + +using System.Reflection; + +public abstract class Enumeration : IEquatable> + where TEnum : Enumeration +{ + public static Dictionary Enumerations { get; private set; } = CreateEnumerations(); + + protected Enumeration(int value, string name) + { + Value = value; + Name = name; + } + + public int Value { get; protected init; } + + public string Name { get; protected init; } = string.Empty; + + public static TEnum? FromValue(int value) + { + return + Enumerations.TryGetValue(value, out TEnum? enumeration) ? + enumeration : + default; + } + + public static TEnum? FromName(string name) + { + return Enumerations.Values.SingleOrDefault(v => v.Name == name); + } + + public bool Equals(Enumeration? other) + { + if (other is null) + { + return false; + } + + return + GetType() == other.GetType() && + Value == other.Value; + } + + public override bool Equals(object? obj) + { + return + obj is Enumeration other && + Equals(other); + } + + public override int GetHashCode() + { + return Value.GetHashCode(); + } + + public override string ToString() + { + return Name; + } + + private static Dictionary CreateEnumerations() + { + var enumerationType = typeof(TEnum); + + var fieldsForType = enumerationType + .GetFields( + BindingFlags.Public | + BindingFlags.Static | + BindingFlags.FlattenHierarchy) + .Where(fieldInfo => + enumerationType.IsAssignableFrom(fieldInfo.FieldType)) + .Select(fieldInfo => + (TEnum) fieldInfo.GetValue(default)!); + + return fieldsForType.ToDictionary(x => x.Value); + } +} diff --git a/ExpenseTracker.Domain/ExpenseTracker.Domain.csproj b/ExpenseTracker.Domain/ExpenseTracker.Domain.csproj new file mode 100644 index 0000000..fa71b7a --- /dev/null +++ b/ExpenseTracker.Domain/ExpenseTracker.Domain.csproj @@ -0,0 +1,9 @@ + + + + net8.0 + enable + enable + + + diff --git a/ExpenseTracker.Infrastructure/DependencyInjection.cs b/ExpenseTracker.Infrastructure/DependencyInjection.cs new file mode 100644 index 0000000..abf0c78 --- /dev/null +++ b/ExpenseTracker.Infrastructure/DependencyInjection.cs @@ -0,0 +1,99 @@ +using Microsoft.Extensions.Configuration; +using Microsoft.Extensions.DependencyInjection; +using AspNetCore.Identity.Mongo; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Infrastructure.Identity.Models; +using ExpenseTracker.Infrastructure.Identity.Services; +using Microsoft.AspNetCore.Authentication.JwtBearer; +using Microsoft.IdentityModel.Tokens; +using System.Text; +using ExpenseTracker.Infrastructure.Services; +using ExpenseTracker.Infrastructure.Email; + +namespace ExpenseTracker.Infrastructure; + +public static class DependencyInjection +{ + public static IServiceCollection AddInfrastructure(this IServiceCollection services, IConfiguration configuration) + { + services + .AddIdentity(configuration) + .AddAuthenticationWithJwt(configuration) + .AddServices(); + + return services; + } + + private static IServiceCollection AddIdentity(this IServiceCollection services, IConfiguration configuration) + { + AddMongoDbIdentity(); + + return services; + + void AddMongoDbIdentity() + { + var mongoDbConnectionString = $"{configuration["Database:ConnectionString"]}/{configuration["Database:IdentityPartitionName"]}"; + + services.AddIdentityMongoDbProvider( + identity => + { + }, + mongo => + { + mongo.ConnectionString = mongoDbConnectionString; + }); + } + + void AddPostgreSQLIdentity() + { + // TODO: Add PostgreSQL Identity connector + } + } + + private static IServiceCollection AddAuthenticationWithJwt(this IServiceCollection services, IConfiguration configuration) + { + services + .AddAuthentication(options => + { + options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; + options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; + options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme; + }) + .AddJwtBearer(options => + { + options.IncludeErrorDetails = true; + options.SaveToken = true; + options.RequireHttpsMetadata = false; + options.TokenValidationParameters = new TokenValidationParameters() + { + ValidateIssuer = false, + ValidateAudience = false, + ValidateLifetime = true, + ValidateIssuerSigningKey = true, + ValidAudience = configuration["Jwt:Audience"], + ValidIssuer = configuration["Jwt:Issuer"], + ClockSkew = TimeSpan.Zero, + IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(configuration["Jwt:IssuerSigningKey"])) + }; + }); + + return services; + } + + private static IServiceCollection AddServices(this IServiceCollection services) + { + services + .AddScoped() + .AddScoped() + .AddSingleton(); + + services.AddHttpClient( + "CurrencyConverterService", + client => + { + client.BaseAddress = new Uri("https://api.freecurrencyapi.com/v1"); + }); + + return services; + } +} diff --git a/ExpenseTracker.Infrastructure/Email/EmailSenderService.cs b/ExpenseTracker.Infrastructure/Email/EmailSenderService.cs new file mode 100644 index 0000000..f570a3d --- /dev/null +++ b/ExpenseTracker.Infrastructure/Email/EmailSenderService.cs @@ -0,0 +1,63 @@ +using System.Text; +using ExpenseTracker.Application.Common.Interfaces.Services; +using MailKit.Net.Smtp; +using MailKit.Security; +using Microsoft.Extensions.Configuration; +using MimeKit; + +namespace ExpenseTracker.Infrastructure.Email; + +public class EmailSenderService : IEmailSenderService +{ + private readonly IConfiguration _configuration; + + public EmailSenderService(IConfiguration configuration) + { + _configuration = configuration; + } + + public async Task SendAsync( + ICollection recipientAddresses, + string subject, + string message, + CancellationToken cancellationToken) + { + var smtpClientHost = _configuration.GetSection("Email").GetValue("Host"); + var smtpClientPort = _configuration.GetSection("Email").GetValue("Port"); + + var smtpClientUsername = _configuration.GetSection("Email").GetValue("Username"); + var smtpClientPassword = _configuration.GetSection("Email").GetValue("Password"); + + var fromAddres = _configuration.GetSection("Email").GetValue("SenderAddress");; + var fromName = _configuration.GetSection("Email").GetValue("SenderName");; + + var subj = subject; + var body = message; + + + var msg = new MimeMessage(); + + msg.From.Add(new MailboxAddress(fromName, fromAddres)); + + foreach (var address in recipientAddresses) + { + msg.To.Add(new MailboxAddress("", address)); + } + + msg.Subject = subj; + + msg.Body = new TextPart("plain") + { + Text = body + }; + + + using (var client = new SmtpClient()) + { + await client.ConnectAsync(smtpClientHost, smtpClientPort, SecureSocketOptions.SslOnConnect, cancellationToken); + await client.AuthenticateAsync(smtpClientUsername, smtpClientPassword, cancellationToken); + await client.SendAsync(msg, cancellationToken); + await client.DisconnectAsync(true, cancellationToken); + } + } +} diff --git a/ExpenseTracker.Infrastructure/ExpenseTracker.Infrastructure.csproj b/ExpenseTracker.Infrastructure/ExpenseTracker.Infrastructure.csproj new file mode 100644 index 0000000..9fd514d --- /dev/null +++ b/ExpenseTracker.Infrastructure/ExpenseTracker.Infrastructure.csproj @@ -0,0 +1,22 @@ + + + + net8.0 + enable + enable + + + + + + + + + + + + + + + + diff --git a/ExpenseTracker.Infrastructure/Identity/IdentitySeeder.cs b/ExpenseTracker.Infrastructure/Identity/IdentitySeeder.cs new file mode 100644 index 0000000..130f8aa --- /dev/null +++ b/ExpenseTracker.Infrastructure/Identity/IdentitySeeder.cs @@ -0,0 +1,114 @@ +using Microsoft.AspNetCore.Identity; +using Microsoft.Extensions.DependencyInjection; +using ExpenseTracker.Application.Common.Models; +using ExpenseTracker.Infrastructure.Identity.Models; + +namespace ExpenseTracker.Infrastructure.Identity; + +public static class IdentitySeeder +{ + private static UserManager _userManager; + private static RoleManager _roleManager; + + public static void SeedIdentity(IServiceScope serviceScope) + { + _userManager = serviceScope.ServiceProvider.GetService>(); + _userManager.UserValidators.Clear(); + _userManager.PasswordValidators.Clear(); + + _roleManager = serviceScope.ServiceProvider.GetService>(); + _roleManager.RoleValidators.Clear(); + + SeedRoles(); + SeedUsers(); + } + + private static void SeedRoles() + { + var roles = Enum.GetValues(typeof(IdentityRoles)).Cast(); + + foreach (var role in roles) + { + var roleName = role.ToString(); + + var roleExists = _roleManager.RoleExistsAsync(roleName).GetAwaiter().GetResult(); + + if (roleExists) + { + continue; + } + + _roleManager.CreateAsync(new ApplicationRole() + { + Id = Guid.NewGuid().ToString(), + Name = roleName, + ConcurrencyStamp = Guid.NewGuid().ToString("D") + }).GetAwaiter().GetResult(); + } + } + + private static void SeedUsers() + { + var user = new ApplicationUser + { + Id = Guid.NewGuid().ToString(), + Email = "user", + NormalizedEmail = "user", + EmailConfirmed = true, + SecurityStamp = Guid.NewGuid().ToString("D"), + Roles = _roleManager.Roles.Where(r => r.Name == IdentityRoles.User.ToString()).Select(r => r.Id).ToList(), + RefreshTokens = new RefreshToken[0] + }; + + var userExists = _userManager.FindByEmailAsync(user.Email).Result is not null; + if (!userExists) + { + var hashed = _userManager.PasswordHasher.HashPassword(user, "user"); + user.PasswordHash = hashed; + _userManager.CreateAsync(user); + } + + + + var admin = new ApplicationUser + { + Id = Guid.NewGuid().ToString(), + Email = "admin", + NormalizedEmail = "admin", + EmailConfirmed = true, + SecurityStamp = Guid.NewGuid().ToString("D"), + Roles = _roleManager.Roles.Where(r => r.Name == IdentityRoles.Administrator.ToString()).Select(r => r.Id).ToList(), + RefreshTokens = new RefreshToken[0] + }; + + userExists = _userManager.FindByEmailAsync(admin.Email).Result is not null; + if (!userExists) + { + var hashed = _userManager.PasswordHasher.HashPassword(admin, "admin"); + admin.PasswordHash = hashed; + _userManager.CreateAsync(admin); + _userManager.AddToRoleAsync(admin, IdentityRoles.Administrator.ToString()); + } + + + + var adminUser = new ApplicationUser + { + Id = Guid.NewGuid().ToString(), + Email = "adminUser", + NormalizedEmail = "ADMINUSER", + EmailConfirmed = true, + SecurityStamp = Guid.NewGuid().ToString("D"), + Roles = _roleManager.Roles.Where(r => r.Name == IdentityRoles.Administrator.ToString() || r.Name == IdentityRoles.User.ToString()).Select(r => r.Id).ToList(), + RefreshTokens = new RefreshToken[0] + }; + + userExists = _userManager.FindByEmailAsync(adminUser.Email).Result is not null; + if (!userExists) + { + var hashed = _userManager.PasswordHasher.HashPassword(adminUser, "adminUser"); + adminUser.PasswordHash = hashed; + _userManager.CreateAsync(adminUser); + } + } +} diff --git a/ExpenseTracker.Infrastructure/Identity/Models/ApplicationRole.cs b/ExpenseTracker.Infrastructure/Identity/Models/ApplicationRole.cs new file mode 100644 index 0000000..f48d498 --- /dev/null +++ b/ExpenseTracker.Infrastructure/Identity/Models/ApplicationRole.cs @@ -0,0 +1,5 @@ +using AspNetCore.Identity.Mongo.Model; + +namespace ExpenseTracker.Infrastructure.Identity.Models; + +public class ApplicationRole : MongoRole { } diff --git a/ExpenseTracker.Infrastructure/Identity/Models/ApplicationUser.cs b/ExpenseTracker.Infrastructure/Identity/Models/ApplicationUser.cs new file mode 100644 index 0000000..22a82d9 --- /dev/null +++ b/ExpenseTracker.Infrastructure/Identity/Models/ApplicationUser.cs @@ -0,0 +1,8 @@ +using AspNetCore.Identity.Mongo.Model; + +namespace ExpenseTracker.Infrastructure.Identity.Models; + +public class ApplicationUser : MongoUser +{ + public ICollection> RefreshTokens { get; set; } = null!; +} diff --git a/ExpenseTracker.Infrastructure/Identity/Models/RefreshToken.cs b/ExpenseTracker.Infrastructure/Identity/Models/RefreshToken.cs new file mode 100644 index 0000000..d7e1210 --- /dev/null +++ b/ExpenseTracker.Infrastructure/Identity/Models/RefreshToken.cs @@ -0,0 +1,20 @@ +namespace ExpenseTracker.Infrastructure.Identity.Models; + +public class RefreshToken where TKey : IEquatable +{ + public TKey Id { get; set; } = default!; + + public string Value { get; set; } = null!; + + public DateTime CreationDateTimeUtc { get; set; } + + public DateTime ExpirationDateTimeUtc { get; set; } + + public DateTime? RevokationDateTimeUtc { get; set; } + + public bool IsExpired => DateTime.UtcNow >= ExpirationDateTimeUtc; + + public bool IsActive => RevokationDateTimeUtc is null && !IsExpired; + + public TKey? ApplicationUserId { get; set; } +} diff --git a/ExpenseTracker.Infrastructure/Identity/Services/AuthenticationService.cs b/ExpenseTracker.Infrastructure/Identity/Services/AuthenticationService.cs new file mode 100644 index 0000000..1f58a32 --- /dev/null +++ b/ExpenseTracker.Infrastructure/Identity/Services/AuthenticationService.cs @@ -0,0 +1,251 @@ +using System.IdentityModel.Tokens.Jwt; +using System.Security.Claims; +using System.Security.Cryptography; +using System.Text; +using Microsoft.AspNetCore.Identity; +using Microsoft.Extensions.Configuration; +using Microsoft.IdentityModel.Tokens; +using ExpenseTracker.Application.Common.Exceptions; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Application.Common.Models; +using ExpenseTracker.Application.Authentication; +using ExpenseTracker.Infrastructure.Identity.Models; + +namespace ExpenseTracker.Infrastructure.Identity.Services; + +public class AuthenticationService : IAuthenticationService +{ + private readonly IConfiguration _configuration; + private readonly UserManager _userManager; + private readonly RoleManager _roleManager; + private readonly IEmailSenderService _emailSenderService; + + public AuthenticationService( + IConfiguration configuration, + UserManager userManager, + RoleManager roleManager, + IEmailSenderService emailSenderService) + { + _userManager = userManager; + _userManager.UserValidators.Clear(); + _userManager.PasswordValidators.Clear(); + + _roleManager = roleManager; + + _configuration = configuration; + _emailSenderService = emailSenderService; + } + + public async Task RegisterWithEmailAndPasswordAsync(string email, string password, CancellationToken cancellationToken) + { + var userWithSameEmail = await _userManager.FindByEmailAsync(email); + if (userWithSameEmail is not null) + { + throw new RegistrationException("User with given email already registered."); + } + + var roles = _roleManager.Roles + .Where(r => r.Name == IdentityRoles.User.ToString()) + .Select(r => r.Id) + .ToList(); + + var newUser = new ApplicationUser + { + Id = Guid.NewGuid().ToString(), + Email = email, + Roles = roles, + RefreshTokens = new RefreshToken[0] + }; + + var createUserResult = await _userManager.CreateAsync(newUser, password); + + if (createUserResult.Errors.Any()) + { + throw new Exception(); + } + } + + public async Task RegisterWithEmailAsync(string email, CancellationToken cancellationToken) + { + var userWithSameEmail = await _userManager.FindByEmailAsync(email); + if (userWithSameEmail is not null) + { + throw new RegistrationException("User with given email already registered."); + } + + var roles = _roleManager.Roles + .Where(r => r.Name == IdentityRoles.User.ToString()) + .Select(r => r.Id) + .ToList(); + + var newUser = new ApplicationUser + { + Id = Guid.NewGuid().ToString(), + Email = email, + EmailConfirmed = true, + Roles = roles, + RefreshTokens =new RefreshToken[0] + }; + + var randomPassword = GenerateRandomPassword(16); + var createUserResult = await _userManager.CreateAsync(newUser, randomPassword); + + if (createUserResult.Errors.Any()) + { + throw new Exception(); + } + + await _emailSenderService.SendAsync( + new string[] { email }, + "Expense Tracker Account Registration", + $"Account registered successfuly.\n\n" + + $"Your login credentials are:\n" + + $" - email: {email}\n" + + $" - password: {randomPassword}\n\n" + + $"Do not worry if you did not register the account." + + " All accounts without activity are being cleaned up periodically.", + cancellationToken); + + string GenerateRandomPassword(int length) + { + string allowedCharacters = + "abcdefghijklmnopqrstuvwxyz" + + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + + "1234567890" + + "`-=~!@#$%^&*()_+" + + "[]{};:',<.>/?|\\\""; + + var rng = new Random(DateTime.UtcNow.Microsecond); + var sb = new StringBuilder(); + int randomIndex; + + for (int i = 0; i < length; i++) + { + randomIndex = rng.Next(allowedCharacters.Length); + sb.Append(allowedCharacters[randomIndex]); + } + + return sb.ToString(); + } + } + + public async Task LoginAsync(string email, string password, CancellationToken cancellationToken) + { + var user = await _userManager.FindByEmailAsync(email); + if (user is null) + { + throw new LoginException("No users registered with given email."); + } + + var isPasswordCorrect = await _userManager.CheckPasswordAsync(user, password); + if (!isPasswordCorrect) + { + throw new LoginException("Given password is incorrect."); + } + + var jwtSecurityToken = await CreateJwtAsync(user, cancellationToken); + var accessToken = new JwtSecurityTokenHandler().WriteToken(jwtSecurityToken); + + var refreshToken = user.RefreshTokens.FirstOrDefault(t => t.IsActive); + if (refreshToken is null) + { + refreshToken = CreateRefreshToken(); + refreshToken.ApplicationUserId = user.Id; + user.RefreshTokens.Add(refreshToken); + var result = await _userManager.UpdateAsync(user); + } + + return new TokensModel(accessToken, refreshToken.Value); + } + + public async Task RenewAccessTokenAsync(string refreshToken, CancellationToken cancellationToken) + { + var user = _userManager.Users.SingleOrDefault(u => u.RefreshTokens.Any(rt => rt.Value == refreshToken)); + if (user is null) + { + throw new RenewAccessTokenException($"Refresh token {refreshToken} was not found."); + } + + var refreshTokenObject = user.RefreshTokens.Single(rt => rt.Value == refreshToken); + if (!refreshTokenObject.IsActive) + { + throw new RenewAccessTokenException("Refresh token is inactive."); + } + + var jwtSecurityToken = await CreateJwtAsync(user, cancellationToken); + var accessToken = new JwtSecurityTokenHandler().WriteToken(jwtSecurityToken); + + return new TokensModel(accessToken, refreshToken); + } + + public async Task RevokeRefreshTokenAsync(string refreshToken, CancellationToken cancellationToken) + { + var user = _userManager.Users.SingleOrDefault(u => u.RefreshTokens.Any(t => t.Value == refreshToken)); + if (user is null) + { + throw new RevokeRefreshTokenException("Invalid refreshToken"); + } + + var refreshTokenObject = user.RefreshTokens.Single(x => x.Value == refreshToken); + if (!refreshTokenObject.IsActive) + { + throw new RevokeRefreshTokenException("RefreshToken already revoked"); + } + + refreshTokenObject.RevokationDateTimeUtc = DateTime.UtcNow; + await _userManager.UpdateAsync(user); + } + + private async Task CreateJwtAsync(ApplicationUser user, CancellationToken cancellationToken) + { + var userClaims = await _userManager.GetClaimsAsync(user); + + var roles = await _userManager.GetRolesAsync(user); + var roleClaims = new List(); + foreach (var role in roles) + { + roleClaims.Add(new Claim("roles", role)); + } + + var claims = new List() + { + new Claim(JwtRegisteredClaimNames.Sub, user.Id.ToString()), + new Claim(JwtRegisteredClaimNames.Email, user.Email) + } + .Union(userClaims) + .Union(roleClaims); + + var validityInMinutes = Double.Parse(_configuration["Jwt:AccessTokenValidityInMinutes"]); + var expirationDateTimeUtc = DateTime.UtcNow.AddMinutes(validityInMinutes); + + var symmetricSecurityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["Jwt:IssuerSigningKey"])); + var signingCredentials = new SigningCredentials(symmetricSecurityKey, SecurityAlgorithms.HmacSha256); + + var jwtSecurityToken = new JwtSecurityToken( + issuer: _configuration["Jwt:Issuer"], + audience: _configuration["Jwt:Audience"], + claims: claims, + expires: expirationDateTimeUtc, + signingCredentials: signingCredentials); + + return jwtSecurityToken; + } + + private RefreshToken CreateRefreshToken() + { + var randomNumber = new byte[32]; + + using var rng = RandomNumberGenerator.Create(); + rng.GetNonZeroBytes(randomNumber); + + var validityInDays = Double.Parse(_configuration["Jwt:RefreshTokenValidityInDays"]); + + return new RefreshToken + { + Id = Guid.NewGuid().ToString(), + Value = Convert.ToBase64String(randomNumber), + CreationDateTimeUtc = DateTime.UtcNow, + ExpirationDateTimeUtc = DateTime.UtcNow.AddDays(validityInDays) + }; + } +} diff --git a/ExpenseTracker.Infrastructure/Services/CurrencyConverterService.cs b/ExpenseTracker.Infrastructure/Services/CurrencyConverterService.cs new file mode 100644 index 0000000..1ec1d86 --- /dev/null +++ b/ExpenseTracker.Infrastructure/Services/CurrencyConverterService.cs @@ -0,0 +1,201 @@ +using System.Diagnostics; +using Microsoft.Extensions.Configuration; +using Microsoft.Extensions.Logging; +using Newtonsoft.Json; +using Newtonsoft.Json.Serialization; +using ExpenseTracker.Application.Common.Exceptions; +using ExpenseTracker.Application.Common.Interfaces.Services; +using ExpenseTracker.Domain.Enums; + +namespace ExpenseTracker.Infrastructure.Services; + +public sealed class CurrencyConverterService : ICurrencyConverterService +{ + private readonly ILogger _logger; + private readonly HttpClient _httpClient; + private readonly string? _apiKey; + + private readonly JsonSerializerSettings _jsonSerializerSettings = new JsonSerializerSettings() + { + ContractResolver = new CamelCasePropertyNamesContractResolver() + }; + + private Dictionary> exchangeRateCache; + + public CurrencyConverterService( + ILogger logger, + IHttpClientFactory httpClientFactory, + IConfiguration configuration) + { + _logger = logger; + _httpClient = httpClientFactory.CreateClient("CurrencyConverterService"); + _apiKey = configuration.GetSection("FreeCurrencyAPI").GetValue("ApiKey"); + + InitializeCache(); + } + + public async Task GetLatestExchangeRate( + Currency fromCurrency, + Currency toCurrency, + CancellationToken cancellationToken) + { + if (fromCurrency.Equals(toCurrency)) + { + return 1.0; + } + + var currentDate = DateOnly.FromDateTime(DateTime.UtcNow); + + if (TryGetExchangeRateFromCache(currentDate, fromCurrency, toCurrency, out double? result)) + { + return (double)result; + } + + HttpResponseMessage? response; + + try + { + response = await _httpClient.GetAsync( + $"v1/latest" + + $"?apikey={_apiKey}" + + $"&base_currency={fromCurrency.ToString()}" + + $"¤cies={toCurrency.ToString()}", + cancellationToken); + + response.EnsureSuccessStatusCode(); + } + catch (HttpRequestException exception) + { + _logger.LogError($"{exception.Message}\n{exception.StackTrace}"); + throw new CurrencyConverterException(exception.Message); + } + + var json = await response.Content.ReadAsStringAsync(cancellationToken); + + _logger.LogDebug( + "{@DateUtc} {@TimeUtc} {@TraceId} {@SpanId} Received data: {@data}", + DateTime.UtcNow.ToString("yyyy-MM-dd"), + DateTime.UtcNow.ToString("HH:mm:ss.FFF"), + Activity.Current?.TraceId.ToString(), + Activity.Current?.SpanId.ToString(), + json); + + dynamic deserealizedObject = JsonConvert.DeserializeObject(json); + + var exchangeRate = (double)deserealizedObject["data"][toCurrency.ToString()]; + + AddToCache(currentDate, fromCurrency, toCurrency, exchangeRate); + + return exchangeRate; + } + + public async Task GetHistoricalExchangeRate( + Currency fromCurrency, + Currency toCurrency, + DateOnly date, + CancellationToken cancellationToken) + { + { + if (fromCurrency.Equals(toCurrency)) + return 1.0; + } + + if (TryGetExchangeRateFromCache(date, fromCurrency, toCurrency, out double? result)) + { + return (double)result; + } + + HttpResponseMessage? response; + + try + { + response = await _httpClient.GetAsync( + $"v1/historical" + + $"?apikey={_apiKey}" + + $"&base_currency={fromCurrency.ToString()}" + + $"¤cies={toCurrency.ToString()}" + + $"&date={date.ToString("yyyy-MM-dd")}", + cancellationToken); + + response.EnsureSuccessStatusCode(); + } + catch (HttpRequestException exception) + { + _logger.LogError($"{exception.Message}\n{exception.StackTrace}"); + throw new CurrencyConverterException(exception.Message); + } + + var json = await response.Content.ReadAsStringAsync(cancellationToken); + + _logger.LogDebug( + "{@DateUtc} {@TimeUtc} {@TraceId} {@SpanId} Received data: {@data}", + DateTime.UtcNow.ToString("yyyy-MM-dd"), + DateTime.UtcNow.ToString("HH:mm:ss.FFF"), + Activity.Current?.TraceId.ToString(), + Activity.Current?.SpanId.ToString(), + json); + + dynamic deserealizedObject = JsonConvert.DeserializeObject(json); + + var exchangeRate = (double)deserealizedObject["data"][date.ToString("yyyy-MM-dd")][toCurrency.ToString()]; + + AddToCache(date, fromCurrency, toCurrency, exchangeRate); + + return exchangeRate; + } + + private void InitializeCache() + { + exchangeRateCache = new Dictionary>(); + } + + private void AddToCache(DateOnly date, Currency fromCurrency, Currency toCurrency, double exchangeRate) + { + if (!exchangeRateCache.ContainsKey(date)) + { + var newDict = new Dictionary<(Currency, Currency), double>(); + exchangeRateCache.Add(date, newDict); + } + + if (!exchangeRateCache[date].ContainsKey((fromCurrency, toCurrency))) + { + exchangeRateCache[date].Add((fromCurrency, toCurrency), exchangeRate); + + _logger.LogDebug( + "{@DateUtc} {@TimeUtc} {@TraceId} {@SpanId} Add data to cache: {@Date} {@FromCurrency} -> {@ToCurrency} {@ExchangeRate}", + DateTime.UtcNow.ToString("yyyy-MM-dd"), + DateTime.UtcNow.ToString("HH:mm:ss.FFF"), + Activity.Current?.TraceId.ToString(), + Activity.Current?.SpanId.ToString(), + date, + fromCurrency, + toCurrency, + exchangeRate); + } + } + + private bool TryGetExchangeRateFromCache(DateOnly date, Currency fromCurrency, Currency toCurrency, out double? exchangeRate) + { + if (exchangeRateCache.ContainsKey(date) && + exchangeRateCache[date].ContainsKey((fromCurrency, toCurrency))) + { + exchangeRate = exchangeRateCache[date][(fromCurrency, toCurrency)]; + + _logger.LogDebug( + "{@DateUtc} {@TimeUtc} {@TraceId} {@SpanId} Returned value from cache: {@Date} {@FromCurrency} -> {@ToCurrency} {@Value}", + DateTime.UtcNow.ToString("yyyy-MM-dd"), + DateTime.UtcNow.ToString("HH:mm:ss.FFF"), + Activity.Current?.TraceId.ToString(), + Activity.Current?.SpanId.ToString(), + date, + fromCurrency, + toCurrency, + exchangeRate); + + return true; + } + + exchangeRate = null; + return false; + } +} diff --git a/ExpenseTracker.Persistence/DependencyInjection.cs b/ExpenseTracker.Persistence/DependencyInjection.cs new file mode 100644 index 0000000..b66b964 --- /dev/null +++ b/ExpenseTracker.Persistence/DependencyInjection.cs @@ -0,0 +1,68 @@ +using Microsoft.EntityFrameworkCore; +using Microsoft.Extensions.Configuration; +using Microsoft.Extensions.DependencyInjection; +using MongoDB.Bson.Serialization; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Domain.Entities; +using ExpenseTracker.Persistence.MongoDb; +using ExpenseTracker.Persistence.PostgreSQL; +using ExpenseTracker.Persistence.MongoDb.Repositories; +using ExpenseTracker.Persistence.Serializers; +using ExpenseTracker.Persistence.PostgreSQL.Repositories; +using ExpenseTracker.Application.Common.Interfaces; + +namespace ExpenseTracker.Persistence; + +public static class DependencyInjection +{ + public static IServiceCollection AddPersistence(this IServiceCollection services, IConfiguration configuration) + { + var databaseName = configuration["Database:Type"]; + + if (databaseName.Equals("mongodb")) + { + services.AddMongoDb(); + return services; + } + + if (databaseName.Equals("postgresql")) + { + services.AddPostgreSQL(configuration); + return services; + } + + // TODO: Refactor to use database type enum + + throw new ArgumentException( + $"Unsupported database type specified in configuration. " + + $"Supported types: mongodb postgresql"); + } + + private static IServiceCollection AddMongoDb(this IServiceCollection services) + { + BsonSerializer.RegisterSerializer(new AccountSerializer()); + BsonSerializer.RegisterSerializer(new TransactionSerializer()); + + services.AddScoped(); + services.AddScoped(); + services.AddScoped(); + services.AddScoped(); + + return services; + } + + private static IServiceCollection AddPostgreSQL(this IServiceCollection services, IConfiguration configuration) + { + services.AddDbContext(options => + { + options.UseNpgsql(configuration["Database:ConnectionString"]); + }); + + services.AddScoped(); + + // services.AddScoped(); + // services.AddScoped(); + + return services; + } +} diff --git a/ExpenseTracker.Persistence/ExpenseTracker.Persistence.csproj b/ExpenseTracker.Persistence/ExpenseTracker.Persistence.csproj new file mode 100644 index 0000000..fc52ef1 --- /dev/null +++ b/ExpenseTracker.Persistence/ExpenseTracker.Persistence.csproj @@ -0,0 +1,27 @@ + + + + net8.0 + enable + enable + + + + + + + + + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + + + + + + diff --git a/ExpenseTracker.Persistence/MongoDb/MongoDbContext.cs b/ExpenseTracker.Persistence/MongoDb/MongoDbContext.cs new file mode 100644 index 0000000..aaf2a92 --- /dev/null +++ b/ExpenseTracker.Persistence/MongoDb/MongoDbContext.cs @@ -0,0 +1,115 @@ +using System.Diagnostics; +using Microsoft.Extensions.Configuration; +using Microsoft.Extensions.Logging; +using MongoDB.Bson; +using MongoDB.Driver; +using MongoDB.Driver.Core.Events; + +namespace ExpenseTracker.Persistence.MongoDb; + +public class MongoDbContext : IDisposable +{ + private IMongoDatabase Database { get; set; } + private MongoClient Client { get; set; } + public IClientSessionHandle Session { get; private set; } + + private readonly List> _commands; + + public MongoDbContext(IConfiguration configuration, ILogger logger) + { + var settings = new MongoClientSettings(); + + settings.ClusterConfigurator = cb => + { + cb.Subscribe(e => + { + logger.LogDebug( + "{@DateUtc} {@TimeUtc} {@TraceId} {@SpanId} Starting performing MongoDB command {@CommandName}.\nQuery: {@Query}.", + DateTime.UtcNow.ToString("yyyy-MM-dd"), + DateTime.UtcNow.ToString("HH:mm:ss.FFF"), + Activity.Current?.TraceId.ToString(), + Activity.Current?.SpanId.ToString(), + e.CommandName, + e.Command.ToString()); + }); + cb.Subscribe(e => + { + logger.LogCritical( + "{@DateUtc} {@TimeUtc} {@TraceId} {@SpanId} MongoDB command {@CommandName} failed with exception {@Exception}.", + DateTime.UtcNow.ToString("yyyy-MM-dd"), + DateTime.UtcNow.ToString("HH:mm:ss.FFF"), + Activity.Current?.TraceId.ToString(), + Activity.Current?.SpanId.ToString(), + e.CommandName, + e.Failure); + }); + cb.Subscribe(e => + { + logger.LogDebug( + "{@DateUtc} {@TimeUtc} {@TraceId} {@SpanId} Finished performing MongoDB command {@CommandName} in {@DurationInSeconds} seconds.", + DateTime.UtcNow.ToString("yyyy-MM-dd"), + DateTime.UtcNow.ToString("HH:mm:ss.FFF"), + Activity.Current?.TraceId.ToString(), + Activity.Current?.SpanId.ToString(), + e.CommandName, + e.Duration.TotalSeconds); + }); + }; + + settings.Server = new MongoServerAddress(configuration["Database:ConnectionString"].Split(':')[0]); + + Client = new MongoClient(settings); + Database = Client.GetDatabase(configuration["Database:DomainPartitionName"]); + + _commands = new List>(); + } + + public async Task SaveAsync(CancellationToken cancellationToken) + { + // Console.WriteLine($"\n\n\n{_commands.Count}\n\n\n"); + // if (_commands.Count == 1) + // { + // var task = _commands.First(); + // await task(); + // + // return 1; + // } + + using (Session = await Client.StartSessionAsync()) + { + Session.StartTransaction(); + + try + { + var commandTasks = _commands.Select(c => c()); + + await Task.WhenAll(commandTasks); + } + catch (Exception) + { + await Session.AbortTransactionAsync(cancellationToken); + throw; + } + + await Session.CommitTransactionAsync(cancellationToken); + } + + return _commands.Count; + } + + public IMongoCollection GetCollection(string name) + { + return Database.GetCollection(name); + } + + public void AddCommand(Func command) + { + _commands.Add(command); + } + + public void Dispose() + { + Session?.Dispose(); + GC.SuppressFinalize(this); + } +} diff --git a/ExpenseTracker.Persistence/MongoDb/MongoDbUnitOfWork.cs b/ExpenseTracker.Persistence/MongoDb/MongoDbUnitOfWork.cs new file mode 100644 index 0000000..5f1fc6c --- /dev/null +++ b/ExpenseTracker.Persistence/MongoDb/MongoDbUnitOfWork.cs @@ -0,0 +1,47 @@ +using ExpenseTracker.Application.Common.Interfaces; +using ExpenseTracker.Application.Common.Interfaces.Repositories; + +namespace ExpenseTracker.Persistence.MongoDb; + +public class MongoDbUnitOfWork : IUnitOfWork +{ + private MongoDbContext _dbContext; + + public MongoDbUnitOfWork( + MongoDbContext dbContext, + IAccountRepository accountRepository, + ITransactionRepository transactionRepository) + { + _dbContext = dbContext; + + AccountRepository = accountRepository; + TransactionRepository = transactionRepository; + } + + public IAccountRepository AccountRepository { get; init; } + public ITransactionRepository TransactionRepository { get; init; } + + public int Save() + { + return _dbContext.SaveAsync(CancellationToken.None).Result; + } + + public async Task SaveAsync(CancellationToken cancellationToken) + { + return await _dbContext.SaveAsync(cancellationToken); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + public void Dispose(bool disposing) + { + if (disposing) + { + _dbContext.Dispose(); + } + } +} diff --git a/ExpenseTracker.Persistence/MongoDb/Repositories/AccountMongoDbRepository.cs b/ExpenseTracker.Persistence/MongoDb/Repositories/AccountMongoDbRepository.cs new file mode 100644 index 0000000..38d1518 --- /dev/null +++ b/ExpenseTracker.Persistence/MongoDb/Repositories/AccountMongoDbRepository.cs @@ -0,0 +1,11 @@ +using MongoDB.Driver; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Domain.Entities; + +namespace ExpenseTracker.Persistence.MongoDb.Repositories; + +public sealed class AccountMongoDbRepository : BaseMongoDbRepository, IAccountRepository +{ + public AccountMongoDbRepository(MongoDbContext mongoDbContext) + : base(mongoDbContext, "accounts") { } +} diff --git a/ExpenseTracker.Persistence/MongoDb/Repositories/BaseMongoDbRepository.cs b/ExpenseTracker.Persistence/MongoDb/Repositories/BaseMongoDbRepository.cs new file mode 100644 index 0000000..66060c9 --- /dev/null +++ b/ExpenseTracker.Persistence/MongoDb/Repositories/BaseMongoDbRepository.cs @@ -0,0 +1,68 @@ +using System.Linq.Expressions; +using MongoDB.Driver; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Domain.Entities; + +namespace ExpenseTracker.Persistence.MongoDb.Repositories; + +public abstract class BaseMongoDbRepository : IBaseRepository + where TKey : IEquatable + where TEntity : EntityBase +{ + protected readonly MongoDbContext _dbContext; + protected IMongoCollection _collection; + + public BaseMongoDbRepository(MongoDbContext dbContext, string collectionName) + { + _dbContext = dbContext; + _collection = _dbContext.GetCollection(collectionName); + } + + public IQueryable Queryable => _collection.AsQueryable(); + + public async Task AddOneAsync(TEntity entity, CancellationToken cancellationToken) + { + _dbContext.AddCommand(() => + _collection.InsertOneAsync(entity, null, cancellationToken) + ); + + return entity; + } + + public async Task> AddManyAsync(IEnumerable entities, CancellationToken cancellationToken) + { + _dbContext.AddCommand( + () => _collection.InsertManyAsync(entities, null, cancellationToken) + ); + + return entities; + } + + + public async Task UpdateOneAsync(TEntity entity, CancellationToken cancellationToken) + { + _dbContext.AddCommand(() => + _collection.ReplaceOneAsync( + _dbContext.Session, + e => e.Id.Equals(entity.Id), + entity, new ReplaceOptions(), + cancellationToken) + ); + + return entity; + } + + public async Task DeleteOneAsync(TKey id, CancellationToken cancellationToken) + { + _dbContext.AddCommand(() => + _collection.DeleteOneAsync(_dbContext.Session, e => e.Id.Equals(id), null, cancellationToken) + ); + } + + public async Task DeleteManyAsync(Expression> predicate, CancellationToken cancellationToken) + { + _dbContext.AddCommand(() => + _collection.DeleteManyAsync(_dbContext.Session, predicate, null, cancellationToken) + ); + } +} diff --git a/ExpenseTracker.Persistence/MongoDb/Repositories/TransactionMongoDbRepository.cs b/ExpenseTracker.Persistence/MongoDb/Repositories/TransactionMongoDbRepository.cs new file mode 100644 index 0000000..02c5539 --- /dev/null +++ b/ExpenseTracker.Persistence/MongoDb/Repositories/TransactionMongoDbRepository.cs @@ -0,0 +1,11 @@ +using MongoDB.Driver; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Domain.Entities; + +namespace ExpenseTracker.Persistence.MongoDb.Repositories; + +public class TransactionMongoDbRepository : BaseMongoDbRepository, ITransactionRepository +{ + public TransactionMongoDbRepository(MongoDbContext mongoDbContext) + : base(mongoDbContext, "transactions") { } +} diff --git a/ExpenseTracker.Persistence/MongoDb/Serializers/AccountSerializer.cs b/ExpenseTracker.Persistence/MongoDb/Serializers/AccountSerializer.cs new file mode 100644 index 0000000..44715d6 --- /dev/null +++ b/ExpenseTracker.Persistence/MongoDb/Serializers/AccountSerializer.cs @@ -0,0 +1,109 @@ +using MongoDB.Bson; +using MongoDB.Bson.IO; +using MongoDB.Bson.Serialization; +using MongoDB.Bson.Serialization.Serializers; +using ExpenseTracker.Domain.Entities; +using ExpenseTracker.Domain.Enums; + +namespace ExpenseTracker.Persistence.Serializers; + +public class AccountSerializer : SerializerBase, IBsonDocumentSerializer +{ + private const string IdDeserializedFieldName = "Id"; + private const string IdSerializedFieldName = "_id"; + + private const string NameDeserializedFieldName = "Name"; + private const string NameSerializedFieldName = "name"; + + private const string DescriptionDeserializedFieldName = "Description"; + private const string DescriptionSerializedFieldName = "description"; + + private const string CurrencyDeserializedFieldName = "Currency"; + private const string CurrencySerializedFieldName = "currency"; + + private const string UserIdDeserializedFieldName = "UserId"; + private const string UserIdSerializedFieldName = "userId"; + + public override Account Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args) + { + context.Reader.ReadStartDocument(); + + var entity = new Account(); + + while (context.Reader.ReadBsonType() != BsonType.EndOfDocument) + { + var fieldName = context.Reader.ReadName(); + + switch (fieldName) + { + case IdSerializedFieldName: + entity.Id = context.Reader.ReadString(); + break; + case NameSerializedFieldName: + entity.Name = context.Reader.ReadString(); + break; + case DescriptionSerializedFieldName: + var description = context.Reader.ReadString(); + entity.Description = description.Equals(String.Empty) ? null : description; + break; + case CurrencySerializedFieldName: + entity.Currency = Currency.FromName(context.Reader.ReadString()); + break; + case UserIdSerializedFieldName: + entity.UserId = context.Reader.ReadString(); + break; + } + } + + context.Reader.ReadEndDocument(); + + return entity; + } + + public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, Account value) + { + context.Writer.WriteStartDocument(); + + context.Writer.WriteString(IdSerializedFieldName, value.Id); + context.Writer.WriteString(NameSerializedFieldName, value.Name); + context.Writer.WriteString(DescriptionSerializedFieldName, value.Description ?? String.Empty); + context.Writer.WriteString(CurrencySerializedFieldName, value.Currency.Name); + context.Writer.WriteString(UserIdSerializedFieldName, value.UserId); + + context.Writer.WriteEndDocument(); + } + + public bool TryGetMemberSerializationInfo(string memberName, out BsonSerializationInfo serializationInfo) + { + switch (memberName) + { + case IdDeserializedFieldName: + serializationInfo = new BsonSerializationInfo(IdSerializedFieldName, new StringSerializer(), typeof(string)); + return true; + case NameDeserializedFieldName: + serializationInfo = new BsonSerializationInfo(NameSerializedFieldName, new StringSerializer(), typeof(string)); + return true; + case DescriptionDeserializedFieldName: + serializationInfo = new BsonSerializationInfo(DescriptionSerializedFieldName, new StringSerializer(), typeof(string)); + return true; + case CurrencyDeserializedFieldName: + serializationInfo = new BsonSerializationInfo(CurrencySerializedFieldName, new CurrencySerializer(), typeof(Currency)); + return true; + case UserIdDeserializedFieldName: + serializationInfo = new BsonSerializationInfo(UserIdSerializedFieldName, new StringSerializer(), typeof(string)); + return true; + default: + serializationInfo = null; + return false; + } + } +} + +public class CurrencySerializer : SerializerBase +{ + public override Currency Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args) + { + var name = context.Reader.ReadString(); + return Currency.FromName(name); + } +} diff --git a/ExpenseTracker.Persistence/MongoDb/Serializers/TransactionSerializer.cs b/ExpenseTracker.Persistence/MongoDb/Serializers/TransactionSerializer.cs new file mode 100644 index 0000000..afba032 --- /dev/null +++ b/ExpenseTracker.Persistence/MongoDb/Serializers/TransactionSerializer.cs @@ -0,0 +1,110 @@ +using MongoDB.Bson; +using MongoDB.Bson.IO; +using MongoDB.Bson.Serialization; +using MongoDB.Bson.Serialization.Serializers; +using ExpenseTracker.Domain.Entities; +using ExpenseTracker.Domain.Enums; + +namespace ExpenseTracker.Persistence.Serializers; + +public class TransactionSerializer : SerializerBase, IBsonDocumentSerializer +{ + private const string IdDeserializedFieldName = "Id"; + private const string IdSerializedFieldName = "_id"; + + private const string AmountDeserializedFieldName = "Amount"; + private const string AmountSerializedFieldName = "amount"; + + private const string CategoryDeserializedFieldName = "Category"; + private const string CategorySerializedFieldName = "category"; + + private const string TimeDeserializedFieldName = "Time"; + private const string TimeSerializedFieldName = "time"; + + private const string DescriptionDeserializedFieldName = "Description"; + private const string DescriptionSerializedFieldName = "description"; + + private const string AccountIdDeserializedFieldName = "AccountId"; + private const string AccountIdSerializedFieldName = "accountId"; + + public override Transaction Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args) + { + context.Reader.ReadStartDocument(); + + var entity = new Transaction(); + + while (context.Reader.ReadBsonType() != BsonType.EndOfDocument) + { + var fieldName = context.Reader.ReadName(); + + switch (fieldName) + { + case IdSerializedFieldName: + entity.Id = context.Reader.ReadString(); + break; + case AmountSerializedFieldName: + entity.Amount = context.Reader.ReadDouble(); + break; + case CategorySerializedFieldName: + entity.Category = Category.FromName(context.Reader.ReadString()); + break; + case TimeSerializedFieldName: + entity.Time = DateTimeOffset.FromUnixTimeMilliseconds(context.Reader.ReadDateTime()); + break; + case DescriptionSerializedFieldName: + var description = context.Reader.ReadString(); + entity.Description = description.Equals(String.Empty) ? null : description; + break; + case AccountIdSerializedFieldName: + entity.AccountId = context.Reader.ReadString(); + break; + } + } + + context.Reader.ReadEndDocument(); + + return entity; + } + + public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, Transaction value) + { + context.Writer.WriteStartDocument(); + + context.Writer.WriteString(IdSerializedFieldName, value.Id); + context.Writer.WriteDouble(AmountSerializedFieldName, value.Amount); + context.Writer.WriteString(CategorySerializedFieldName, value.Category.Name); + context.Writer.WriteDateTime(TimeSerializedFieldName, value.Time.ToUnixTimeMilliseconds()); + context.Writer.WriteString(DescriptionSerializedFieldName, value.Description ?? String.Empty); + context.Writer.WriteString(AccountIdSerializedFieldName, value.AccountId); + + context.Writer.WriteEndDocument(); + } + + public bool TryGetMemberSerializationInfo(string memberName, out BsonSerializationInfo serializationInfo) + { + switch (memberName) + { + case IdDeserializedFieldName: + serializationInfo = new BsonSerializationInfo(IdSerializedFieldName, new StringSerializer(), typeof(string)); + return true; + case AmountDeserializedFieldName: + serializationInfo = new BsonSerializationInfo(AmountSerializedFieldName, new DoubleSerializer(), typeof(double)); + return true; + case CategoryDeserializedFieldName: + serializationInfo = new BsonSerializationInfo(CategorySerializedFieldName, new StringSerializer(), typeof(string)); + return true; + case TimeDeserializedFieldName: + serializationInfo = new BsonSerializationInfo(TimeSerializedFieldName, new DateTimeSerializer(), typeof(DateTimeOffset)); + return true; + case DescriptionDeserializedFieldName: + serializationInfo = new BsonSerializationInfo(DescriptionSerializedFieldName, new StringSerializer(), typeof(string)); + return true; + case AccountIdDeserializedFieldName: + serializationInfo = new BsonSerializationInfo(AccountIdSerializedFieldName, new StringSerializer(), typeof(string)); + return true; + default: + serializationInfo = null; + return false; + } + } +} diff --git a/ExpenseTracker.Persistence/PostgreSQL/ApplicationDbContext.cs b/ExpenseTracker.Persistence/PostgreSQL/ApplicationDbContext.cs new file mode 100644 index 0000000..b0223cc --- /dev/null +++ b/ExpenseTracker.Persistence/PostgreSQL/ApplicationDbContext.cs @@ -0,0 +1,26 @@ +using System.Reflection; +using Microsoft.EntityFrameworkCore; +using ExpenseTracker.Domain.Entities; + +namespace ExpenseTracker.Persistence.PostgreSQL; + +public class ApplicationDbContext : DbContext +{ + public ApplicationDbContext(DbContextOptions options) : base(options) { } + + public DbSet Expenses { get => Set(); } + + public DbSet Budgets { get => Set(); } + + protected override void OnModelCreating(ModelBuilder builder) + { + base.OnModelCreating(builder); + + builder.HasDefaultSchema("domain"); + + builder.ApplyConfigurationsFromAssembly( + Assembly.GetExecutingAssembly(), + t => t.Namespace == "ExpenseTracker.Persistence.PostgreSQL.Configurations" + ); + } +} diff --git a/ExpenseTracker.Persistence/PostgreSQL/Configurations/BudgetConfiguration.cs b/ExpenseTracker.Persistence/PostgreSQL/Configurations/BudgetConfiguration.cs new file mode 100644 index 0000000..ca68b78 --- /dev/null +++ b/ExpenseTracker.Persistence/PostgreSQL/Configurations/BudgetConfiguration.cs @@ -0,0 +1,62 @@ +// using Microsoft.EntityFrameworkCore; +// using Microsoft.EntityFrameworkCore.Metadata.Builders; +// using ExpenseTracker.Domain.Entities; +// +// namespace ExpenseTracker.Persistence.PostgreSQL.Configurations; +// +// public class BudgetConfiguration : EntityBaseConfiguration +// { +// public override void Configure(EntityTypeBuilder builder) +// { +// base.Configure(builder); +// +// builder +// .ToTable("budgets") +// .HasKey(e => e.Id); +// +// builder +// .Property(e => e.Amount) +// .HasColumnName("amount") +// .IsRequired(); +// +// builder +// .Property(e => e.Currency) +// .HasColumnName("currency") +// .HasConversion( +// t => t.Name, +// s => Domain.Enums.Currency.FromName(s) +// ) +// .IsRequired(); +// +// builder +// .Property(e => e.Category) +// .HasColumnName("category") +// .HasConversion( +// t => t.Name, +// s => Domain.Enums.Category.FromName(s) +// ) +// .IsRequired(); +// +// builder +// .Property(e => e.FromTime) +// .HasColumnName("from_time") +// .IsRequired(); +// +// builder +// .Property(e => e.ToTime) +// .HasColumnName("to_time") +// .IsRequired(); +// +// builder +// .HasMany(e => e.Expenses) +// .WithOne(e => e.Account) +// .OnDelete(DeleteBehavior.Cascade); +// +// builder +// .Property(e => e.UserId) +// .HasColumnName("fk_budget_user_id") +// .IsRequired(); +// // .OnDelete(DeleteBehavior.Cascade); +// } +// } +// diff --git a/ExpenseTracker.Persistence/PostgreSQL/Configurations/EntityBaseConfiguration.cs b/ExpenseTracker.Persistence/PostgreSQL/Configurations/EntityBaseConfiguration.cs new file mode 100644 index 0000000..4d1292f --- /dev/null +++ b/ExpenseTracker.Persistence/PostgreSQL/Configurations/EntityBaseConfiguration.cs @@ -0,0 +1,20 @@ +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Metadata.Builders; +using ExpenseTracker.Domain.Entities; + +namespace ExpenseTracker.Persistence.PostgreSQL.Configurations; + +public class EntityBaseConfiguration : IEntityTypeConfiguration + where TEntity : EntityBase +{ + public virtual void Configure(EntityTypeBuilder builder) + { + builder + .HasKey(e => e.Id); + + builder + .Property(e => e.Id) + .HasColumnName("id") + .IsRequired(); + } +} diff --git a/ExpenseTracker.Persistence/PostgreSQL/Configurations/ExpenseConfiguration.cs b/ExpenseTracker.Persistence/PostgreSQL/Configurations/ExpenseConfiguration.cs new file mode 100644 index 0000000..a10c7af --- /dev/null +++ b/ExpenseTracker.Persistence/PostgreSQL/Configurations/ExpenseConfiguration.cs @@ -0,0 +1,64 @@ +// using Microsoft.EntityFrameworkCore; +// using Microsoft.EntityFrameworkCore.Metadata.Builders; +// using ExpenseTracker.Domain.Entities; +// +// namespace ExpenseTracker.Persistence.PostgreSQL.Configurations; +// +// public class ExpenseConfiguration : EntityBaseConfiguration +// { +// public override void Configure(EntityTypeBuilder builder) +// { +// base.Configure(builder); +// +// builder +// .ToTable("expenses") +// .HasKey(e => e.Id); +// +// builder +// .Property(e => e.Amount) +// .HasColumnName("amount") +// .IsRequired(); +// +// builder +// .Property(e => e.Currency) +// .HasColumnName("currency") +// .HasConversion( +// t => t.Name, +// s => Domain.Enums.Currency.FromName(s) +// ) +// .IsRequired(); +// +// builder +// .Property(e => e.Category) +// .HasColumnName("category") +// .HasConversion( +// t => t.Name, +// s => Domain.Enums.Category.FromName(s) +// ) +// .IsRequired(); +// +// builder +// .Property(e => e.Time) +// .HasColumnName("time") +// .IsRequired(); +// +// builder +// .Property(e => e.Description) +// .HasColumnName("description") +// .IsRequired(); +// +// builder +// .HasOne(e => e.Account) +// .WithMany(e => e.Expenses) +// .HasForeignKey(e => e.AccountId) +// .HasConstraintName("fk_expense_budget_id") +// .OnDelete(DeleteBehavior.Cascade); +// +// builder +// .Property(e => e.UserId) +// .HasColumnName("fk_expense_user_id") +// .IsRequired(); +// // .OnDelete(DeleteBehavior.Cascade); +// } +// } +// diff --git a/ExpenseTracker.Persistence/PostgreSQL/Migrations/20240408161520_Add_Budgets_and_Expenses_relations.Designer.cs b/ExpenseTracker.Persistence/PostgreSQL/Migrations/20240408161520_Add_Budgets_and_Expenses_relations.Designer.cs new file mode 100644 index 0000000..4d9f6b7 --- /dev/null +++ b/ExpenseTracker.Persistence/PostgreSQL/Migrations/20240408161520_Add_Budgets_and_Expenses_relations.Designer.cs @@ -0,0 +1,129 @@ +// +using System; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Migrations; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using ExpenseTracker.Persistence.PostgreSQL; +using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata; + +#nullable disable + +namespace ExpenseTracker.Persistence.PostgreSQL.Migrations +{ + [DbContext(typeof(ApplicationDbContext))] + [Migration("20240408161520_Add_Budgets_and_Expenses_relations")] + partial class Add_Budgets_and_Expenses_relations + { + /// + protected override void BuildTargetModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder + .HasDefaultSchema("domain") + .HasAnnotation("ProductVersion", "8.0.3") + .HasAnnotation("Relational:MaxIdentifierLength", 63); + + NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder); + + modelBuilder.Entity("ExpenseTracker.Domain.Entities.Budget", b => + { + b.Property("Id") + .HasColumnType("text") + .HasColumnName("id"); + + b.Property("Amount") + .HasColumnType("double precision") + .HasColumnName("amount"); + + b.Property("Category") + .IsRequired() + .HasColumnType("text") + .HasColumnName("category"); + + b.Property("Currency") + .IsRequired() + .HasColumnType("text") + .HasColumnName("currency"); + + b.Property("FromTime") + .HasColumnType("timestamp with time zone") + .HasColumnName("from_time"); + + b.Property("ToTime") + .HasColumnType("timestamp with time zone") + .HasColumnName("to_time"); + + b.Property("UserId") + .IsRequired() + .HasColumnType("text") + .HasColumnName("fk_budget_user_id"); + + b.HasKey("Id"); + + b.ToTable("budgets", "domain"); + }); + + modelBuilder.Entity("ExpenseTracker.Domain.Entities.Expense", b => + { + b.Property("Id") + .HasColumnType("text") + .HasColumnName("id"); + + b.Property("Amount") + .HasColumnType("double precision") + .HasColumnName("amount"); + + b.Property("BudgetId") + .HasColumnType("text"); + + b.Property("Category") + .IsRequired() + .HasColumnType("text") + .HasColumnName("category"); + + b.Property("Currency") + .IsRequired() + .HasColumnType("text") + .HasColumnName("currency"); + + b.Property("Description") + .IsRequired() + .HasColumnType("text") + .HasColumnName("description"); + + b.Property("Time") + .HasColumnType("timestamp with time zone") + .HasColumnName("time"); + + b.Property("UserId") + .IsRequired() + .HasColumnType("text") + .HasColumnName("fk_expense_user_id"); + + b.HasKey("Id"); + + b.HasIndex("BudgetId"); + + b.ToTable("expenses", "domain"); + }); + + modelBuilder.Entity("ExpenseTracker.Domain.Entities.Expense", b => + { + b.HasOne("ExpenseTracker.Domain.Entities.Budget", "Budget") + .WithMany("Expenses") + .HasForeignKey("BudgetId") + .OnDelete(DeleteBehavior.Cascade) + .HasConstraintName("fk_expense_budget_id"); + + b.Navigation("Budget"); + }); + + modelBuilder.Entity("ExpenseTracker.Domain.Entities.Budget", b => + { + b.Navigation("Expenses"); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/ExpenseTracker.Persistence/PostgreSQL/Migrations/20240408161520_Add_Budgets_and_Expenses_relations.cs b/ExpenseTracker.Persistence/PostgreSQL/Migrations/20240408161520_Add_Budgets_and_Expenses_relations.cs new file mode 100644 index 0000000..985a28f --- /dev/null +++ b/ExpenseTracker.Persistence/PostgreSQL/Migrations/20240408161520_Add_Budgets_and_Expenses_relations.cs @@ -0,0 +1,80 @@ +using System; +using Microsoft.EntityFrameworkCore.Migrations; + +#nullable disable + +namespace ExpenseTracker.Persistence.PostgreSQL.Migrations +{ + /// + public partial class Add_Budgets_and_Expenses_relations : Migration + { + /// + protected override void Up(MigrationBuilder migrationBuilder) + { + migrationBuilder.EnsureSchema( + name: "domain"); + + migrationBuilder.CreateTable( + name: "budgets", + schema: "domain", + columns: table => new + { + id = table.Column(type: "text", nullable: false), + amount = table.Column(type: "double precision", nullable: false), + currency = table.Column(type: "text", nullable: false), + category = table.Column(type: "text", nullable: false), + from_time = table.Column(type: "timestamp with time zone", nullable: false), + to_time = table.Column(type: "timestamp with time zone", nullable: false), + fk_budget_user_id = table.Column(type: "text", nullable: false) + }, + constraints: table => + { + table.PrimaryKey("PK_budgets", x => x.id); + }); + + migrationBuilder.CreateTable( + name: "expenses", + schema: "domain", + columns: table => new + { + id = table.Column(type: "text", nullable: false), + amount = table.Column(type: "double precision", nullable: false), + currency = table.Column(type: "text", nullable: false), + category = table.Column(type: "text", nullable: false), + time = table.Column(type: "timestamp with time zone", nullable: false), + description = table.Column(type: "text", nullable: false), + BudgetId = table.Column(type: "text", nullable: true), + fk_expense_user_id = table.Column(type: "text", nullable: false) + }, + constraints: table => + { + table.PrimaryKey("PK_expenses", x => x.id); + table.ForeignKey( + name: "fk_expense_budget_id", + column: x => x.BudgetId, + principalSchema: "domain", + principalTable: "budgets", + principalColumn: "id", + onDelete: ReferentialAction.Cascade); + }); + + migrationBuilder.CreateIndex( + name: "IX_expenses_BudgetId", + schema: "domain", + table: "expenses", + column: "BudgetId"); + } + + /// + protected override void Down(MigrationBuilder migrationBuilder) + { + migrationBuilder.DropTable( + name: "expenses", + schema: "domain"); + + migrationBuilder.DropTable( + name: "budgets", + schema: "domain"); + } + } +} diff --git a/ExpenseTracker.Persistence/PostgreSQL/Migrations/ApplicationDbContextModelSnapshot.cs b/ExpenseTracker.Persistence/PostgreSQL/Migrations/ApplicationDbContextModelSnapshot.cs new file mode 100644 index 0000000..e66e9af --- /dev/null +++ b/ExpenseTracker.Persistence/PostgreSQL/Migrations/ApplicationDbContextModelSnapshot.cs @@ -0,0 +1,126 @@ +// +using System; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using ExpenseTracker.Persistence.PostgreSQL; +using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata; + +#nullable disable + +namespace ExpenseTracker.Persistence.PostgreSQL.Migrations +{ + [DbContext(typeof(ApplicationDbContext))] + partial class ApplicationDbContextModelSnapshot : ModelSnapshot + { + protected override void BuildModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder + .HasDefaultSchema("domain") + .HasAnnotation("ProductVersion", "8.0.3") + .HasAnnotation("Relational:MaxIdentifierLength", 63); + + NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder); + + modelBuilder.Entity("ExpenseTracker.Domain.Entities.Budget", b => + { + b.Property("Id") + .HasColumnType("text") + .HasColumnName("id"); + + b.Property("Amount") + .HasColumnType("double precision") + .HasColumnName("amount"); + + b.Property("Category") + .IsRequired() + .HasColumnType("text") + .HasColumnName("category"); + + b.Property("Currency") + .IsRequired() + .HasColumnType("text") + .HasColumnName("currency"); + + b.Property("FromTime") + .HasColumnType("timestamp with time zone") + .HasColumnName("from_time"); + + b.Property("ToTime") + .HasColumnType("timestamp with time zone") + .HasColumnName("to_time"); + + b.Property("UserId") + .IsRequired() + .HasColumnType("text") + .HasColumnName("fk_budget_user_id"); + + b.HasKey("Id"); + + b.ToTable("budgets", "domain"); + }); + + modelBuilder.Entity("ExpenseTracker.Domain.Entities.Expense", b => + { + b.Property("Id") + .HasColumnType("text") + .HasColumnName("id"); + + b.Property("Amount") + .HasColumnType("double precision") + .HasColumnName("amount"); + + b.Property("BudgetId") + .HasColumnType("text"); + + b.Property("Category") + .IsRequired() + .HasColumnType("text") + .HasColumnName("category"); + + b.Property("Currency") + .IsRequired() + .HasColumnType("text") + .HasColumnName("currency"); + + b.Property("Description") + .IsRequired() + .HasColumnType("text") + .HasColumnName("description"); + + b.Property("Time") + .HasColumnType("timestamp with time zone") + .HasColumnName("time"); + + b.Property("UserId") + .IsRequired() + .HasColumnType("text") + .HasColumnName("fk_expense_user_id"); + + b.HasKey("Id"); + + b.HasIndex("BudgetId"); + + b.ToTable("expenses", "domain"); + }); + + modelBuilder.Entity("ExpenseTracker.Domain.Entities.Expense", b => + { + b.HasOne("ExpenseTracker.Domain.Entities.Budget", "Budget") + .WithMany("Expenses") + .HasForeignKey("BudgetId") + .OnDelete(DeleteBehavior.Cascade) + .HasConstraintName("fk_expense_budget_id"); + + b.Navigation("Budget"); + }); + + modelBuilder.Entity("ExpenseTracker.Domain.Entities.Budget", b => + { + b.Navigation("Expenses"); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/ExpenseTracker.Persistence/PostgreSQL/Repositories/BasePostgreSQLRepository.cs b/ExpenseTracker.Persistence/PostgreSQL/Repositories/BasePostgreSQLRepository.cs new file mode 100644 index 0000000..75d69ce --- /dev/null +++ b/ExpenseTracker.Persistence/PostgreSQL/Repositories/BasePostgreSQLRepository.cs @@ -0,0 +1,55 @@ +using System.Linq.Expressions; +using Microsoft.EntityFrameworkCore; +using ExpenseTracker.Application.Common.Interfaces.Repositories; +using ExpenseTracker.Domain.Entities; + +namespace ExpenseTracker.Persistence.PostgreSQL.Repositories; + +public class BasePostgreSQLRepository : IBaseRepository + where TKey : IEquatable + where TEntity : EntityBase +{ + protected ApplicationDbContext _dbContext; + + public BasePostgreSQLRepository(ApplicationDbContext dbContext) + { + _dbContext = dbContext; + } + + public IQueryable Queryable => _dbContext.Set().AsQueryable(); + + public async Task AddOneAsync(TEntity entity, CancellationToken cancellationToken) + { + await _dbContext.Set().AddAsync(entity, cancellationToken); + await _dbContext.SaveChangesAsync(); + return entity; + } + + public async Task> AddManyAsync(IEnumerable entities, CancellationToken cancellationToken) + { + await _dbContext.Set().AddRangeAsync(entities, cancellationToken); + await _dbContext.SaveChangesAsync(); + return entities; + } + + + public async Task UpdateOneAsync(TEntity entity, CancellationToken cancellationToken) + { + _dbContext.Set().Update(entity); + await _dbContext.SaveChangesAsync(); + return entity; + } + + public async Task DeleteOneAsync(TKey id, CancellationToken cancellationToken) + { + // await _dbContext.Set().Where(e => e.Id.Equals(id)).ExecuteDeleteAsync(); + var entity = _dbContext.Set().Find(id); + _dbContext.Set().Remove(entity); + await _dbContext.SaveChangesAsync(); + } + + public Task DeleteManyAsync(Expression> predicate, CancellationToken cancellationToken) + { + throw new NotImplementedException(); + } +} diff --git a/ExpenseTracker.Persistence/PostgreSQL/Repositories/BudgetPostgreSQLRepository.cs b/ExpenseTracker.Persistence/PostgreSQL/Repositories/BudgetPostgreSQLRepository.cs new file mode 100644 index 0000000..06891b5 --- /dev/null +++ b/ExpenseTracker.Persistence/PostgreSQL/Repositories/BudgetPostgreSQLRepository.cs @@ -0,0 +1,10 @@ +// using ExpenseTracker.Application.Common.Interfaces.Repositories; +// using ExpenseTracker.Domain.Entities; +// +// namespace ExpenseTracker.Persistence.PostgreSQL.Repositories; +// +// public sealed class BudgetPostgreSQLRepository : BasePostgreSQLRepository, IAccountRepository +// { +// public BudgetPostgreSQLRepository(ApplicationDbContext dbContext) +// : base(dbContext) { } +// } diff --git a/ExpenseTracker.Persistence/PostgreSQL/Repositories/ExpensePostgreSQLRepository.cs b/ExpenseTracker.Persistence/PostgreSQL/Repositories/ExpensePostgreSQLRepository.cs new file mode 100644 index 0000000..6294e3d --- /dev/null +++ b/ExpenseTracker.Persistence/PostgreSQL/Repositories/ExpensePostgreSQLRepository.cs @@ -0,0 +1,10 @@ +// using ExpenseTracker.Application.Common.Interfaces.Repositories; +// using ExpenseTracker.Domain.Entities; +// +// namespace ExpenseTracker.Persistence.PostgreSQL.Repositories; +// +// public sealed class ExpensePostgreSQLRepository : BasePostgreSQLRepository, IExpenseRepository +// { +// public ExpensePostgreSQLRepository(ApplicationDbContext dbContext) +// : base(dbContext) { } +// } diff --git a/ExpenseTracker.sln b/ExpenseTracker.sln new file mode 100644 index 0000000..4f57938 --- /dev/null +++ b/ExpenseTracker.sln @@ -0,0 +1,46 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.0.31903.59 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ExpenseTracker.Api", "ExpenseTracker.Api\ExpenseTracker.Api.csproj", "{30DB976E-DDA0-40BD-8074-76860FE40F14}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ExpenseTracker.Application", "ExpenseTracker.Application\ExpenseTracker.Application.csproj", "{9C1172CD-F950-4B60-9AC7-E22CF70F96D3}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ExpenseTracker.Domain", "ExpenseTracker.Domain\ExpenseTracker.Domain.csproj", "{867199F8-161D-465E-B7D2-8FDD71C37472}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ExpenseTracker.Persistence", "ExpenseTracker.Persistence\ExpenseTracker.Persistence.csproj", "{C571B8DD-07E2-45D5-9BBD-3BBB0AFAF356}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ExpenseTracker.Infrastructure", "ExpenseTracker.Infrastructure\ExpenseTracker.Infrastructure.csproj", "{7B6DE30C-1AE8-41FF-99D7-CF268D2F8330}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {30DB976E-DDA0-40BD-8074-76860FE40F14}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {30DB976E-DDA0-40BD-8074-76860FE40F14}.Debug|Any CPU.Build.0 = Debug|Any CPU + {30DB976E-DDA0-40BD-8074-76860FE40F14}.Release|Any CPU.ActiveCfg = Release|Any CPU + {30DB976E-DDA0-40BD-8074-76860FE40F14}.Release|Any CPU.Build.0 = Release|Any CPU + {9C1172CD-F950-4B60-9AC7-E22CF70F96D3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {9C1172CD-F950-4B60-9AC7-E22CF70F96D3}.Debug|Any CPU.Build.0 = Debug|Any CPU + {9C1172CD-F950-4B60-9AC7-E22CF70F96D3}.Release|Any CPU.ActiveCfg = Release|Any CPU + {9C1172CD-F950-4B60-9AC7-E22CF70F96D3}.Release|Any CPU.Build.0 = Release|Any CPU + {867199F8-161D-465E-B7D2-8FDD71C37472}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {867199F8-161D-465E-B7D2-8FDD71C37472}.Debug|Any CPU.Build.0 = Debug|Any CPU + {867199F8-161D-465E-B7D2-8FDD71C37472}.Release|Any CPU.ActiveCfg = Release|Any CPU + {867199F8-161D-465E-B7D2-8FDD71C37472}.Release|Any CPU.Build.0 = Release|Any CPU + {C571B8DD-07E2-45D5-9BBD-3BBB0AFAF356}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {C571B8DD-07E2-45D5-9BBD-3BBB0AFAF356}.Debug|Any CPU.Build.0 = Debug|Any CPU + {C571B8DD-07E2-45D5-9BBD-3BBB0AFAF356}.Release|Any CPU.ActiveCfg = Release|Any CPU + {C571B8DD-07E2-45D5-9BBD-3BBB0AFAF356}.Release|Any CPU.Build.0 = Release|Any CPU + {7B6DE30C-1AE8-41FF-99D7-CF268D2F8330}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {7B6DE30C-1AE8-41FF-99D7-CF268D2F8330}.Debug|Any CPU.Build.0 = Debug|Any CPU + {7B6DE30C-1AE8-41FF-99D7-CF268D2F8330}.Release|Any CPU.ActiveCfg = Release|Any CPU + {7B6DE30C-1AE8-41FF-99D7-CF268D2F8330}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection +EndGlobal diff --git a/README.md b/README.md new file mode 100644 index 0000000..ea13d8f --- /dev/null +++ b/README.md @@ -0,0 +1,3 @@ +# Expense Tracker Class Library + +This code repository is a class library containing core business logic upon which all the "front-ends" such as rest api, mvc, razor pages, cli etc., will be built diff --git a/globl.json b/globl.json new file mode 100644 index 0000000..3fea262 --- /dev/null +++ b/globl.json @@ -0,0 +1,6 @@ +{ + "sdk": { + "version": "8.0.0", + "rollForward": "latestFeature" + } +}