IDology — MycoPOS - Psychoactive Mycology Point of Sale for Retail and Web

Integrating IDology into an Odoo POS system

To verify customer IDs for the retail sale of legal psychoactive mushrooms can be done by leveraging **IDology’s API** for age verification and document validation. Here's a step-by-step guide on how to engineer this system:

### 1. **Understand IDology’s API and Requirements**
Before integrating IDology into your Odoo POS system, you'll need to:

Sign up for IDology and get access to their API keys.
Read through IDology’s API documentation to understand how the API works, including the endpoints available for age verification and document validation.

### 2. **Odoo POS Setup Overview**
In Odoo, the **POS** module can be customized by extending its functionality using Odoo's Python-based custom modules. The key components you'll need to modify or extend are:
- **POS order processing** (where the sale happens).
- **Custom UI** to interact with the ID scanning process.
- **Backend logic** for handling age verification through IDology.

### 3. **Steps to Integrate IDology API in Odoo POS**

Here’s a breakdown of the integration process:

### Step 1: Set Up the Environment
1. **Install Required Python Libraries**: You will need libraries for HTTP requests (like `requests`) to call IDology’s API from your Odoo backend.

```bash
pip install requests
```

2. **Get IDology API Credentials**: Once you've signed up for IDology, obtain the **API key** and **API URL**. The documentation should provide you with all the necessary details, such as the authentication method (likely a bearer token or basic authentication).

### Step 2: Create a Custom Odoo POS Module
1. **Create a Custom Module in Odoo**:
In Odoo, modules are Python packages that can extend existing functionality. You’ll create a module to handle the integration with IDology.

Here’s how to structure your module:
```
custom_pos_idology/
├── __init__.py
├── __manifest__.py
├── models/
│ ├── pos_order.py
└── static/
└── src/
└── js/
└── pos_idology.js
```

2. **Create the Manifest (`__manifest__.py`)**: This file defines the module and its dependencies.

```python
{
'name': 'POS ID Verification with IDology',
'version': '1.0',
'category': 'Point of Sale',
'author': 'Your Company',
'depends': ['point_of_sale'],
'data': [],
'qweb': ['static/src/xml/pos_idology.xml'],
'assets': {
'point_of_sale.assets': [
'custom_pos_idology/static/src/js/pos_idology.js',
],
},
'installable': True,
'application': True,
}
```

3. **Add the Backend Code (e.g., `pos_order.py`)**: In this step, you’ll add logic to communicate with IDology’s API.

### Step 3: Integrate with IDology API in Odoo

In the **backend models** (e.g., `models/pos_order.py`), you'll write the code to call IDology's API for age verification when an order is created or during checkout.

1. **Define the IDology API Call**:
```python
import requests
from odoo import models, fields, api
from odoo.exceptions import UserError

class PosOrder(models.Model):
_inherit = 'pos.order'

def verify_customer_age(self, customer_id):
# Define your IDology API endpoint and credentials
api_url = "https://api.idology.com/verify"
api_key = "YOUR_API_KEY" # Replace with your actual API key

# Prepare the payload for the API request
payload = {
'customer_id': customer_id, # This is the ID data extracted from the scanned ID
'api_key': api_key,
}

# Send a request to IDology API for age verification
response = requests.post(api_url, data=payload)
if response.status_code == 200:
# Parse the response from IDology
result = response.json()
if result['age_verified']:
return True # Customer is eligible to purchase
else:
raise UserError('Age verification failed. Customer is not eligible to purchase.')
else:
raise UserError('ID verification service is unavailable. Please try again later.')

@api.model
def create(self, vals):
order = super(PosOrder, self).create(vals)

# Trigger ID verification before confirming the sale
customer_id = order.partner_id.id_card_number # Assuming you store customer ID info here
if customer_id:
self.verify_customer_age(customer_id)

return order
```

This code assumes that you have stored the customer’s ID information (or barcode data) in the `partner_id` field, which can be captured during the POS transaction.
It uses the `requests` library to call the IDology API with the provided customer ID and checks the response to verify whether the customer meets the age requirements.

### Step 4: Add Frontend Code to Trigger ID Scan in POS
1. **POS Interface (Frontend)**: You need to allow the cashier to scan the customer’s ID or input the ID manually. You’ll likely use a **Bluetooth barcode scanner** for this.

In the `static/src/js/pos_idology.js` file, you’ll need to create a JavaScript function to trigger the ID scan.

```javascript
odoo.define('custom_pos_idology.pos_idology', function (require) {
"use strict";

const { Component } = require('owl');
const { useState } = require('react');
const { PosComponent } = require('point_of_sale.OwlComponents');

class PosIDScan extends PosComponent {
constructor() {
super(...arguments);
this.state = useState({ scannedID: null });
}

async onScanID(event) {
const scannedData = event.detail; // This would be your barcode or OCR data

// Send the scanned data (customer ID) to the Odoo backend for verification
const response = await this.rpc({
model: 'pos.order',
method: 'verify_customer_age',
args: [scannedData],
});

if (response) {
this.state.scannedID = scannedData;
alert('Age verified! Proceed with the sale.');
} else {
alert('Age verification failed. Customer is not eligible.');
}
}
}

PosIDScan.template = 'PosIDScan';

return PosIDScan;
});
```

**Scan ID**: When the cashier scans a customer’s ID using the Bluetooth scanner, the `onScanID` function will capture the scan data.
This data will be sent to the Odoo backend, where the `verify_customer_age` method will be called, invoking the IDology API for verification.

### Step 5: Customize the POS Interface
You’ll need to ensure that the **POS interface** is updated to reflect whether the customer has passed the ID verification. You can create a simple **popup** or alert to notify the cashier if the customer is eligible or not.

1. **Add Popup/Alert**: After the verification, you can display a simple alert on the POS screen:

**Pass**: Proceed with the sale.
**Fail**: Block the transaction and notify the cashier.

### Step 6: Testing and Debugging
1. **Test ID Scanning**: Test the Bluetooth scanner to ensure that it correctly sends the ID information to the POS system.
2. **Test API Communication**: Ensure that the API call to IDology works as expected and returns the correct age verification results.
3. **Edge Cases**: Handle edge cases such as expired IDs, invalid scans, or failed API responses. Show appropriate error messages to the cashier.

### Step 7: Deployment

**Deploy the Custom Module**: Once you’ve thoroughly tested the system, you can deploy the custom Odoo module to your production environment.
**Monitor API Usage**: Keep track of API usage and ensure the IDology service is operational.

### Conclusion
By following the steps above, you can integrate **IDology**’s age verification and document validation API into your **Odoo POS system**. The key steps involve:

Creating a custom Odoo module that interacts with IDology’s API.
Building a frontend UI to capture ID scans.
Implementing backend logic to verify the customer’s age using IDology.
Handling verification results to either allow or block sales based on the customer’s eligibility.

This integration will help you stay compliant with age restrictions while providing a smooth customer experience in your mycology retail business.

MycoPOS Premium Subscription includes all development costs and licensing fees for use with IDology’s API.

Integrating **IDology** into an **Odoo POS system**

Here’s a breakdown of the integration process:

Integrating IDology into an Odoo POS system