OpenOlitor

OpenOlitor is a fully self‑hosted, web‑based administration platform designed for Community‑Supported Agriculture (CSA), Solidarity Farming and subscription‑based direct marketing. From a developer’s point of view it is a modular, API‑centric solution that abstracts the complex domain logic (member management, subscription handling, order fulfillment, financial reporting) into a set of reusable services. The project is released under AGPL‑v3, ensuring that any derivative work remains open source while protecting the community’s intellectual property.

Technical Stack & Architecture

OpenOlitor follows a classic three‑tier architecture:

• Backend – Written in Scala (2.13.x) and built on the Play Framework 2.8, providing a reactive HTTP layer with JSON‑first APIs. Business logic is encapsulated in domain‑driven modules (e.g., MemberService, OrderProcessor) and exposed via REST endpoints.
• Persistence – Uses PostgreSQL as the primary relational store. All schema migrations are managed with Slick and Flyway, ensuring deterministic upgrades. A secondary Redis cache is optional for session storage and rate limiting.
• Frontend – The UI is a single‑page application built with Angular (12+) and communicates exclusively through the backend’s REST API. Internationalisation is handled via Angular i18n, allowing multi‑language deployments out of the box.

The application is packaged as a self‑contained JAR, making it straightforward to deploy in Docker containers or traditional application servers. A dedicated server module exposes health‑check endpoints (/health, /metrics) that integrate with Kubernetes liveness/readiness probes.

Core Capabilities & APIs

• Subscription Lifecycle – CRUD operations for plans, baskets, and recurring orders. The API supports complex pricing rules (volume discounts, seasonal adjustments) that can be defined via JSON schemas.
• Member & Producer Management – Full CRUD with role‑based access control. Membership tiers, payment status, and demographic data are stored in a normalized schema.
• Financial Integration – Exposes webhook endpoints for payment providers (e.g., Stripe, PayPal). The server can trigger reconciliation jobs that update member balances and generate PDF invoices on demand.
• Reporting & Analytics – Endpoints return aggregated data (sales per region, basket fulfillment rates) in CSV or JSON. Developers can hook into the reporting pipeline to embed charts or export data to external BI tools.
• Webhooks & Extensibility – External systems can subscribe to events (order.created, member.updated) via an optional webhook dispatcher. A plugin architecture allows custom modules to register new services without touching core code.

Deployment & Infrastructure

OpenOlitor is designed for cloud‑native environments. The Docker image (openolitor/openolitor-server:latest) is built with a multi‑stage approach, keeping the runtime footprint minimal (~200 MB). For Kubernetes, Helm charts are available that configure PostgreSQL, Redis, and the application pod with configurable resource limits. The platform scales horizontally by adding more replicas; the stateless nature of the Play server ensures seamless load balancing.

Self‑hosting prerequisites are modest: a JVM 17 runtime, PostgreSQL ≥12, and optional Redis. The application ships with a lightweight development server for rapid iteration, but production deployments should use TLS termination at the ingress and enforce HTTPS.

Integration & Extensibility

OpenOlitor’s API surface is RESTful with strict versioning (/api/v1/...). Authentication uses JWT tokens issued by the server itself, simplifying integration with external identity providers (OAuth2, SAML). The webhook system supports both inbound and outbound events, allowing developers to build real‑time dashboards or trigger external workflows (e.g., Slack notifications).

The plugin system is based on Scala’s ServiceLoader mechanism. Developers can create a new JAR that implements the OpenOlitorPlugin interface and publish it to the classpath. The server auto‑detects plugins at startup, registering any additional routes or background jobs they expose.

Developer Experience

• Documentation – Comprehensive Wiki coverage (installation, API reference, plugin guide) with examples in both German and English. The repository includes automated tests (ScalaTest) and CI pipelines on Travis, ensuring code quality.
• Configuration – All settings are externalised via application.conf and environment variables, enabling zero‑touch deployments. Feature flags can toggle experimental modules.
• Community & Support – An active GitHub issue tracker and mailing list foster rapid feedback. The AGPL license guarantees that improvements remain community‑owned, encouraging contributions.

Use Cases

1. CSA Operator – Deploy OpenOlitor to manage weekly basket orders, automate invoicing, and provide members with a self‑service portal.
2. Co‑operative Farm – Use the plugin system to integrate with a custom ERP, syncing inventory and financial data.
3. Regional Food Hub – Expose the API to third‑party apps (mobile ordering, market analytics) while keeping core logic on a single platform.
4. Educational Projects – Leverage the open source codebase to teach students about domain‑driven design, reactive Scala, and full‑stack web development.

Advantages for Developers

• Full Open Source – AGPL guarantees that any derivative remains free, fostering a collaborative ecosystem.
• Modern Stack – Scala + Play for performance and type safety; Angular for a responsive UI.
• Modular Architecture – Clean separation of concerns allows incremental adoption; start with the API and later add UI or plugins.