DEV Community: Fabian Anguiano

How to Programmatically Cancel MRP Records in Odoo

Fabian Anguiano — Thu, 04 Apr 2024 21:50:35 +0000

How to Programmatically Cancel MRP Records in Odoo

Sometimes, it's necessary to cancel specific manufacturing orders (MRPs) due to various reasons such as production issues, changes in demand, or material shortages. This article demonstrates how to programmatically cancel MRP records in Odoo using Python.

Pre-requisites

Before proceeding, ensure you have the following:

Odoo instance accessible via network
Administrative rights or API access credentials
Python environment with xmlrpc.client and requests libraries installed

Step 1: Disable SSL Verification

In a development or testing environment, you might encounter SSL verification issues. The first part of the code disables SSL verification to avoid these problems:

import ssl

try:
    _create_unverified_https_context = ssl._create_unverified_context
except AttributeError:
    # Legacy Python that doesn't verify HTTPS certificates by default
    pass
else:
    # Handle target environment that doesn't support HTTPS verification
    ssl._create_default_https_context = _create_unverified_https_context

Note: Disabling SSL verification in a production environment is not recommended due to security risks.

Step 2: Authenticate with Odoo

You need to authenticate with the Odoo server to access its API. Replace the url, db, username, and password with your Odoo server's details:

import xmlrpc.client

db = 'your_db_name'
url = 'http://your_odoo_server_ip:8069'
username = 'your_username'
password = 'your_password'

ctx = ssl.create_default_context()
ctx.check_hostname = False
ctx.verify_mode = ssl.CERT_NONE

models = xmlrpc.client.ServerProxy('{}/xmlrpc/2/object'.format(url), allow_none=True, verbose=False, use_datetime=True, context=ssl._create_unverified_context())
common = xmlrpc.client.ServerProxy('{}/xmlrpc/2/common'.format(url), allow_none=True, verbose=False, use_datetime=True, context=ssl._create_unverified_context())

uid = common.authenticate(db, username, password, {})

Step 3: Cancel MRP Records

The following code searches for MRP records in the state 'to_close', cancels the associated picking records, and then cancels the MRP records:

mrp_active = models.execute_kw(db, uid, password, 'mrp.production', 'search_read', [[['state', '=', 'to_close']]])

for pick in mrp_active:
    for i in pick['picking_ids']:
        try:
            models.execute_kw(db, uid, password, 'stock.picking', 'action_cancel', [i])
        except Exception as e:
            print('Error canceling picking:', e)
    try:
        models.execute_kw(db, uid, password, 'mrp.production', 'action_cancel', [pick['id']])
        models.execute_kw(db, uid, password, 'mrp.production', 'write', [pick['id'], {'state': 'cancel'}])
        print('MRP record cancelled:', pick['id'])
    except Exception as e:
        print('Error canceling MRP record:', e)

Conclusion

Automating the cancellation of MRP records in Odoo can save time and reduce errors, especially when dealing with multiple records. The approach outlined above provides a basic framework for interacting with Odoo's API, which you can expand based on your specific requirements. Always test your scripts in a development environment before applying them to production to avoid unintended consequences.

Intro to Python's "Lock" w/ Flask

Fabian Anguiano — Tue, 12 Dec 2023 23:41:36 +0000

Mastering Concurrency in Flask with Python's `Lock`

Introduction

In the dynamic world of web development, Python's Flask framework stands out for its simplicity and flexibility. However, as with any web framework, Flask applications can run into concurrency issues, especially when multiple requests try to modify shared resources simultaneously. This article delves into one such challenge and demonstrates how Python's Lock mechanism provides an elegant solution.

The Challenge of Concurrent Requests

Consider a Flask application receiving data through an API endpoint. This data might be processed and stored, or used to modify existing records in a database. Now, imagine multiple requests hitting the endpoint at the same time. Without proper handling, these concurrent requests could lead to race conditions, where the outcome depends on the sequence or timing of the requests. Such scenarios can result in data corruption, duplication of records, or other unintended consequences.

Enter Python's `Lock`

To manage such concurrency issues, Python offers a synchronization mechanism called Lock in its threading module. A lock allows only one thread to access a particular block of code at a time, effectively preventing other threads from executing the same code block until the lock is released.

Implementing `Lock` in Flask

Here's how you can implement a Lock in a Flask route:

Import the Lock:

   from threading import Lock

Initialize the Lock:

   lock = Lock()

Use the Lock in a Route:

   @app.route('/endpoint', methods=['POST'])
   def handle_request():
       with lock:
           # Process the request
           pass
       return 'Request processed', 200

In this setup, when a POST request hits the /endpoint, the with lock: statement ensures that only one request at a time enters the processing block. Subsequent requests wait until the lock is released. This sequential processing guards against the dangers of concurrent access.

Benefits and Considerations

The primary benefit of using Lock is the prevention of race conditions, ensuring data integrity and consistency. However, it's crucial to use locks judiciously. Overuse can lead to bottlenecks, reducing the application's ability to handle high volumes of traffic efficiently.

Conclusion

Concurrency management is a critical aspect of web application development. In Flask, Python's Lock provides a straightforward yet powerful tool to handle concurrent requests safely. By integrating Lock into your Flask routes, you can protect shared resources and maintain the integrity of your application's processes.

If you have any questions or want to connect I am on X

How to send PDF's with Telegram.

Fabian Anguiano — Wed, 06 Dec 2023 21:58:19 +0000

In this article, we will cover how to send a PDF via telegram.
NOTE: This guide assumes you have an API token from Telegram.

Here is the code so you can see it before we start.

import requests

def send_pdf(bot_token, chat_id, pdf_path):
    """
    Send a PDF document to a specific chat using Telegram Bot API.

    :param bot_token: str - Your Telegram bot token
    :param chat_id: str - Your chat id
    :param pdf_path: str - The path to the PDF file you want to send
    """
    method = "sendDocument"
    url = f"https://api.telegram.org/bot{bot_token}/{method}"
    files = {'document': open(pdf_path, 'rb')}
    data = {'chat_id': chat_id}
    response = requests.post(url, files=files, data=data)
    return response.json()  # Returns the result as a JSON object

# Call the function and print the result
result = send_pdf(bot_token, chat_id, pdf_path)
print(result)

Here is a breakdown.

The Function Components

pdf_path:
- Description: This specifies the location of the PDF file you want to send.
- Usage: Replace 'Invoices1.pdf' with the path to your document.
bot_token:
- Description: This is your unique token for interacting with the Telegram bot.
- Usage: Replace YOUR_BOT_TOKEN with the token you received from BotFather.
chat_id:
- Description: This is the identifier for the chat where you want to send your PDF.
- Usage: Replace YOUR_CHAT_ID with the desired chat ID.

Once you set up your parameters, you move on to making the actual request to send the pdf.

Making the Request

Inside the function, the code constructs and sends an HTTP request to the Telegram API:

Method: method = "sendDocument"
- This specifies the action we want our bot to perform - sending a document.
Constructing the URL:
- url = f"https://api.telegram.org/bot{bot_token}/{method}"
- This dynamically creates the request URL using your bot's token.
Preparing the File:
- files = {'document': open(pdf_path, 'rb')}
- This opens your PDF in binary read mode, ready for transmission.
Sending the Request:
- response = requests.post(url, files=files, data=data)
- This sends the file to the specified chat via your bot.

Execution

result = send_pdf(bot_token, chat_id, pdf_path)
print(result)

Once you execute, you will know pretty quickly if the PDF has been sent ! Feel free to comment or contact me with any questions.

You can contact me at X

How to run a internal Flask APK Server

Fabian Anguiano — Wed, 11 Oct 2023 20:56:22 +0000

Flask APK Server

Overview

This Flask application serves an APK file to clients. Developed as a minimalistic solution, the app is designed to be used in a controlled environment with a limited number of users.

Features:

Simple endpoint (/apk) to download the APK.
Endpoint (/test) to test the server's functionality.
Endpoint (/apk-test) to check the presence and size of the APK file.

Flask App:


python
from flask import Flask, send_file
import os

app = Flask(__name__)

@app.route('/apk')
def download_apk():
    apk_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'app.apk')
    return send_file(apk_path, as_attachment=True, download_name='app.apk')

@app.route('/apk-test')
def test_apk():
    apk_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'app.apk')
    try:
        size = os.path.getsize(apk_path)
        return jsonify(status="success", message=f"The APK exists and its size is {size} bytes")
    except OSError:
        return jsonify(status="error", message="The APK does not exist or there's a problem accessing it.")

@app.route('/test')
def test_route():
    return "Test route is working!"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=2000, debug=True)

Automating Product Descriptions in Odoo with OpenAI's GPT-3 and Python

Fabian Anguiano — Fri, 15 Sep 2023 21:24:59 +0000

Introduction

If you're managing an online store or any business that requires a catalog of products, you know how time-consuming it can be to write unique and engaging product descriptions. What if there was a way to automate this process?

In this tutorial, we'll walk you through how to automatically generate product descriptions in Odoo using OpenAI's GPT-3. We'll use Python to bridge the gap between Odoo and OpenAI's API. Don't worry if you're not a coding expert; we'll guide you through each step, including an explanation of the code.

Prerequisites

Odoo Account: You should have an Odoo instance where you can add or update products.
OpenAI API Key: Get an API key from OpenAI by signing up at their Developer Dashboard.
Python 3.x: Make sure Python is installed on your machine. You can download it from here.

For more Python and Odoo scripts, you can check out this GitHub repository: Odoo Unable to Unreserve Fix Script.

Step-by-Step Guide

Step 1: Install Required Python Packages

First, you need to install some Python packages that our script will use. Open your terminal and run:

\bash pip install xmlrpc.client openai configparser \\

Step 2: Create a Configuration File

Create a new text file named config.ini\ in your working directory and paste the following:

\`ini
[OpenAI]
api_key=YOUR_OPENAI_API_KEY

[Odoo]
url=YOUR_ODOO_URL
db=YOUR_ODOO_DB_NAME
username=YOUR_ODOO_USERNAME
password=YOUR_ODOO_PASSWORD
`\

Replace the placeholders with your actual OpenAI API key and Odoo credentials.

Step 3: Write the Python Script

Create a new Python file (main.py\) and paste the script shared at the beginning of this article. Save the file.

Step 4: Understanding the Code

The script is divided into several key parts:

SSL Configuration: This part of the code sets up a secure connection for the script. This is especially important if you're working in an environment that requires secure HTTPS connections but doesn't support HTTPS verification.

\python try: _create_unverified_https_context = ssl._create_unverified_context except AttributeError: pass else: ssl._create_default_https_context = _create_unverified_https_context \\
Loading Configurations: Here, we read the OpenAI and Odoo details from the config.ini\ file you created earlier.

\python config = configparser.ConfigParser() config.read('config.ini') \\
Odoo Login: This part logs you into your Odoo account and sets up the XML-RPC clients needed to interact with Odoo's API.

\python common = xmlrpc.client.ServerProxy('{}/xmlrpc/2/common'.format(url)) uid = common.authenticate(db, username, password, {}) models = xmlrpc.client.ServerProxy('{}/xmlrpc/2/object'.format(url)) \\
Fetching Products: This part fetches the first 100 products from your Odoo database.

\python product_ids = models.execute_kw(db, uid, password, 'product.template', 'search', [[]], {'limit': 100}) \\
Updating Descriptions: Here, for each product, we call the OpenAI API to generate a product description and then update the product in Odoo.

\python for product in products: response = openai.Completion.create( engine="text-davinci-003", prompt=f"Describe the product: {product['name']}", temperature=0.5, max_tokens=100 ) description = response.choices[0].text.strip() \\

Step 5: Run the Script

Open your terminal, navigate to the folder where main.py\ is saved, and run:

\bash python main.py \\

Step 6: Verify the Changes

Log in to your Odoo account and navigate to the products. You should see that the product descriptions have been updated.

Conclusion

Automating product descriptions can save you a lot of time and effort. With just a few lines of Python code, we've created a powerful tool that uses OpenAI's GPT-3 to generate product descriptions and updates them in Odoo. This tutorial not only guides you through how to set up and use the script but also provides an in-depth explanation of how the code works. Happy automating!

Automating AWS WorkSpaces Tier Management with CloudFormation

Fabian Anguiano — Wed, 06 Sep 2023 19:23:58 +0000

Introduction

Managing resources efficiently is crucial in any cloud environment. In the context of AWS WorkSpaces, keeping track of CPU utilization and making timely tier changes can help in optimizing costs and performance. This article presents a CloudFormation template that automatically manages AWS WorkSpaces tiers based on CPU utilization.

AWSTemplateFormatVersion: '2010-09-09'
Resources:
  # CloudWatch Alarms for CPU Utilization
  CpuUtilizationAlarmHigh:
    Type: AWS::CloudWatch::Alarm
    Properties:
      AlarmName: CpuHighUtilizationAlarm
      AlarmDescription: Trigger when CPU Utilization is high
      Namespace: AWS/WorkSpaces
      MetricName: CPUUtilization
      Statistic: Average
      Period: 300
      EvaluationPeriods: 1
      Threshold: 80
      ComparisonOperator: GreaterThanOrEqualToThreshold
      AlarmActions:
        - Ref: TierManagementSNSTopic

  CpuUtilizationAlarmLow:
    Type: AWS::CloudWatch::Alarm
    Properties:
      AlarmName: CpuLowUtilizationAlarm
      AlarmDescription: Trigger when CPU Utilization is low
      Namespace: AWS/WorkSpaces
      MetricName: CPUUtilization
      Statistic: Average
      Period: 300
      EvaluationPeriods: 1
      Threshold: 20
      ComparisonOperator: LessThanOrEqualToThreshold
      AlarmActions:
        - Ref: TierManagementSNSTopic

  # SNS Topic to be triggered by CloudWatch Alarms
  TierManagementSNSTopic:
    Type: AWS::SNS::Topic
    Properties:
      DisplayName: WorkSpaceTierManagement

  # Lambda function to change WorkSpace tier
  WorkSpaceTierChangeLambdaFunction:
    Type: AWS::Lambda::Function
    Properties:
      FunctionName: WorkSpaceTierChange
      Handler: index.handler
      Role: arn:aws:iam::your-account-id:role/execution_role
      Code:
        ZipFile: |
          import boto3
          import json

          workspaces_client = boto3.client('workspaces')

          def handler(event, context):
              sns_message = json.loads(event['Records'][0]['Sns']['Message'])
              alarm_name = sns_message.get('AlarmName', 'default-alarm')

              # Fetch all WorkSpaces in a specific directory
              directory_id = "your-directory-id-here"
              workspaces = workspaces_client.describe_workspaces(DirectoryId=directory_id)['Workspaces']

              for workspace in workspaces:
                  workspace_id = workspace['WorkspaceId']

                  if 'High' in alarm_name:
                      change_workspace_tier(workspace_id, 'POWERPRO')
                  elif 'Low' in alarm_name:
                      change_workspace_tier(workspace_id, 'POWER')

          def change_workspace_tier(workspace_id, new_tier):
              try:
                  response = workspaces_client.modify_workspace_properties(
                      WorkspaceId=workspace_id,
                      WorkspaceProperties={
                          'ComputeTypeName': new_tier
                      }
                  )
                  print(f"Changed tier of {workspace_id} to {new_tier}")
              except Exception as e:
                  print(f"Failed to change tier: {e}")

      Runtime: python3.8
      Timeout: 5

  # SNS Subscription to Lambda
  SNSTopicSubscription:
    Type: AWS::SNS::Subscription
    Properties:
      Protocol: lambda
      TopicArn: !Ref TierManagementSNSTopic
      Endpoint: !GetAtt [WorkSpaceTierChangeLambdaFunction, Arn]

The CloudFormation template comprises the following key components:

1. CloudWatch Alarms

Two CloudWatch Alarms are defined:

CpuUtilizationAlarmHigh: Triggers when CPU Utilization is above 80%.
CpuUtilizationAlarmLow: Triggers when CPU Utilization is below 20%.

2. SNS Topic

The TierManagementSNSTopic is an SNS Topic that will receive notifications from the CloudWatch Alarms.

3. Lambda Function

The WorkSpaceTierChangeLambdaFunction is triggered when an SNS notification is received. It changes the tier of WorkSpaces based on the alarm conditions.

4. SNS Subscription

The SNSTopicSubscription subscribes the Lambda function to the SNS Topic, allowing the function to be invoked when an alarm triggers.

Pre-requisites

AWS CLI installed and configured
A valid AWS WorkSpaces setup
IAM role with sufficient permissions for CloudWatch and WorkSpaces (execution_role)

Deployment Instructions

Follow these steps to deploy the CloudFormation template:

1. Validate the Template

First, validate the CloudFormation template to ensure it is well-formed.

aws cloudformation validate-template --template-body file://path/to/template.yaml

2. Upload the Template to S3 (Optional)

You can upload the template to an S3 bucket if it's too large or if you prefer to keep it centralized.

aws s3 cp path/to/template.yaml s3://your-s3-bucket/

3. Deploy the Stack

You can deploy the CloudFormation stack using the AWS CLI.

# If template is local
aws cloudformation create-stack --stack-name WorkSpacesTierManagement --template-body file://path/to/template.yaml

# Or if template is in S3
aws cloudformation create-stack --stack-name WorkSpacesTierManagement --template-url https://s3.amazonaws.com/your-s3-bucket/template.yaml

4. Monitor the Stack

You can monitor the status of the stack in the AWS CloudFormation console or via the AWS CLI.

aws cloudformation describe-stacks --stack-name WorkSpacesTierManagement

Conclusion

This CloudFormation template offers an automated approach to manage AWS WorkSpaces tiers based on CPU utilization, thus optimizing resource usage. Deploying this stack in your AWS environment can significantly streamline your WorkSpaces management process.

Serving Dynamically Generated PDFs in Django Production

Fabian Anguiano — Thu, 17 Aug 2023 22:02:28 +0000

Serving Dynamically Generated PDFs in Django

In many Django projects, there's a need to generate and serve files dynamically. One common scenario is generating PDFs on-the-fly based on user interactions. Here are various strategies to handle such cases, especially when serving these files with Django both in development (DEBUG=True) and in production (DEBUG=False).

1. Using a dedicated directory for generated files:

Step-by-Step Implementation:

Create a Directory: Set up a directory named generated_pdfs at the root level of your project.
Update urls.py:

Add the following to your urls.py to serve files from the generated_pdfs directory:

from django.views.static import serve
from django.conf import settings
import os

path('generated_pdfs/<path:path>/', serve, {'document_root': os.path.join(settings.BASE_DIR, 'generated_pdfs')}),

Modify the PDF generation logic:

When saving the dynamically generated PDF, ensure it's saved to the generated_pdfs directory.

Access the PDFs:

After generating a PDF, it can be accessed via: http://localhost:8000/generated_pdfs/<pdf_name>.pdf

2. Using Django's static file handling:

This method involves treating the generated PDFs like any other static file in Django, but it requires running the collectstatic command each time a new file is generated.

Step-by-Step Implementation:

Save the PDF: When generating a new PDF, save it in Django's static directory.
Automate collectstatic after PDF generation:
To ensure the newly generated PDFs are available immediately, run the collectstatic command after generating a PDF. You can automate this by adding the following logic in your PDF generation view:

from django.core.management import call_command

# ... Your PDF generation logic ...

# After saving the PDF, run collectstatic
call_command('collectstatic', '--noinput')

Serving in Production: In a production environment, ensure that you've set up a web server or a CDN to serve the static files.

Troubleshooting:

If you encounter a HTTP 500 error, check the Django development server console logs for detailed error messages.
Ensure the generated_pdfs directory and the files within have the appropriate read permissions.
In the case of conflicting URL patterns, Django evaluates them in order. Ensure that no pattern above the generated_pdfs pattern is catching the request first.

Follow me on Twitter

A Guide to Pagination in the 3dcart API: Fetching Sales Data

Fabian Anguiano — Tue, 04 Jul 2023 19:11:48 +0000

Introduction

Working with APIs often involves retrieving large amounts of data. To efficiently handle all of this data, pagination is a crucial technique. This article aims to guide you through the process of implementing pagination with the 3dcart API, using a Python script as an example. By the end, you'll have a clear understanding of how to fetch sales data from the 3dcart API using pagination.

Prerequisites

Before diving into pagination, ensure you have the following prerequisites:

Basic knowledge of Python programming.
Familiarity with making API requests using Python.

Setting Up the Script

To begin, let's set up a script that fetches sales data from the 3dcart API. The script provided below serves as a starting point:

# Import the necessary libraries
import requests
import json
import time

def fetch_sales_data_from_api(sales_order_names):
    # Load headers from the config file
    with open('config.json') as config_file:
        config = json.load(config_file)

    # Set up the base URL and headers
    base_url = "https://apirest.3dcart.com/3dCartWebAPI/v1/Orders"
    headers = {
        'SecureURL': config['SecureURL'],
        'PrivateKey': config['PrivateKey'],
        'Token': config['Token']
    }

    # Set pagination parameters
    limit = 100  # Number of results per page
    offset = 0   # Initial offset value
    max_retries = 3

    all_order_data = []

    # Iterate over the order statuses
    for order_status in sales_order_names:
        # Remove the "WH-" prefix from the order status
        invoice_number = order_status.replace("WH-", "")

        # Reset the offset for each order status
        offset = 0

        # Construct the initial URL
        url = f"{base_url}?invoicenumber={invoice_number}&limit={limit}&offset={offset}"

        # Retry logic
        success = False
        retries = 0

        while not success and retries < max_retries:
            response = requests.request("GET", url, headers=headers)

            if response.status_code == 200:
                success = True
                print(f"Successfully fetched data from {url}")
                orders = response.json()
                if orders:
                    all_order_data.extend(orders)
                break

            else:
                print("Retrying...")
                retries += 1
                time.sleep(10)

        if not success:
            print("Failed to fetch data after multiple retries.")

    return all_order_data

What is Pagination ?

Pagination is a technique used to retrieve large amounts of data in manageable chunks or pages. The 3dcart API supports pagination by allowing you to specify the limit and offset parameters in your API requests.

The limit parameter determines the number of results per page.
The offset parameter indicates the starting position of the data to be retrieved.

Basically think of pagination as breaking up large chunks of data to sort data faster.

Implementing Pagination

In the provided script, pagination is implemented in the fetch_sales_data_from_api function. Here's a breakdown of how it works:

The script loads the necessary headers from a configuration file (config.json).
It sets up the base URL and constructs the headers for the API request.
Pagination parameters are defined:
- limit: The number of results to retrieve per page. In the example, it's set to 100.
- offset: The initial starting position. It's reset for each order status in the loop.
The script initializes an empty list, all_order_data, to store the fetched order data.
For each order status, the script constructs the URL by combining the base URL, the invoice number (with the "WH-" prefix removed), the limit, and the offset.
A retry loop is implemented to handle potential failures during the API request. It tries up to max_retries times, with a 10-second delay between retries.
Upon a successful response (status code 200), the script extracts the orders data from the response and appends it to the all_order_data list.
If the maximum number of retries is reached without success, an appropriate message is printed.
Finally, the function returns the complete all_order_data list.

Conclusion

In this article, we explored how to implement pagination when working with the 3dcart API. By using the provided script as a starting point, you can fetch sales data from the API while handling pagination seamlessly. Remember to adapt the script and configuration file to suit your specific requirements.

Pagination is a powerful technique that allows you to work with large datasets more efficiently. With this knowledge, you're now equipped to fetch data from the 3dcart API using pagination effectively.

Here is a gist of the code
https://gist.github.com/tunahorse/01d74fd67af06b625ce5c59481f906d9

Follow me on twitter

Create a Odoo email sales report, with Python.

Fabian Anguiano — Mon, 26 Jun 2023 21:18:50 +0000

Odoo Email Noty: Sales Reporting Tool

I created a Python script helps you conveniently pull sales data from your Odoo server and compile it into a detailed email report.

Here is the repo.

https://github.com/tunahorse/Odoo_email_noty

Features

Pull sales data from an Odoo server
Segment sales data
Generate a detailed report of total orders and total amounts for both segments
Send the generated report via email, customized with the details of each order

Get user input for date

date_input = input("Please enter a dateThe script you've provided is a Python script that pulls sales data from an Odoo server and sends an email with the sales report. The report contains a summary of total orders and the total order amount, as well as details of each order.

Here's a detailed breakdown of what each part of the script does:

The script starts by importing several Python libraries which are required for its operation:

- `xmlrpc.client`: This is used to make remote procedure call (RPC) to the Odoo server.
- `ssl`: This is used to create a secure connection to the Odoo server.
- `datetime`, `date`, `timedelta`: These are used to manipulate dates.
- `email.mime.multipart` and `email.mime.text`: These are used to create and manipulate the email to be sent.
- `smtplib`: This is used to send the email.
- `configparser`: This is used to read the configuration file which contains the necessary details to connect to the Odoo server and the email server.
- `pprint`: This is used to pretty-print data for debugging purposes.

The script reads the configuration file named 'config.ini' using configparser. This file contains necessary information such as the Odoo server details (URL, database name, username, and password) and the email server details (SMTP server, port, from address, to address, and password).
It creates an SSL context to allow connection to a self-signed Odoo server.
It connects to the Odoo server using xmlrpc.client.ServerProxy and authenticates with the server using the username and password from the config file.
It takes user input for a date. If no date is entered or if the entered date is not valid, it uses today's date.
It fetches sales data from the Odoo server using the models.execute_kw function. It uses the 'sale.order' model and the 'search_read' method to fetch sales orders for the specified date.
It calculates the total number of orders and the total order amount by iterating over the fetched sales data.
It creates an email using MIMEMultipart and sets the 'From', 'To', and 'Subject' fields.
It creates the body of the email by adding the total number of orders and the total order amount. It then iterates over the sales data again to add the details of each order to the email body.
It attaches the body to the email using msg.attach.
It connects to the SMTP server using smtplib.SMTP, logs in with the 'From' email address and password, and sends the email using server.sendmail.
Finally, it disconnects from the SMTP server using server.quit.

Remember to replace all the placeholder values in the 'config.ini' file with your actual details, and also make sure that the Odoo server is properly set up and contains the 'sale.order' model with the required fields.

Managing Duplicate Sales Records in Odoo Using Python

Fabian Anguiano — Wed, 24 May 2023 20:32:15 +0000

I recently had a situation where an Odoo instance was importing sales from multiple sales channels, due to the nature of the import process some sales got created twice. Technically sales records with the same name should not allowed, but alas here we are.

I made this script to find any records with the same name.

import xmlrpc.client

# Odoo details
url = 'your_url'
db = 'your_db'
username = 'your_username'
password = 'your_password'

# Get the uid
common = xmlrpc.client.ServerProxy('{}/xmlrpc/2/common'.format(url))
uid = common.authenticate(db, username, password, {})

# Get the models
models = xmlrpc.client.ServerProxy('{}/xmlrpc/2/object'.format(url))

# Search for sales order records
sales_order_ids = models.execute_kw(db, uid, password,
    'sale.order', 'search',
    [[]])

# Read the sales order records
sales_orders = models.execute_kw(db, uid, password,
    'sale.order', 'read',
    [sales_order_ids])

# Dictionary to store the count of each record
record_count = {}

# Go through each sales order
for order in sales_orders:
    # If the order name is not in the record_count
    if order['name'] not in record_count:
        # Add it with a count of 1
        record_count[order['name']] = 1
    else:
        # If it is already there, increment the count
        record_count[order['name']] += 1

# Print the repeated records
for record, count in record_count.items():
    if count > 1:
        print(f"\033[91m Multiple sales records: {record} \033[0m")

ChatGPT == Slack: The Impact of User Base on the Workflow Stack

Fabian Anguiano — Mon, 22 May 2023 18:42:18 +0000

In the digital landscape, many tools and platforms vie for dominance in the enterprise ecosystem. Among these, chat and collaboration tools like Slack and AI-based language models like ChatGPT, a product from OpenAI, have become staples of the modern workflow stack. While these tools may seem dissimilar, their success is deeply rooted in the same concept: User adoption and seamless integration within the workflow stack. In this article, we'll explore how these tools affect the workflow stack and why enterprises tend to adopt them, focusing on the case of ChatGPT's triumph over its competitor, Bard.

Understanding the Workflow Stack

Before we delve into comparisons, let's define the "workflow stack". The workflow stack is an enterprise's unique combination of tools and software that streamline business processes. These can include anything from project management software to AI-assisted language models that help generate content. Slack, an instant messaging platform, is commonly found in the workflow stack due to its functionality for team communication and project collaboration.

ChatGPT, on the other hand, is an AI language model that provides different services, such as drafting emails, creating content, coding assistance, and more. Its flexibility and multi-functionality make it a valuable addition to the workflow stack.

The Power of User Adoption: Slack's Story

Slack's dominance in the market comes from its widespread adoption. Even though there might be arguably superior tools, the sheer number of users who have already integrated Slack into their workflow stack makes it a hard-to-replace element of many enterprises. Slack's easy-to-use interface, seamless integration with other tools, and efficient communication system have made it the go-to choice for team collaboration.

Enterprises often have to pay the fees associated with Slack, not necessarily because it's the best tool available, but because it is so deeply ingrained in their workflow stack. Switching to a different tool would mean massive training costs, disruption of work, and potential communication breakdowns - all costs that most businesses would rather avoid.

The ChatGPT Advantage: User Adoption and Flexibility

Much like Slack, ChatGPT's success is also largely determined by its user base. However, ChatGPT's victory over competitors like Bard is rooted in two main factors: user adoption and flexibility.

ChatGPT boasts a large user base, which continues to grow thanks to its ability to provide diverse solutions. This wide user adoption not only signifies its current triumph but also suggests a prosperous future. As more users integrate ChatGPT into their workflow stack, its usefulness and value within the enterprise ecosystem grow.

Moreover, ChatGPT offers an unparalleled level of flexibility. It's not limited to one function but provides a range of services, from generating content to drafting emails and even assisting in coding. This multi-functionality allows enterprises to use it in different aspects of their workflow stack, reinforcing its adoption and further solidifying its position within the stack.

Conclusion

User adoption and integration within the workflow stack are critical success factors for digital tools. Both Slack and ChatGPT exemplify how a large user base and seamless integration can secure a tool's place within the enterprise workflow stack.

While Slack's place is maintained more due to the costs and complications associated with switching, ChatGPT is securing its future through widespread user adoption and versatility. As we look to the future of work, it will be interesting to see how these factors continue to shape the tools that become integral parts of our workflow stacks.

Will Google's BARD Fall Flat?

Fabian Anguiano — Wed, 17 May 2023 16:16:21 +0000

Google's Bard, a collaborative AI tool, has been making waves since its launch less than two months ago. It started as an experiment that allowed users to interact with AI in new and creative ways, and the response from users has been largely positive. With its rapid evolution, Bard has been able to incorporate advanced math and reasoning skills, and even coding capabilities, making it one of the most versatile tools in the AI landscape today¹.

While the introduction of new features and the expansion of Bard into more countries suggests a bright future for the product², some observers have raised concerns about Google's track record with ambitious projects.

There's no denying that Google's history of terminating projects raises doubts about Bard's future. From Google Optimize to Google Cloud IoT Core, the tech giant has a long list of 285 services that it has killed off over the years³. This "Google Graveyard" has led many to wonder if Bard will eventually meet the same fate.

The nature of large organizations like Google can be a double-edged sword. On one hand, their resources allow for ambitious projects like Bard to be conceived and developed. On the other hand, the bureaucratic nature of large corporations often leads to slow decision-making processes and a lack of agility. This can negatively impact the usability of their products.

For example, Google's previous attempts at social networks, Google Plus and Google Buzz, faced criticism for their confusing user interfaces and lack of unique features. These projects were eventually terminated. The lessons from these experiences must be kept in mind as Google continues to develop and improve Bard.

One of the central themes of the HBO series "Silicon Valley" is the struggle of innovators against corporate giants. In one memorable scene, Hooli, the show's Google-esque tech behemoth, attempts to reverse engineer a rival's product. Despite having a team of skilled engineers and vast resources, the project falls behind schedule⁴. This fictional scenario echoes real concerns about Google's ability to deliver on its ambitious AI projects. The "behind schedule" scene from "Silicon Valley" serves as a humorous but pointed reminder of the potential pitfalls that Google's Bard could face in its developmental journey.

Despite these concerns, it's important to note that Bard is still in its early stages, and Google has demonstrated a commitment to its development and improvement. The recent updates, including the integration of Google Lens and new coding features, suggest that Google is serious about making Bard a long-term project⁵⁶⁷.

However, only time will tell if Bard can avoid the fate of its predecessors and become a lasting part of Google's product suite. Will Bard become another tombstone in the Google Graveyard or will it defy the odds and become a lasting success? That's a story still being written.

Yes, this was written with ChatGPT, I tried to use Bard but the result were subpar.

source ↩
source ↩
source ↩
source ↩
source ↩
source ↩
source ↩

DEV Community: Fabian Anguiano

How to Programmatically Cancel MRP Records in Odoo

How to Programmatically Cancel MRP Records in Odoo

Pre-requisites

Step 1: Disable SSL Verification

Step 2: Authenticate with Odoo

Step 3: Cancel MRP Records

Intro to Python's "Lock" w/ Flask

Mastering Concurrency in Flask with Python's Lock

Introduction

The Challenge of Concurrent Requests

Enter Python's Lock

Implementing Lock in Flask

Benefits and Considerations

Conclusion

How to send PDF's with Telegram.

The Function Components

Making the Request

Execution

How to run a internal Flask APK Server

Flask APK Server

Overview

Features:

Flask App:

Automating Product Descriptions in Odoo with OpenAI's GPT-3 and Python

Introduction

Prerequisites

Step-by-Step Guide

Step 1: Install Required Python Packages

Step 2: Create a Configuration File

Step 3: Write the Python Script

Step 4: Understanding the Code

Step 5: Run the Script

Step 6: Verify the Changes

Conclusion

Automating AWS WorkSpaces Tier Management with CloudFormation

Introduction

1. CloudWatch Alarms

2. SNS Topic

3. Lambda Function

4. SNS Subscription

Pre-requisites

Deployment Instructions

1. Validate the Template

2. Upload the Template to S3 (Optional)

3. Deploy the Stack

4. Monitor the Stack

Conclusion

Serving Dynamically Generated PDFs in Django Production

Serving Dynamically Generated PDFs in Django

1. Using a dedicated directory for generated files:

Step-by-Step Implementation:

2. Using Django's static file handling:

Step-by-Step Implementation:

Troubleshooting:

A Guide to Pagination in the 3dcart API: Fetching Sales Data

Introduction

Prerequisites

Setting Up the Script

What is Pagination ?

Implementing Pagination

Conclusion

Create a Odoo email sales report, with Python.

Odoo Email Noty: Sales Reporting Tool

Features

Get user input for date

Managing Duplicate Sales Records in Odoo Using Python

ChatGPT == Slack: The Impact of User Base on the Workflow Stack

Understanding the Workflow Stack

The Power of User Adoption: Slack's Story

The ChatGPT Advantage: User Adoption and Flexibility

Conclusion

Will Google's BARD Fall Flat?

Mastering Concurrency in Flask with Python's `Lock`

Enter Python's `Lock`

Implementing `Lock` in Flask