QLBase

🪁 What is QLBase?

QLBase is a powerful open-source decentralizable backend solution designed to provide scalable and reliable services for a wide range of applications. It offers a comprehensive set of features including user account authentication, SMS verification via OTP (One-Time Password), data analytics, database storage, and even file storage as a software service. QLBase aims to be a flexible alternative to traditional cloud-based services, empowering developers to build robust applications with ease.

🎯 Features

QLBase offers a wide array of features that make it a versatile, scalable, reliable, and powerful backend solution suitable for a variety of applications. Below are the summarized APIs and service features of QLBase:

Authentication: QLBase provides a robust authentication system that allows you to manage user accounts securely.
SMS Verification: Easily integrate SMS verification into your application using QLBase's OTP service. Protect your user accounts with one-time passwords sent via SMS. QLBase provides SMS verification functionality using an Arduino UNO with a SIM900 Shield as the underlying SMS hardware.
Data Analytics: QLBase includes powerful data analytics capabilities, enabling you to identify, track, and page data efficiently. QLBase offers data analytics identification, tracking, paging, and even making aliases for both registered users and anonymous guess.
Database: Store and manage your data in QLBase's scalable and reliable database storage. Key features of QLBase's database storage include
File Storage: QLBase simplifies file management within your application. QLBase file storage API service offers: file uploads, file retrievals, and access controls.

🚀 Deployment

Deploying QLBase is a straightforward and hassle-free process that can be executed on virtually any system, provided it possesses the capability to run both the Apache and MySQL server, two fundamental components for QLBase to operate seamlessly.

To initiate the deployment, all you need to do is follow the comprehensive instructional guide outlined below, ensuring that each step is executed with precision and attention to detail.

The user-friendly nature of QLBase's deployment procedure, combined with the clear and concise instructions, makes it accessible even for those with limited technical expertise, ensuring a smooth and successful setup on your system.

💼 Software Requirements

QLBase requires several software from downloading its repository to building and running.

Git — Free and open source distributed version control system designed to handle everything.
Go Compiler — Open-source programming language supported by Google.
Qrepo - Simple and easy-to-use all-for-one build tool for Windows, Linux, and macOS.
NodeJS — An open-source, cross-platform JavaScript runtime environment.
XAMPP — Completely free, easy to install Apache distribution containing MariaDB, PHP, and Perl.

📥 Downloading the Repository

Open any terminal on your system and then follow the steps below:

Clone the QLBase repository from GitHub.

git clone https://github.com/nthnn/QLBase

Change the working directory to the cloned folder.
```
cd QLBase
```

If nothing went wrong, you have now downloaded the QLBase repository and should proceed to the section below.

🏗️ Building from Source

To simplify the deployment process of QLBase, a deploy.sh bash script is provided. This script is designed to package all the deployment-important files and assets and builds the back-end apps, ensuring a smooth deployment experience.

Ensure your Go compiler and NodeJS installation first before proceeding.
```
go version
node -v
```
Before running the deployment Bash script, it is important to set the appropriate file permissions first. It can be done by typing the following:
```
sudo chmod -R 777 ./deploy.sh
```
Now, run the deployment script and wait for it to finish. This script will build all the back-end software, documentations, and will compile all necessary files into a zip file output.
```
./deploy.sh
```
If it runs successfully, it will generate a zip file named qlbase.zip. Extract this zip file to the root of your Apache server and proceed to the next step.
Open the file named config.ini inside the folder bin. The file contains the following configurations:
```
[database]
server=localhost
username=root
password=
name=qlbase_apps
port=3306

[smtp]
host=<smtp host>
port=<smtp port>
from=<smtp email>
password=<smtp password>

[env]
home=http://localhost:8080/QLBase
sms=enabled
sms_serial=/dev/ttyUSB0
timezone=Asia/Manila
```
The database section defines the MySQL server, username, password, database name, and the server port. While the SMTP server defines the host address/name, server port, from (email address of origin), and password; this SMTP configuration will be used as email gateway for recovering forgotten passwords of users. The SMS service enability can also be configured with either "enabled" or "disabled" value. And lastly, the environment section defines the root URL of the current QLBase runtime.
On UNIX-based and UNIX-like operating systems (such as Linux and OSX), you are required to change the permissions of binary files inside the bin folder. Changing permissions can be done by opening the bin folder in the terminal and typing the following:
```
sudo chmod -R 777 .
```
Go back to the cloned folder of QLBase and look for the file named db.sql. Copy its contents and then paste and execute it to your MySQL server's terminal.
Cheers! 🥂 You can now open and enjoy your installed QLBase decentralized server!

💿 Firmware

The SMS OTP feature in QLBase is of utmost importance, providing a secure user authentication method through one-time passwords sent via SMS. In the following sections, you'll discover an in-depth look at the firmware, complete with setup instructions to make integration a smooth process.

⚡ Components

The SMS OTP (Short Message Service One-Time Password) firmware, an integral part of the QLBase system, relies on a concise and efficient hardware setup. This essential framework necessitates the utilization of just two key components, namely the Arduino UNO development board and the SIM900 GSM/GPRS UNO Shield.

Arduino UNO board	SIM900 Shield

The Arduino Uno board is a popular and versatile microcontroller platform that serves as a foundation for countless DIY electronics projects. Developed by Arduino, an open-source hardware and software community, the Uno is designed for both beginners and experienced electronics enthusiasts, making it an ideal choice for those looking to learn, experiment, and prototype with microcontrollers.

While, the SIM900 GSM/GPRS Uno Shield is a specialized add-on module designed to work in conjunction with Arduino Uno and compatible microcontroller boards. This shield enables wireless communication over the Global System for Mobile Communications (GSM) and General Packet Radio Service (GPRS) networks, making it a valuable tool for projects that require remote data transmission, SMS messaging, and internet connectivity.

🔧 Hardware Setup

Before you can upload the firmware, you need to set up your development environment and configure the Arduino UNO with the SIM900 shield. Ensure that you have an Arduino UNO and a SIM900 shield. Connect the SIM900 shield to the Arduino UNO, and make sure the following pin connections below are in accordance:

Arduino UNO	SIM900 Shield
5V	5V
GND	GND
D7	RX
D8	TX

For more information about using the SIM900 GSM/GPRS shield, please refer to this article.

📡 Uploading the Firmware

In this crucial steps, we will guide you through the process of uploading the SMS OTP firmware to your Arduino UNO with the SIM900 shield. This action is pivotal for enabling secure user authentication through SMS OTP for QLBase.

Begin by installing Visual Studio Code, a versatile and powerful integrated development environment (IDE).
Install the PlatformIO extension for Visual Studio Code.
Open the sms-otp-firmware folder inside the QLBase in Visual Studio Code using the PlatformIO extension.
Configure your SIM900 power source and wait for it to blink every 3 seconds.
Use PlatformIO to build and upload the firmware to your Arduino UNO with the SIM900 shield by clicking the upload button at the lower left bottom bar of the Visual Studio Code.

After following these steps, you can now connect the Arduino UNO to your computer where the QLBase is running to use the SMS-OTP API service.

🤝 Contributing and Contributors

All contributions are welcome to make QLBase even better. Whether you want to report a bug, suggest new features, or contribute code, your contributions are highly appreciated.

🐞 Issue Reporting

If you come across a bug, have a feature request, or wish to propose enhancements, we kindly encourage you to initiate the process by opening an issue on our GitHub Issue Tracker. Your feedback is invaluable in helping us refine and enhance the QLBase. To ensure we can address your concern effectively, we kindly request that you include as much pertinent information as possible. This may encompass a detailed description of the issue or feature request, and if applicable, specific steps to replicate the problem.

Your thorough input enables us to better understand and resolve the matter swiftly, contributing to the overall improvement of QLBase. Thank you for your contributions and for helping us create a more robust and user-friendly environment.

🛠️ Pull Requests

If you're eager to get involved and contribute your coding expertise to QLBase, we're thrilled to have you on board! To ensure a smooth and collaborative process, here's an outlined the following steps that you can follow:

Fork the QLBase repository to your GitHub account. And then clone it to your local machine.
```
git clone https://github.com/<your username>/QLBase.git
```

Create a new branch for your changes:

git checkout -b feature/<your feature name>

You can now make changes to the repository.

Commit your changes:

git add -A
git commit -m "Add your meaningful commit message here"

Push your changes to your forked repository:
```
git push origin feature/<your feature name>
```
Create a pull request (PR) from your branch to the main branch of the QLBase repository.
Your PR will be reviewed, and any necessary changes will be discussed and implemented.
Once your PR is approved, it will be merged into the main branch, and your contribution will be part of QLBase.

👥 Contributors

Finally, this section acknowledges and celebrates the individuals who have made significant contributions to the development and success of the project. Meet the dedicated and talented team members, developers, and collaborators who have played key roles in bringing QLBase to life and advancing its objectives.

Nathanne Isip — Original Author, Developer
Lady Selene — Artist, Illustrator

📷 Screenshots

QLBase Documentations

QLBase Homepage

Application Dashboard

Application Overview

Data Analytics Tab

QLBase API Sandbox

💙 Donating

QLBase is an open-source project and is voluntarily developed. If you find QLBase useful and would like to support its continued development and improvement, you can make a donation.

QLBase developers are profoundly grateful for your support! Your generosity allows us to continue developing and maintaining QLBase, making it better with each update. Your contribution is not just a donation; it's a vote of confidence in the project and a testament to the strength of the open-source community. Your contribution will help cover fund new features and support the community and developers (?) behind QLBase.

⭐️ Star History

📜 License

The use of QLBase is governed by the terms and conditions of MIT License. It's important to adhere to these licensing requirement when using or distributing QLBase components. The entire QLBase system, including the server-side, back-end, and the source files for the Arduino firmware used in the SMS service, is licensed under the MIT License.