+52 55 4336 6356, +52 55 4336 6368 contacto@semantiq.com.mx

Consume la API Rest de SugarCRM con el lenguaje de programación python, en el ejemplo compartimos todas las configuraciones que necesitas.

## Autor Saúl Sandoval
from flask import Flask, jsonify, request
from werkzeug.security import generate_password_hash
from config import config, Sugar
from models import User, db
from hashlib import md5, sha1
import requests
import json

#Creamos nuestra aplicación
def create_app(enviroment):
    app = Flask(__name__)
    app.config['SECRET_KEY'] = 'Secret_key'
    app.config.from_object(enviroment)

    with app.app_context():
        db.init_app(app)
        db.create_all()

    return app

enviroment = config['development']
app = create_app(enviroment)

@app.route('/api/v1/login', methods=['POST'])
def login():
    #Validamos que los datos enviados por el formulario existan en la base de datos
    username = request.form['username']
    password = request.form['password']
    user = User.query.filter_by(username=username).first()
    if (user.username is None or user.password is None):
        return jsonify({'message': 'Usuario no encontrado'}), 404
    #Si los datos son correctos nos actualizará el token del usuario y nos entregará un json con la respuesta.
    if (user.check_password(password)):
        token = User.generate_token(user.username)
        user.set_token(token)
        user.save().update()
        return jsonify({'message': 'Login realizado correctamente', 'token': token, 'expires_in': 60 * 60 * 24})
    return jsonify({'message': 'login incorrecto'}), 404

#Definimos la ruta para conectarnos a SugarCRM
@app.route('/api/v1/sugar/<string:module>', methods=['POST'])
def sugar(module):
    #Llamamos a nuestra clase Sugar() del fichero config.py
    sugar = Sugar()
    #Validamos que el token que nos llegue por el Header sea el mismo que el del usuario en la base de datos
    token = request.headers.get('X-Test_Header')
    current_user = User.query.filter_by(token=token).first()

    #Validamos la caducidad del token
    ttoken = User.verify_time_token(token)
    if ttoken is None or token is None or token != current_user.token:
        return jsonify({'message': 'Token caducado o inválido'})

    #Indicamos los paramátros de SugarCRM
    instance_url = sugar.instance_name
    auth_url = instance_url + "/oauth2/token"
    oauth2_token_arguments = sugar.token_arguments

    #Iniciamos la sesión para la conexión
    s = requests.Session()
    auth_request = s.post(auth_url, data=oauth2_token_arguments) #Indicamos los valores a enviar en la petición
    oauth2_token_response = auth_request.content #Recuperamos el objeto de la respuesta
    oauth2_token_response_obj = json.loads(oauth2_token_response) #Decodificamos el JSON obtenido
    oauth2_token = oauth2_token_response_obj['access_token'] #Tomamos el token de acceso del JSON decodificado

    query = instance_url + '/' + module   #En base al módulo indicado en la ruta
    query_headers = {"OAuth-Token": oauth2_token} #Pasamos el token por los headers
    api = s.get(query, headers=query_headers) #Mandamos la petición a la conexión con los parametros de url y headers
    api_response = api.content     #Obtenemos la respuesta
    api_response_obj = json.loads(api_response)  #Decodificamos el JSON para obtener un objeto
    return jsonify({'content': api_response_obj}) #Mostramos el objeto resultante.

    s.close() #Cerramos la conexión

if __name__ == '__main__':
    app.run(debug=True, port=8000)



#FICHERO CONFIG.PY
class Config:
    pass

#Indicamos los valores de configuración para la base de datos
class DevelopmentConfig(Config):
    DEBUG = True
    SQLALCHEMY_DATABASE_URI = 'mysql://localhost/users'
    SQLALCHEMY_TRACK_MODIFICATIONS = False
    SQLALCHEMY_DATABASE_USER = 'root'
    SQLALCHEMY_DATABASE_PASSWORD = ''

#Generamos la clase Sugar para indicar los datos de la instancia de SUGARCRM a conectarnos
class Sugar():
    instance_name = 'https://gileaddev.sugarondemand.com/rest/v11'
    username = 'S_sandoval'
    password = 'Merefa1210'
    token_arguments = {
        "grant_type": "password",
        "client_id": "sugar",
        "client_secret": "",
        "username": username,
        "password": password,
        "platform": "prueba-apisaul"
    }

#Habilitamos nuestro entorno de desarrollo
config = {
    'development': DevelopmentConfig,
}


#FICHERO MODELS.PY

from flask_sqlalchemy import SQLAlchemy
from itsdangerous import URLSafeTimedSerializer
from werkzeug.security import generate_password_hash, check_password_hash

db = SQLAlchemy()

#Generamos nuestra clase a la que apuntará la Base de datos
class User(db.Model):
    #Indicamos la tabla a usar
    __tablename__ = 'users'

    #Definimos las columnas de la tabla con sus valores
    id = db.Column(db.String(36), primary_key=True, autoincrement=False)
    username = db.Column(db.String(50), nullable=False)
    password = db.Column(db.String(255))
    token = db.Column(db.String(48), nullable=False)
    created_at = db.Column(db.DateTime(), nullable=False,
                           default=db.func.current_timestamp())

    @classmethod
    #Método para crear un usuario
    def create(cls, id, username, password, token):
        user = User(id=id, username=username, password=password, token=token)
        return user.save()

    #Método para guardar
    def save(self):
        try:
            db.session.add(self)
            db.session.commit()

            return self
        except:
            return False

    #Método JSON
    def json(self):
        return {
            'id': self.id,
            'username': self.username,
            'password': self.password,
            'created_at': self.created_at,
            'token': self.token
        }

    #Método para eliminar
    def delete(self):
        try:
            db.session.delete(self)
            db.session.commit()

            return True
        except:
            return False

    def update(self):
        self.save

    #Método para generar el token de acceso
    def generate_token(payload):
        ts = URLSafeTimedSerializer('Secret_key')
        return ts.dumps(obj=payload)

    #Método que valida la caducidad del token
    def verify_time_token(token, max_age=86400):
        ts = URLSafeTimedSerializer('Secret_key')
        return ts.loads(token, max_age=max_age)

    #Método para cifrar la contraseña y setearla al usuario
    def set_password(self, password):
        self.password = generate_password_hash(
            password, method='sha1', salt_length=10)

    #Método que valida el password ingresado con el de la base de datos
    def check_password(self, password):
        return check_password_hash(self.password, password)

    #Método que permite actualizar el token con cada login
    def set_token(self, token):
        self.token = token 

También contamos con una API REST Ejemplo con C#