odoo

README

odoo-models-connect

Cliente en Go para conectarse a Odoo utilizando XML-RPC. Esta librería permite realizar operaciones CRUD, mapear datos a estructuras Go.

Tabla de Contenidos

• odoo-models-connect
  • Tabla de Contenidos
  • Características
  • Requisitos
  • Instalación
  • Configuración
  • Uso
    • Inicializar el Cliente
    • Operaciones CRUD
      • Crear un Registro
      • Leer Registros
      • Actualizar un Registro
      • Eliminar un Registro
    • Mapeo de Modelos
      • Definir una Estructura
      • Mapear Datos a la Estructura
    • Procesamiento en Paralelo con Goroutines
      • Ejemplo de Procesamiento en Paralelo
  • Ejemplos
  • Estructura del Proyecto
  • Notas Importantes
  • Contribuciones
  • Licencia

Características

• Conexión a Odoo mediante XML-RPC.
• Autenticación y manejo de sesiones.
• Operaciones CRUD (Crear, Leer, Actualizar, Eliminar).
• Mapeo de datos a estructuras Go.
• Procesamiento paralelo utilizando goroutines y canales.
• Manejo de errores personalizado.

Requisitos

• Go 1.13 o superior.
• Acceso a una instancia de Odoo con las credenciales adecuadas.
• Las siguientes dependencias de Go:
  • github.com/kolo/xmlrpc
  • github.com/joho/godotenv
  • github.com/mitchellh/mapstructure

Instalación

Clona este repositorio o copia los archivos necesarios en tu proyecto.

git clone github.com/DeijoseDevelop/odoo-models-connect.git
cd odoo-models-connect

Instala las dependencias:

go get github.com/kolo/xmlrpc
go get github.com/joho/godotenv
go get github.com/mitchellh/mapstructure

Configuración

Crea un archivo .env en el directorio raíz del proyecto con las siguientes variables:

DATABASE=nombre_de_tu_base_de_datos
USERNAME=tu_usuario
PASSWORD=tu_contraseña
URL=http://tu_dominio_odoo.com

Asegúrate de reemplazar los valores con tus credenciales y URL de Odoo.

Uso

Inicializar el Cliente

Importa los paquetes necesarios y crea una instancia de OdooClient:

package main

import (
    "fmt"
    "github.com/DeijoseDevelop/odoo-models-connect" // Importa tu paquete adecuadamente
)

func main() {
    client, err := odoo.NewOdooClient(".env")
    if err != nil {
        fmt.Println("Error al inicializar el cliente Odoo:", err)
        return
    }
    // Ahora puedes usar el cliente para realizar operaciones
}

Operaciones CRUD

Crear un Registro

data := map[string]interface{}{
    "name":  "Nuevo Cliente",
    "email": "cliente@example.com",
}
id, err := client.Create("res.partner", data)
if err != nil {
    fmt.Println("Error al crear el registro:", err)
    return
}
fmt.Println("Registro creado con ID:", id)

Leer Registros

domain := []interface{}{[]interface{}{"is_company", "=", true}}
fields := []string{"id", "name", "email"}
records, err := client.SearchRead("res.partner", domain, fields)
if err != nil {
    fmt.Println("Error al leer los registros:", err)
    return
}
for _, record := range records {
    fmt.Println("Registro:", record)
}

Actualizar un Registro

updateData := map[string]interface{}{
    "email": "nuevo.email@example.com",
}
success, err := client.Update("res.partner", []int{id}, updateData)
if err != nil || !success {
    fmt.Println("Error al actualizar el registro:", err)
    return
}
fmt.Println("Registro actualizado exitosamente")

Eliminar un Registro

success, err := client.Delete("res.partner", []int{id})
if err != nil || !success {
    fmt.Println("Error al eliminar el registro:", err)
    return
}
fmt.Println("Registro eliminado exitosamente")

Mapeo de Modelos

Define estructuras que representen tus modelos de Odoo y utiliza la función MapToStruct para mapear los datos.

Definir una Estructura

type ResPartner struct {
    ID        int    `json:"id"`
    Name      string `json:"name"`
    Email     string `json:"email"`
    IsCompany bool   `json:"is_company"`
}

Mapear Datos a la Estructura

for _, record := range records {
    var partner ResPartner
    if err := odoo.MapToStruct(record, &partner); err != nil {
        fmt.Println("Error al mapear el registro:", err)
        continue
    }
    fmt.Println("Partner:", partner)
}

Procesamiento en Paralelo con Goroutines

Si necesitas procesar muchos datos, puedes utilizar goroutines y canales para mejorar el rendimiento.

Ejemplo de Procesamiento en Paralelo

import (
    "sync"
)

func main() {
    // ... Inicializar cliente ...

    // Obtener IDs de los registros
    domain := []interface{}{}
    ids, err := client.Search("res.partner", domain)
    if err != nil {
        fmt.Println("Error al obtener IDs:", err)
        return
    }

    // Procesar en lotes
    batchSize := 100
    var batches [][]int
    for batchSize < len(ids) {
        ids, batches = ids[batchSize:], append(batches, ids[0:batchSize:batchSize])
    }
    batches = append(batches, ids)

    var wg sync.WaitGroup
    partnersChannel := make(chan ResPartner, len(ids))

    for _, batch := range batches {
        wg.Add(1)
        go func(batch []int) {
            defer wg.Done()
            domain := []interface{}{[]interface{}{"id", "in", batch}}
            fields := []string{"id", "name", "email", "is_company"}
            records, err := client.SearchRead("res.partner", domain, fields)
            if err != nil {
                fmt.Println("Error al obtener registros:", err)
                return
            }
            for _, record := range records {
                var partner ResPartner
                if err := odoo.MapToStruct(record, &partner); err != nil {
                    fmt.Println("Error al mapear el registro:", err)
                    continue
                }
                partnersChannel <- partner
            }
        }(batch)
    }

    go func() {
        wg.Wait()
        close(partnersChannel)
    }()

    for partner := range partnersChannel {
        fmt.Println("Partner:", partner)
    }
}

Ejemplos

Consulta el archivo example.go para ver ejemplos completos de cómo utilizar la librería, incluyendo operaciones CRUD y procesamiento paralelo (si copias y pegas, agrega la palabra "odoo" antes de cada componente, ejemplo: odoo.NewOdooClient()).

Estructura del Proyecto

odoo-models-connect/
├── client.go         // Contiene OdooClient y métodos
├── errors.go         // Tipos de error personalizados
├── models.go         // Definiciones de modelos y mapeadores
├── utils.go          // Funciones utilitarias
├── main.go           // Uso de ejemplo
├── .env              // Variables de entorno (no incluir en control de versiones)
└── README.md         // Instrucciones de uso (este archivo)

Notas Importantes

• Manejo de Errores: Siempre maneja los errores devueltos por las funciones para evitar comportamientos inesperados.
• Tipos de Datos: Verifica los tipos de datos al mapear los resultados. Algunos campos pueden ser int64, float64, etc.
• Campos Nulos: Ten cuidado con los campos que pueden ser nil o no estar presentes en los datos retornados.
• Concurrencia: Al utilizar goroutines, asegúrate de manejar adecuadamente la sincronización y los recursos compartidos.
• Variables de Entorno: No incluyas el archivo .env en tu control de versiones ya que contiene información sensible.

Contribuciones

Las contribuciones son bienvenidas. Si deseas mejorar la librería o agregar nuevas funcionalidades, por favor:

1. Haz un fork del proyecto.
2. Crea una rama para tu nueva funcionalidad (git checkout -b nueva-funcionalidad).
3. Realiza tus cambios y haz commit (git commit -am 'Agregar nueva funcionalidad').
4. Envía tus cambios a GitHub (git push origin nueva-funcionalidad).
5. Crea un Pull Request.

Licencia

Este proyecto está bajo la Licencia MIT. Consulta el archivo LICENSE para más detalles.

Documentation

Index

• func ConvertImageToBase64(imagePath string) (string, error)
• func MapToStruct(data map[string]interface{}, result interface{}) error
• func PrintModel(model interface{})
• type AccessDeniedError
  • func (e *AccessDeniedError) Error() string
• type AccountMove
• type ObjectDoesNotExistError
  • func (e *ObjectDoesNotExistError) Error() string
• type OdooClient
  • func NewOdooClient(envPath string) (*OdooClient, error)
  • func (c *OdooClient) Create(model string, data map[string]interface{}) (int, error)
  • func (c *OdooClient) Delete(model string, ids []int) (bool, error)
  • func (c *OdooClient) Search(model string, domain []interface{}) ([]int, error)
  • func (c *OdooClient) SearchRead(model string, domain []interface{}, fields []string) ([]map[string]interface{}, error)
  • func (c *OdooClient) Update(model string, ids []int, data map[string]interface{}) (bool, error)
• type ProductProduct
• type ResPartner

Functions

func ConvertImageToBase64

func ConvertImageToBase64(imagePath string) (string, error)

Función para convertir una imagen a base64

func MapToStruct

func MapToStruct(data map[string]interface{}, result interface{}) error

Función genérica para mapear datos a estructuras

func PrintModel

func PrintModel(model interface{})

Ejemplo de función para mostrar información de cualquier modelo

Types

type AccessDeniedError

type AccessDeniedError struct {
	Message string
}

Error personalizado para acceso denegado

func (*AccessDeniedError) Error

func (e *AccessDeniedError) Error() string

type AccountMove

type AccountMove struct {
	ID          int     `json:"id"`
	Name        string  `json:"name"`
	PartnerID   int     `json:"partner_id"`
	InvoiceDate string  `json:"invoice_date"`
	AmountTotal float64 `json:"amount_total"`
	State       string  `json:"state"`
}

type ObjectDoesNotExistError

type ObjectDoesNotExistError struct {
	ID int
}

Error cuando un objeto no existe

func (*ObjectDoesNotExistError) Error

func (e *ObjectDoesNotExistError) Error() string

type OdooClient

type OdooClient struct {
	Database string
	Username string
	Password string
	URL      string
	UID      int
	// contains filtered or unexported fields
}

func NewOdooClient

func NewOdooClient(envPath string) (*OdooClient, error)

Inicializa el cliente Odoo y autentica

func (*OdooClient) Create

func (c *OdooClient) Create(model string, data map[string]interface{}) (int, error)

func (*OdooClient) Delete

func (c *OdooClient) Delete(model string, ids []int) (bool, error)

func (*OdooClient) Search

func (c *OdooClient) Search(model string, domain []interface{}) ([]int, error)

Método para obtener IDs utilizando execute

func (*OdooClient) SearchRead

func (c *OdooClient) SearchRead(model string, domain []interface{}, fields []string) ([]map[string]interface{}, error)

Implementación de operaciones CRUD utilizando el método execute

func (*OdooClient) Update

func (c *OdooClient) Update(model string, ids []int, data map[string]interface{}) (bool, error)

type ProductProduct

type ProductProduct struct {
	ID            int     `json:"id"`
	Name          string  `json:"name"`
	Type          string  `json:"type"`
	SaleOk        bool    `json:"sale_ok"`
	PurchaseOk    bool    `json:"purchase_ok"`
	ListPrice     float64 `json:"list_price"`
	StandardPrice float64 `json:"standard_price"`
}

type ResPartner

type ResPartner struct {
	ID        int    `json:"id"`
	Name      string `json:"name"`
	Email     string `json:"email"`
	IsCompany bool   `json:"is_company"`
}