-
-
Notifications
You must be signed in to change notification settings - Fork 52
Developers
We encourage anyone that wants to try and help to do so in any way they can! We are open source and appreciate any help.
We use the dependency injection pattern as recommended by Microsoft. https://docs.microsoft.com/en-us/dotnet/core/extensions/dependency-injection.
https://github.com/jbogard/MediatR
We are using the Domain driven development approach for the application. Here is a quick summary:
- The Domain defines what the application is about : interfaces, objects, etc. There is no logic in this layer.
- The Application defines how the application works : handlers, services, etc.
- The Infrastructure defines how we communicate with external tools : Poe Api, poeprices.info, poe.ninja
- The Persistence defines our internal database access.
- The Localization project contains centralized translations.
- The Presentation projects is to finally make the views for our apps.
The domain layer answers the question "What?". Here we declare all objects and services that need expain what the application is about. Our domain objects should be our own and not rely on external tools to dictate how we structure our data.
What we typically find in this layer are:
- service interfaces;
- object declarations;
- commands;
- queries;
- notifications;
What we will not find are:
- service implementations;
- json deserialization logic (i.e. JsonPropertyName);
- command, query and notification handlers;
The application layer answers the question "How?". In this layer we will find the implementations of the domain. The implementations found here are totally independent and should not rely on any third party files or api.
What we typically find in this layer are:
- service implementations;
- command, query and notification handlers;
What we will not find are:
- api calls;
- json deserialization logic;
- database logic;
The infrastructure layer is similar to the application layer, but it interacts with third party systems like external apis and files. Some external tools may have different data structure than we do in our domain. This layer should convert the data from the api structure to our own domain structure.
What we typically find in this layer are:
- service implementations with external dependencies;
- command, query and notification handlers with external dependencies;
- json deserialization logic;
What we will not find are:
- database logic;
The persistence layer is our database layer. This is where we implement our repositories to store data.
What we typically find in this layer are:
- repository implementations;
The last layer is the layer in which we present to the user. This is our UI.
When developping, we recommend using the Sidekick.Presentation.Blazor project (not Electron). It compiles a lot faster. If you are creating additional pages, feel free to add it to the Home screen. This view is there to help us developers be more efficient.
Steps:
- Run the Sidekick.Presentation.Blazor project
- Open a browser webpage
- Navigate manually to https://localhost:8081
Sometimes, it is necessary to test using the full Electron process. This takes a lot more time to compile and be ready to test.
Steps:
- Run the Sidekick.Presentation.Blazor.Electron project
- Attach to the running process
- Click on Debug -> Attach to process...
- Select Sidekick.Presentation.Blazor.Electron process
- Visual Studio 2019