raythahq / raytha Goto Github PK

Did some rudimentary testing with DocFX and it was easy to get started.

https://dotnet.github.io/docfx/index.html

I ran it on the Raytha.Application project and it did a thorough job of picking up literally everything.

Need to learn how to properly format and clean it up.

Ideally, the left side navigation is simply:

• Admins

  • Commands.CreateAdmin
  • Commands.DeleteAdmin
  • Commands.EditAdmin
  • Queries.GetAdminById
  • Queries.GetAdmins
  • EventHandlers.AdminCreatedEventHandler
  • EventHandlers.AdminPasswordResetEventHandler

• ContentItems

  • Commands.CreateContentItem
  • Commands.DeleteContentItem

...etc, etc, basically just the business layer actions, nicely organized.

I created a branch called docfx

This code: https://github.com/RaythaHQ/raytha/blob/main/src/Raytha.Web/Areas/Admin/Views/ContentItems/Create.cshtml

Anytime there is a lot of if / else-if with hard-coded values feels like a code smell.

We should evaluate how we can simplify the Create / Edit html. It's an important piece of code, especially if we plan to add more Field Types later on.

How can we setup a dashboard with widgets

Both Views and Content Types have "Description" fields that are option when creating / editing. It would be very helpful to have these descriptions available inside the templates, potentially for SEO meta descriptions.

Example:

Task:

• Update RenderModel on ContentType to include Description
• Update RenderModel on View to include Description
• Update GetProjection methods to map

When running Raytha in kubernetes and scaling up to more than 1 pod of Raytha, I noticed it loses the login sometimes. This is because we did not implement services.AddDataProtection().

There are a few ways to implement, but keeping it the simplest and technology footprint minimal, we will use the PersistKeysToDbContext as outlined here: https://learn.microsoft.com/en-us/aspnet/core/security/data-protection/configuration/overview?view=aspnetcore-7.0#persistkeystodbcontext

services.AddDataProtection().SetApplicationName("Raytha").PersistKeysToDbContext<RaythaDbContext>();

I tested it and it works, but this will be slated for 1.0 milestone because it has a database migration script.

Hello, this is simply awesome, with its simplicity, love the videos as well, I highly encourage others to view them.

Can you help explain, how we can create the various hooks, classes if we have entities, for e.g. EventManagement, with all its supporting needs. Will there be a T4 template or some code gen.
Also whats your road map, and can we use this in a commercial closed source for free

thanks

Currently, if you delete a template, the associated content items are silently deleted and I believe this is unexpected behavior. Better to err on the side of caution and prevent this.

Task:

• If a system admin attempts to delete a template, show an error message saying that Content Items are making use of this template. Those content items should be moved to another template prior to deletion.

On fresh database / setup, an error from Too Many Redirects happens on Initial Setup because in the last release we erroneously inherited from BaseController.

When loading up the code base for the first time and changing to Debug without JS configuration mode, a message pops up saying that the solution is misconfigured. Updating it is easy, but should not have this error in the first place.

We need to be able run background jobs or long running jobs such as full data exports / data imports / web hooks, and anything else that may be best served running outside the main web request.

Neither Quartz, nor Hangfire are MIT license. So we may have to roll our own.

If you choose a field in a drop down box (possibly radio also), and then submit, but something caused a validation failure on the form submission, then the drop down field does not keep its value and you have to re-select it.

Task:

• Ensure that on save, if a dropdown box had a value, it keeps the value on validation failure.
• Check to see if this is impacting Radio Fields as well.

Since we moved to the new Monaco Editor, if the user has a validation error when submitting the form, the page just says "There were errors that occurred, see below for details", but no details appear.

See custom liquid filter here:

https://deanebarker.net/tech/fluid/custom-filters/

As of v0.9.2 the template author has to remember to link to attached files like so:

/raytha/media-items/objectkey/{{ Target.PublishedContent.attachment.Value }}

I think this is unfair to expect the template author to remember the prefix of file route. Instead, we can easily do a custom liquid filter that renders it, but it would look like:

{{ Target.PublishedContent.attachment.Value | attachment_url }}

This line here:

is supposed to be a dictionary:

ViewData["ValidationErrors"] = errors?.ToDictionary(k => k.PropertyName, v => v.ErrorMessage);

Otherwise you cannot conveniently access the error for the field by developer name in the liquid template, example:

{{ ViewData["ValidationErrors"]["name"] }}

This is a non-trivial task, but is essential to build it well for v1.0.0.

For now we have a single API call available to allow developers to ping their application for health check purposes.

The initial implementation of the REST API can be a CRUD functionality on:

• Users [read,write]
• UserGroups [read,write]
• Content Items [read,write]
• Media Items [read,write]
• Content Types [read only]

These will go a long way to get started and provide immediate value to devs. In later versions we can consider adding CRUD around Templates and other enhancements.

Some big considerations:

• Authentication method? Most preferred is via API key attached to an admin account. An admin account is assigned to roles with permissions that the API key will inherit.
• Code needs to be compatible with NSwag to autogenerate swagger API specs and UI

If there is a 500 error at the content item level, it is handled by the Try-Catch block in the MainController. However, if there is a global 500 error outside of that, it currently redirects the user to the '/error' route. The problem is that there is no page at this route, so the user sees a 404 error instead.

To avoid this confusion, the system administrator can create a content item with a page route of '/error' as a workaround.

But we should fix this internally.

Discussed in #16

We are going with TinyMCE since it is the best WYSIWYG with an MIT license.

Will try to implement in a minor release since I do not believe a database migration is required for this implementation.

The right sidebar in Content Item > Edit screen does not highlight the active page. It works fine in Settings > Admins and Templates. Below is the expected behavior:

This is the actual behavior:

These two spots:

Need to be changed to search by p.DeveloperName, not p.AuthenticationSchemeType.

This got by testing because in testing I named my saml and jwt authentication schemes saml and jwt respectively. In which case it finds it fine. So that is the workaround til this is fixed.

Task:

• Ensure that the LoginWithSaml and LoginWithJwt properly search by DeveloperName
• Test with DeveloperNames other than saml and jwt

This code below:

I'm thinking it has to be Redirect() instead of RedirectPermanent() because it appears to be cached by cloudflare, the browser, or both. But the url being generated has a 1 day expiry, so if the cache > 24 hrs it redirects to an expired asset.

ref: https://stackoverflow.com/questions/17517318/redirect-vs-redirectpermanent-in-asp-net-mvc

These variables:

are currently only on the Target in the built in templates that are expecting a form submission such as Change password, etc. However, it would be immensely helpful to have these available in all templates if people are building custom form submissions from their own templates.

Here in our RenderEngine service: https://github.com/RaythaHQ/raytha/blob/main/src/Raytha.Web/Services/RenderEngine.cs

We are instantiating a new FluidParser() every time.

However, according to Fluid's documentation here: https://github.com/sebastienros/fluid#thread-safety, it is Thread Safe and should be shared by the whole application, but the TemplateContext should be instantiated every time.

Task:

• Confirm we should make this change
• Change to use private static readonly FluidParser _parser = new FluidParser();
• Perform tests

In the InitialSetup.Command() and EditSmtp.Command() application service layer take in MissingSmtpEnvironmentVariables as a property in the input DTO.

This is silly and IConfiguration should be injected into those application service layers. Expecting the Web layer to pass that in does not make much sense.

Task:

• Remove MissingSmtpEnvironmentVariables from the Command Dtos for InitialSetup and EditSmtp actions.

Task:

• Create a Dockerfile and ensure the platform runs in Docker on local machine
• Deploy to Web Apps for Containers on Azure to ensure it can run in that environment

We should focus on writing Unit Tests for the application and infrastructure layers.

Our project follows the jasontaylerdev/CleanArchitecture pattern and their tests are described here: https://github.com/jasontaylordev/CleanArchitecture/tree/main/tests

In creating the /contact form on raytha.com, I wanted to use the out of the box ModelState.IsValid functionality that comes with .NET since it is a common use case.

However, in the ModelState.IsValid check at the controller level, the SuccessMessage, RequestVerificationToken, and ValidationFailures attributes threw an error as they were empty.

Being empty is expected on a Form Submit.

By setting them to nullable, and { get; set; } instead of { get; init; }, it works.

The default base layout has two extra tags closing the html.

Drag and drop using the reorder list JS controller does not show a notyf notification of success or failure at the bottom right:

For some reason, none of this code is running:

However, the update is successfully made on the server.

Two tasks here:

• When layering on a filter in a view's settings, you can input bad input. This will result in a 500 error when instead, it should simply return "invalid value" since the OData parser crashes trying to process it.
• When trying to sort by bad or malicious values via query string, it results in 500 error, when it should just gracefully fallback to the default view's settings.

We need another block on the dashboard for Database storage usage.

The block should show:

• Storage consumed
• Storage allotted
• Percent used

The storage allotted can be pulled from appsettings.json.

The GetDashboardMetrics.Query needs the code for querying the database for its size.

https://github.com/RaythaHQ/raytha/blob/main/src/Raytha.Application/Dashboard/Queries/GetDashboardMetrics.cs

I believe we can make a query with Dappr.

EXEC sp_spaceused @oneresultset = 1

Result:

If you want to run Raytha behind a reverse proxy where your domain might be something.com but you want Raytha to run at something.com/mysite, it works remarkably well. I tested it on kubernetes behind nginx ingress.

All you have to do is add this line of code in Startup.cs as the first line in Configure(..)

But I think it might a good idea to allow this to be specified in an appsettings.json.

Task:

• Add in appsettings.json a new app setting: "PATHBASE". If the value is set in appsettings.json, change the PathBase to the one specified, otherwise leave it be.

Currently the parent layout _Layout does not have any of the Target variables when you click to Insert Variable. Out of convenience for the template author, they should be easily searchable in the Insert Variable menu.

Add a category in the Insert Variable box to allow the administrator to insert values from the Request query parameters.

I believe there are many use cases where the person building the liquid templates will be expecting an arbitrary query parameter, and can use that to their desire.

Similar to how Target.ValidationFailures[...] is a key-value dictionary, we should have something like Request.Query[...] as the usage in the liquid model.

One of the most difficult builds of my life, the code is immensely complicated and tightly coupled in certain areas. We will need to refactor this section:

However, given the complex nature of it, we will need to complete #10 first to have good test coverage on it before completing the refactoring.

Most third party libraries are pretty close to the latest versions but I noticed several that can be updated. There is also a "StringToExpression" library that don't believe is used anymore. Will confirm and remove if so.

On the javascript side, we actually do not have that many dependencies: https://github.com/RaythaHQ/raytha/blob/master/src/Raytha.Web/wwwroot/raytha_admin/js/package.json but we might as well update them too.

Task:

• Identify packages that can be upgraded
• Review if there are any breaking changes. Create new issue if there is a breaking change and fix that.
• Investigate if StringToExpression package is still being used, and remove if necessary.
• Perform tests.

Successfully setup azure blob storage behind Cloudflare reverse proxy. Benefits of this is are:

1. Cached assets / resources which saves on bandwidth
2. Can make use of Cloudflare image resizer / polish functionality
3. Consistent branding - assets.raytha.com

The problem is that the current Azure Blob Storage implementation generates SAS urls without the custom domain.

Task:

• Add another property in appsettings.json: FILE_STORAGE_AZUREBLOB_CUSTOM_DOMAIN
• If there is a value provided, do a string.Replace() on the hostname of the returned SAS url with the custom domain.
• See if the URL pattern can be compatible with cloudflare image resizer

Currently, if you save a view filter and it is missing proper attributes, it will error out on the next page load. There should be some validation on Filter save to prevent a bad filter from saving against the view.

Some of these controllers need to have their code cleaned up and moved into their own folders. I overloaded the shared directory throughout development. Not a difficult refactoring, just need to be smart about the folder organization and structure.

We need to formalize the CONTRIBUTION information, which should include the following:

• All contributions must be made under the MIT license.
• The following branches should be described:
  • main is the current production branch and should be kept in a clean state at all times.
  • release-X.X.X is typically the next release branch. It is frozen in the sense that no new features will be added, but bug fixes and security upgrades that are intended for the next release will be applied to this branch.
  • dev is the branch where new features are developed. For example, a Unit Tests branch may be created from dev, and a REST API branch may also be created from dev. When each of these features is complete, they are merged back into dev. When we have enough new features for the target milestone, a new release-X.X.X branch is created from dev. When we are ready to release, we merge release-X.X.X into main and tag the merge as a new release. After the release, dev should rebase on top of main and continue development.

This line here:

Our default Raytha implementation fires the DomainEvents before items are saved to the database. But there are many use cases where you may want to handle an event that retrieve the item from the db after the changes have saved, and then perform some action.

We can support both by having DomainEvents choose to implement either INotificationBefore or INotificationAfter. The implementations can be empty, but we can use this fire those that chose Before/After respectively.

I think by default, if the developer forgets to choose, we'll default to After db changes are saved.

We had a lingering package.json in the root directory which was trigging the Dependabot incorrectly.

By default, the liquid template outputs UTC format, but we want to give the Template builder the ability to conveniently convert the time to the same time specified in the system configuration settings.

Example:

<span class="ud-blog-date">{{ item.CreationTime | organization_time: '%b %e %Y, %l:%M:%S %P' }}</span>

The following code needs to be added to https://github.com/RaythaHQ/raytha/blob/main/src/Raytha.Web/Services/RenderEngine.cs

    public static ValueTask<FluidValue> LocalDateFilter(FluidValue input, FilterArguments arguments, TemplateContext context)
    {
        var value = TimeZoneConverter(input, context);
        return ReferenceEquals(value, NilValue.Instance) ? value : MiscFilters.Date(value, arguments, context);
    }

    private static FluidValue TimeZoneConverter(FluidValue input, TemplateContext context)
    {
        if (!input.TryGetDateTimeInput(context, out var value))
        {
            return NilValue.Instance;
        }

        var utc = DateTime.SpecifyKind(value.DateTime, DateTimeKind.Utc);

        // Create new offset for UTC
        var localOffset = new DateTimeOffset(utc, TimeSpan.Zero);

        var result = TimeZoneInfo.ConvertTime(localOffset, context.TimeZone);
        return new DateTimeValue(result);
    }

And:

options.Filters.AddFilter("organization_time", LocalDateFilter);

And we should update the default template too so this filter is in use for fresh installations.

Here: https://github.com/RaythaHQ/raytha/tree/main/src/Raytha.Domain/Events

I created a tutorial video today and found that it would be immensely helpful as part of the default Raytha to include events that fire on:

• ContentItemCreatedEvent
• ContentItemUpdatedEvent
• ContentItemDeletedEvent

Maybe there are other domain events that would be useful too, but we'll start with these.

Add current version to the footer

Right now, modifying the Raytha templates is just raw <textarea> fields but this is not an enjoyable experience. Integration with CodeMirror was not successful in our first iteration.

We will investigate use of Monaco Editor (MIT Open Source) which is the same technology that powers VS Code.

npm install monaco-editor

import * as monaco from 'monaco-editor';

// Initialize the editor
var editor = monaco.editor.create(document.getElementById('editor-container'), {
  value: "function hello() {\n\talert('Hello, world!');\n}",
  language: 'javascript'
});

In list view > public settings, where we set whether the list view is published and what the route path is, we should add settings for the following functionality:

• Default number of items per page
• Max number of items per page
• Ignore layered filter added by public query params. Meaning, list views published to the public side default to the filter set by the admin, but it is possible for the public user to filter even further (they can only ever do a subset of what the admin allows). However, there may be cases where the admin does not want any ability for the visitor to subset their list.

The line that initiates the FluidParser here:

Can be changed to:

    var parser = new FluidParser(new FluidParserOptions { AllowFunctions = true });

This will enable macros in Liquid syntax which is a very helpful feature.

Remove (coming soon) from: REST API automatically generated based on content types (coming soon)

Since we have made progress on #10, we should consider adding a Github Action that automatically builds and runs the tests when pushed. Then we can get the little badges that says "Builds successful" or "Tests passed"

I like what strapi does: https://github.com/strapi/strapi

• Do they run on every feature branch or just main / dev / release-vX.X.X ?

main = current production
release-vX.X.X = next minor release (branch off main for minor fixes and minor features)
dev = serves as trunk for major feature branches and PRs. Eventually turns into a release-v.X.X.X branch when ready to roll out a major release.