Genie.jl is the backbone of Genie Framework: the complete solution for developing modern full-stack web applications in Julia.
It includes key features like the web server, the flexible templating engine with support for HTML, JSON, Markdown, and Julia views,
caching, (encrypted) cookies and sessions, forms handling, and the powerful router. Genie.jl uses the familiar MVC architecture,
follows industry best practices, and comes with lots of useful code generators to get you started!
# Genie Hello World!
# As simple as Hello
using Genie
route("/hello") do
"Welcome to Genie!"
end
# Powerful high-performance HTML view templates
using Genie.Renderer.Html
route("/html") do
h1("Welcome to Genie!") |> html
end
# JSON rendering built in
using Genie.Renderer.Json
route("/json") do
(:greeting => "Welcome to Genie!") |> json
end
# Start the app!
up(8888)
Genie pluginsGenie.jl can be extended to provide even more features by adding official and community contributed plugins. Some of the most popular plugins add functionalities like authentication and authorisation, or web pages auto-reload during development.
Simple but effective database backed authentication plugin for Genie.jl.
It includes all the functionality for registering new accounts and logging in users. It's views can be customised as needed and authentication logic can be applied anywhere in the code (routes, models, views, controllers)
#Auth check at route level
route("/profile/:id") do; @authenticated!
html(:user, :profile, user = User(params(:id)))
end
# Auth check in views
<li class="nav-item">
<% if authenticated %>
<a class="nav-link" href="/profile/$(params(:id))">Profile</a>
<% else %>
Login
<% end %>
</li>
<% end %>
Role based Authorisation (RBA) plugin for Genie.jl.
GenieAuthorisation.jl implements a flexible and robust database backed authorisation framework which employes roles and permissions to determine and enforce the level of user access to designated app features. Authorisation logic can be applied anywhere in the code (routes, models, views, controllers).
#Implement authorisation at route level
route("/admin/users/delete/:id") do; @authorised!(:admin)
delete(User, params(:id))
end
# Authorisation check in views
<% if has_role(current_user(), :admin) ||
has_permission(current_user(), :delete) %>
<a class="btn" href="/admin/users/delete/42">Delete user</a>
<% end %>
GenieAutoReload.jl speeds up and streamlines your Genie Framework app development by automatically monitoring your application files for changes (for example when editing and saving your code).
When changes are detected, the autoreload plugin automatically refreshes all of your application's web pages that are opened in the browser – so you don't have to.
# load GenieAutoReload
using GenieAutoReload
# Enable autoreload
Genie.config.websockets_server = true
GenieAutoReload.autoreload(pwd())
function view()
[
h1("Hello Genie!")
Genie.Assets.channels_support()
GenieAutoReload.assets()
]
end
Stipple is the UI library for building interactive data applications in Julia. Stipple helps Julia developers to quickly and easily create interactive data dashboards and data centric applications, as well as web based user interfaces for Julia software. Stipple offers a large collection of user interface elements (such as inputs, buttons, sliders, tabs, data tables, responsive layouts, and many more) and powerful plotting capabilities.
heading("What's your number?")
# set up user input
textfield("Write your number and see if others dig it too",
:choice, @on("keyup.enter", "process = true"),
clearable = true, filled = true,
errormessage = :errormessage,
error = :error)
h6("Numbers distribution")
# plot it
plot(:data, layout = :layout, config = :config,
style="margin-top: -10pt;")
Stipple pluginsStipple can be extended to include any UI features you could think of: from 3D rendering, to slides and spreadsheets, to powerful diagrams editors, there are no limits to what can be built on top of Stipple!
StippleUI provides a collection of over 25 professional (web) UI elements, ready to implement in your Julia app!
Ranging from the fundamentals like inputs, sliders, buttons, lists, toggles and knobs, to great looking cards, badges, tabs, drawers, menus, and loaders, and to the super-powerful data tables, text editors, and lazy content loaders (and many others!).
heading("German Credits by Age")
bignumber("Bad credits", :count_bad_credits)
bignumber("Good credits", :count_good_credits)
h4("Age interval filter")
range(18:1:90, :range_data; label = true, labelalways = true,
labelvalueleft = Symbol("'Min age: ' + range_data.min"),
labelvalueright = Symbol("'Max age: ' + range_data.max"))
h4("Credits data")
table(:credit_data; pagination=:credit_data_pagination).png)
StippleCharts is a feature rich plotting library for Stipple built upon the powerful ApexCharts.js.
With a simple API, a multitude of chart types, and a multitude of customisation options, StippleCharts is a great alternative to StipplePlotly if you're looking for lighter plotting with great visuals!
.png)
.png)
StipplePlotly.jl is a powerful and easy to use charting plugin for Stipple, based on the well-known Plotly JavaScript library.
Stipple makes it a breeze to combine Plotly charts with other UI elements, typography and responsive layouts, in order to create professional data visualisations.
# set up the plot
function plotdata()
PlotData(
x = [rand(1:100) for _ in 1:1_000],
plot = StipplePlotly.Charts.PLOT_TYPE_HISTOGRAM
)
end
# add to the model
Base.@kwdef mutable struct Model <: ReactiveModel
data::R{Vector{PlotData}} = [plotdata()]
layout::PlotLayout = PlotLayout(plot_bgcolor = "#fff")
config::PlotConfig = PlotConfig()
end
# render
h6("Numbers distribution")
plot(:data, layout = :layout, config = :config)
.png)
.png)
.png)
SearchLight is a complete ORM solution for Julia, supporting Postgres, MySQL and SQLite (ODBC and JDBC support coming soon). SearchLight offers a complete range of features, that go beyond query generation, including database schema versioning through migrations, model validators, data serializers, model relationships, transactions support and much more. SearchLight greatly simplifies the task of working with databases through its portable, concise and readable Julia API.
Base.@kwdef mutable struct User <: AbstractModel
id::DbId = DbId()
username::String = ""
password::String = ""
end
Validation.validator(::Type{User}) = ModelValidator([
ValidationRule(:username, UsersValidator.not_empty),
ValidationRule(:username, UsersValidator.unique),
ValidationRule(:password, UsersValidator.not_empty)
])
function register()
User(username = params(:username),
password = params(:password) |> hash_password,
name = params(:name),
email = params(:email)
) |> save!
end