Bloomerp

Bloomerp is an open-source Business Management Software framework that lets you create fully functional business management applications just by defining your Django database models.

It's out-of-the-box functionality gives you the ability to create advanced apps in minutes whilst maintaining the ability to add custom functionality without too much effort.

At its core, it leverages the popular Python framework Django and HTMX to provide robust and fast applications.

For a live demo, you can go to demo.bloomerp.io

Key features

Bloomerp comes packed with a variety of features:

• Intuitive CRUD Views: With integrated access control provided by Django.
• Advanced List Views: Offering powerful filtering capabilities.
• PDF Generation System: Easily define templates (like contracts) for your model objects.
• Customizable Dashboards: Create intuitive dashboards using widgets that are based on SQL Queries.
• SQL Query Editor: Make informed decisions based on advanced SQL queries on your company data.
• LLM Integration with BloomAI: Integrated 'bloomAI' that is your compangnion to create SQL queries, document templates, and general can even be used to extract company specific knowledge (using Langchain and tools calling). For more information, go to BloomAI.
• Bulk Uploads: For efficiently importing data into models.
• REST APIs: Automatically generated for all models using Django REST Framework.
• File System UI: An intuitive interface including folder structures.
• Bookmarking System: Helps users track bookmarked objects.
• Commenting System: Allows you to comment on specific objects.

Getting Started

You can start using the Bloomerp framework in a few simple steps:

1. Install Django and Bloomerp
2. Set Up the Project: Define settings in your Django application.
3. Start Defining Your Models
4. Define custom views if necessary

Install Django and Bloomerp

First things first, let's install Django:

pip install django

Now, let's get Bloomerp installed:

pip install bloomerp

Or if you want to get the latest (unreleased) version from Github

pip install --upgrade git+https://github.com/DavidBloomer11/Bloomerp.git  

Set Up the Project

Once you have the necessary dependencies installed, it's time to create your new project.

Imagine we're building a sales application that needs to track products, sales, and customers. We'll start by creating our Django project:

Create the Django project:

django-admin startproject core

Create the Django app:

django-admin startapp sales

After setting up the project and app, update core/settings.py to configure Bloomerp:

# core/settings.py
from bloomerp.config import BLOOMERP_APPS, BLOOMERP_MIDDLEWARE, BLOOMERP_USER_MODEL

LOGIN_URL = '/login'

# Installed apps
INSTALLED_APPS = [
    # Default Django apps...
    'sales',  # Your sales app
    # Any other installed apps
]
INSTALLED_APPS += BLOOMERP_APPS

# Middleware
MIDDLEWARE = [
    # Default Django middleware...
]
MIDDLEWARE += BLOOMERP_MIDDLEWARE

# User model
AUTH_USER_MODEL = BLOOMERP_USER_MODEL

# Crispy Forms (used by Bloomerp)
CRISPY_ALLOWED_TEMPLATE_PACKS = "bootstrap5"
CRISPY_TEMPLATE_PACK = "bootstrap5"

# Bloomerp settings
BLOOMERP_SETTINGS = {
    "globals": {
        "organization_name": "FooBar",
    },
    "BASE_URL": "",  # The base URL of the application
    "ROUTERS": [
        # More on routers later; leave blank for now
    ],
    "OPENAI_API_KEY": "KEY",  # For LLM integration
}

With the settings configured, proceed to make migrations:

python manage.py migrate

Create Your Models

Let's define some basic models for our sales application: Customer, Product, and Order.

from django.db import models
from bloomerp.models import BloomerpModel
from bloomerp.models.fields import BloomerpFileField
from django.utils import timezone

class Customer(BloomerpModel):
    name = models.CharField(max_length=255)
    email = models.EmailField()
    phone = models.CharField(max_length=15)
    address = models.TextField()

    string_search_fields = ['name', 'email']  # Fields searchable via string queries
    allow_string_search = True  # Include in global search

class Product(BloomerpModel):
    name = models.CharField(max_length=255)
    description = models.TextField(blank=True, null=True)
    image = BloomerpFileField(allowed_extensions=['.jpg', '.jpeg', '.png'])
    price = models.DecimalField(max_digits=10, decimal_places=2)

    string_search_fields = ['name', 'description']
    allow_string_search = True

class Order(BloomerpModel):
    STATUS_CHOICES = (
        ('pending', 'Pending'),
        ('processing', 'Processing'),
        ('completed', 'Completed'),
        ('cancelled', 'Cancelled'),
    )
    date = models.DateField(default=timezone.now)
    product = models.ForeignKey(Product, on_delete=models.CASCADE)
    quantity = models.IntegerField()
    status = models.CharField(max_length=255, choices=STATUS_CHOICES, default='pending')

    string_search_fields = ['product__name', 'status']
    allow_string_search = True

Notes:

1. Inherit from BloomerpModel: This ensures compatibility with Bloomerp's features.
2. string_search_fields: Specifies fields for string-based searches (e.g., in the search bar or forms).
3. allow_string_search: Determines if the model is searchable via the global search bar.

Make migrations for your new models:

python manage.py makemigrations sales
python manage.py migrate sales

Add the endpoints in your urls.py file.

# urls.py
from bloomerp.urls import BLOOMERP_URLPATTERNS

urlpatterns = [
    path("admin/", admin.site.urls),
    BLOOMERP_URLPATTERNS
]

Every time you update your models, run:

python manage.py save_application_fields

Create a superuser to log in:

python manage.py createsuperuser

Start the server:

python manage.py runserver

Overview of the Out-of-the-Box Application

Let's take a quick look at some of the base functionality provided by Bloomerp.

Note that all the provided features are neatly integrated with Django's permission system, and make use of HTMX for a nice single-page-application (SPA) feel.

Fully Customizable Dashboard

Create dashboards with charts, tables, links, custom texts, and more.

Create Objects

An intuitive and simple create view.

Detail views

Each object has an easy-to-use layout exposing different actions that can be performed on an object, such getting an overview, updating the objects, viewing files related to the object, and more.

List views

Perform advanced queries on models. For example, filter orders with a total between 200 and 300, including a specific product (Electric kettle).

Creating PDFs via Document Templates

Generate standardized documents (like contracts) with dynamic data from your models.

Creation of document template:

Usage of template:

PDF result:

Intuitive Search Bar

Effortlessly navigate and find information using the powerful search bar. Supports searching for specific objects, list-level routes (queries starting with /) and app-level routes (queries starting with //).

Search all object containing "Ana" in their string-search fields:

Search for all list-level routes for the customer model (start query with /):

Search for all app-level routes starting with "cust" (start query with //)

Additional Features

Bloomerp offers a range of other features. Documentation for these is coming soon. Stay tuned!

Creating Custom Views Using Routers

One of the main goals of the Bloomerp framework is to empower developers to easily integrate custom functionality into the Bloomerp UI—beyond the out-of-the-box features—without requiring extensive setup.

Custom views can be created at three different levels:

1. Detail-Level Routes: Custom views defined for specific objects that fit inside the detail view layout. For example, an update view for a particular object. Routes follow the format: www.example.com/model/object_id/route_name

2. List-Level Routes: Custom views defined for a particular model but not tied to a specific object. For instance, the object list view we discussed earlier. Routes follow the format: www.example.com/model/route_name

3. App-Level Routes: Custom views that are not related to any model. These are useful for general application functionality. Routes follow the format: www.example.com/route_name

Getting Started

To begin building custom views, initialize the router in your views.py file and reference it in your settings.py file.

In views.py:

# views.py
from bloomerp.utils.router import BloomerpRouter

router = BloomerpRouter()

In settings.py:

# settings.py
BLOOMERP_SETTINGS = {
    "globals": {
        "organization_name": "FooBar",
    },
    "BASE_URL": "", 
    "ROUTERS": [
        'sales.views.router',  # Links to the router variable inside your app's views file
    ],
    "OPENAI_API_KEY": "KEY",  # For LLM integration
}

Example: Creating a Custom List-Level View

Let's create a custom list-level view that allows user