clean-architecture | Clean Architecture in the real world | Architecture library

I solved it, I just needed to add the event to the bloc. So, my solution was to create another state called PaintingsInitialState like so:

The States

Finally I had to add use_frameworks! :linkage => :static and all my problems are gone :)

I have a feeling this question is better suited to Software Engineering SE but I will make an attempt at answering.

The short answer to your question is: Yes.

If you want to follow Clean Architecture to the letter, the thing to do is build domain models that don't depend on your persistence layer at all. With gorm, that necessitates building a domain <-> persistence model mapping layer and all the added complexity that comes from that. Gorm will still make querying and saving that persistence model easier than creating your own queries, and compared to ORMs in other languages that I've experienced, it's still fairly lightweight.

Technically you do not need to have gorm.Model in the model structs. Having an ID int field, plus any of the CreatedAt, UpdatedAt, DeletedAt fields that you want is enough (this is what gorm.Model gives you). But invariably you will be adding other artifacts that are to do with how gorm does things, so you do not escape this dependence if the gorm package isn't present in your model structs.

This begs the question of whether following Clean Arch to the letter is the right decision for your project. Like all design decisions, it bears tradeoffs and makes more or less sense according to the scope and complexity of the system being built. If you foresee challenges that your project will run into that Clean Arch can mitigate then the extra investment now will pay off. If, on the other hand, aspects of the architecture are there to mitigate problems you're unlikely to run into in your particular situation, then you may be more forgiving. The conclusion to the blog post you linked makes an argument along the same lines:

NHibernate provides the best set of trade-offs between the implementation complexity and the overall purity. There still will be ORM concerns leaking into your domain model, however. But I think it’s a low price for all the benefits you’ll get out of it: speed of development, rich functionality, and separation of concerns.

You use interfaces to be able to change implementations without modifiying your code.

If in a future you use another "way" of sending mails, you just need to change the IMailSender implementation and that's all. Otherwise you would need to refactor all your code depending on your MailSender implementation.

Normally you would use your IMailSender interface also in your validation project. So yes, this intertface should reside in a common library, which will be referenced by both libraries.

Then you will inject (normally via IoC) the implementation in your services, which depend on IMailSender

Usually your Infrastructure library will have have the implementations of your interfaces (some of them may be declared in your "core" library and others...) which will be injected in the classes using it.

So the "infrastructure library" is a way to abstract you implementations, so your code soes not rely on specific classes but on interfaces, being way easier to refactor/change in a future.

There are some other points (it also depends if you are using DDD etc..here every Domain has its own infrastructure) but for me this is the main "reason" of an infrastructure layer.

In this case I would not duplicate the interface, as long as you need the same functionality in both libraries. If not the case, then create two interfaces, each serving the specific needs.

I believe you're missing a level of mocking, leading to the null exception. Keep in mind the mocked class returns null for everything. You have to provide values for everything.

You've mocked DbManager, but not the foodTableDao field inside DbManager.

You are using Item.fromJson instead of ItemModel.fromJson ? Have you tried this ?

You might want to check out this documentation. In .Net Core secrets can be inserted into a the appsettings.json file from environment variables via the command line on start up as long as the appsettings.json file is properly tokenized. There's also the ability to override the appsettings.json file with values stored in a key vault, such as Hashicorp Vault or Microsoft's Azure Key Vault.

You got it in your "edit". The actual input validation should happen on the business logic, in the use case interactor. The controller does the "simple" data transformation.

Example: The view sends a date string. The controller tries to convert it into a Date object. In case the input string is not a valid date format the controller passes this information to the use case interactor e.g. as null or as option in functional languages or as any other type which makes it clear to the use case interactor that the input date was invalid. The use case interactor then decides how to handle this input.

This is a big and really misleading error log of android. The problem was with the library version on Realm used in main gradle file of project. It got solved after just updating the library version.