audrius/report-print-send
1
0
Fork 0
mirror of https://github.com/OCA/report-print-send.git synced 2025-02-16 07:11:31 +02:00
Code Issues Packages Projects Releases Wiki Activity

Pingen: API v2 changes

Browse Source
This commit is contained in:
Anna Janiszewska
2023-01-30 12:56:55 +01:00
parent 0529340243
commit b72b28f004
14 changed files with 814 additions and 304 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
pingen/__init__.py
View File

@@ -1,5 +1,5 @@
# Author: Guewen Baconnier
# Copyright 2012-2017 Camptocamp SA
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from . import controllers
from . import models

4
pingen/__manifest__.py
View File

@@ -4,7 +4,7 @@
{
"name": "pingen.com integration",
"version": "10.0.1.0.0",
"version": "10.0.2.0.0",
"author": "Camptocamp,Odoo Community Association (OCA)",
"maintainer": "Camptocamp",
"license": "AGPL-3",
@@ -12,7 +12,7 @@
"complexity": "easy",
"depends": ["base_setup"],
"external_dependencies": {
"python": ["requests"],
"python": ["requests_oauthlib"],
},
"website": "https://github.com/OCA/report-print-send",
"data": [

1
pingen/controllers/__init__.py Normal file
View File

@@ -0,0 +1 @@
from . import main

141
pingen/controllers/main.py Normal file
View File

@@ -0,0 +1,141 @@
# Copyright 2022 Camptocamp SA
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl)
import hashlib
import hmac
import json
import logging
import werkzeug
from odoo import http
from ..models.pingen import pingen_datetime_to_utc
_logger = logging.getLogger(__name__)
class PingenController(http.Controller):
def _verify_signature(self, request_content):
webhook_signature = http.request.httprequest.headers.get("Signature")
companies = (
http.request.env["res.company"]
.sudo()
.search([("pingen_webhook_secret", "!=", False)])
)
for company in companies:
secret_signature = hmac.new(
company.pingen_webhook_secret.encode("utf-8"),
request_content,
hashlib.sha256,
).hexdigest()
if webhook_signature == secret_signature:
return company
msg = "Webhook signature does not match with any company secret"
_logger.warning(msg)
raise werkzeug.exceptions.Forbidden()
def _get_request_content(self):
return http.request.httprequest.stream.read()
def _get_json_content(self, request_content):
return json.loads(request_content)
def _get_document_uuid(self, json_content):
return (
json_content.get("data", {})
.get("relationships", {})
.get("letter", {})
.get("data", {})
.get("id", "")
)
def _find_pingen_document(self, document_uuid):
if document_uuid:
return http.request.env["pingen.document"].search(
[("pingen_uuid", "=", document_uuid)]
)
return http.request.env["pingen.document"].browse()
def _get_error_reason(self, json_content):
return json_content.get("data", {}).get("attributes", {}).get("reason", "")
def _get_letter_infos(self, json_content, document_uuid):
for node in json_content.get("included", {}):
if node.get("type") == "letters" and node.get("id") == document_uuid:
return node.get("attributes", {})
return {}
def _get_emitted_date(self, json_content):
emitted_at = ""
for node in json_content.get("included", {}):
if node.get("type") == "letters_events":
attributes = node.get("attributes", {})
if attributes.get("code") == "transferred_to_distributor":
emitted_at = attributes.get("emitted_at", "")
break
return pingen_datetime_to_utc(emitted_at.encode())
def _update_pingen_document(self, request_content, values):
json_content = self._get_json_content(request_content)
document_uuid = self._get_document_uuid(json_content)
pingen_doc = self._find_pingen_document(document_uuid)
if pingen_doc:
info_values = pingen_doc._prepare_values_from_post_infos(
self._get_letter_infos(json_content, document_uuid)
)
info_values.update(values)
pingen_doc.sudo().write(info_values)
msg = "Pingen document with UUID %s updated successfully" % document_uuid
_logger.info(msg)
return msg
msg = "Could not find related Pingen document for UUID %s" % document_uuid
_logger.warning(msg)
return msg
@http.route(
"/pingen/letter_issues", type="http", auth="none", methods=["POST"], csrf=False
)
def letter_issues(self, **post):
_logger.info("Webhook call received on /pingen/letter_issues")
request_content = self._get_request_content()
json_content = self._get_json_content(request_content)
self._verify_signature(request_content)
values = {
"state": "pingen_error",
"last_error_message": self._get_error_reason(json_content),
}
self._update_pingen_document(request_content, values)
@http.route(
"/pingen/sent_letters", type="http", auth="none", methods=["POST"], csrf=False
)
def sent_letters(self, **post):
_logger.info("Webhook call received on /pingen/sent_letters")
request_content = self._get_request_content()
json_content = self._get_json_content(request_content)
self._verify_signature(request_content)
emitted_date = self._get_emitted_date(json_content)
values = {
"state": "sent",
}
if emitted_date:
values["send_date"] = emitted_date
self._update_pingen_document(request_content, values)
@http.route(
"/pingen/undeliverable_letters",
type="http",
auth="none",
methods=["POST"],
csrf=False,
)
def undeliverable_letters(self, **post):
_logger.info("Webhook call received on /pingen/undeliverable_letters")
request_content = self._get_request_content()
json_content = self._get_json_content(request_content)
self._verify_signature(request_content)
values = {
"state": "error_undeliverable",
"last_error_message": self._get_error_reason(json_content),
}
self._update_pingen_document(request_content, values)

195
pingen/migrations/10.0.2.0.0/pre-migration.py Normal file
View File

@@ -0,0 +1,195 @@
# Copyright 2022 Camptocamp SA
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl)
from collections import namedtuple
from openupgradelib.openupgrade import (
add_fields,
column_exists,
logged_query,
migrate as oumigrate,
table_exists,
)
from psycopg2 import sql
field_definition = namedtuple("FieldDefinition", ["name", "type", "db_type"])
@oumigrate(use_env=True)
def migrate(env, version):
move_and_migrate_to_api_v2_field(
env,
"ir_attachment",
field_definition("pingen_speed", "selection", "integer"),
"id",
"pingen_document",
field_definition("delivery_product", "selection", "varchar"),
"attachment_id",
field_default="cheap",
values_mapping={"1": "fast", "2": "cheap"},
)
move_and_migrate_to_api_v2_field(
env,
"ir_attachment",
field_definition("pingen_color", "selection", "integer"),
"id",
"pingen_document",
field_definition("print_spectrum", "selection", "varchar"),
"attachment_id",
field_default="grayscale",
values_mapping={"0": "grayscale", "1": "color"},
)
move_and_migrate_to_api_v2_field(
env,
"ir_attachment",
field_definition("pingen_send", "boolean", "bool"),
"id",
"pingen_document",
field_definition("auto_send", "boolean", "bool"),
"attachment_id",
field_default="True",
)
migrate_to_api_v2_field(
env,
"pingen_document",
field_definition("pingen_id", "integer", "int4"),
field_definition("pingen_uuid", "char", "varchar"),
)
migrate_to_api_v2_field(
env,
"pingen_document",
field_definition("post_status", "char", "varchar"),
field_definition("pingen_status", "char", "varchar"),
)
def migrate_to_api_v2_field(
env, table_name, old_field_definition, new_field_definition
):
if table_exists(env.cr, table_name) and not column_exists(
env.cr, table_name, new_field_definition.name
):
add_fields(
env,
[
(
new_field_definition.name,
table_name.replace("_", "."),
table_name,
new_field_definition.type,
new_field_definition.db_type,
"pingen",
)
],
)
migrate_data(env.cr, table_name, old_field_definition, new_field_definition)
def move_and_migrate_to_api_v2_field(
env,
old_model_table,
old_field_definition,
old_model_id,
new_model_table,
new_field_definition,
new_model_id,
field_default=None,
values_mapping={},
):
if table_exists(env.cr, new_model_table) and not column_exists(
env.cr, new_model_table, new_field_definition.name
):
add_fields(
env,
[
(
new_field_definition.name,
new_model_table.replace("_", "."),
new_model_table,
new_field_definition.type,
new_field_definition.db_type,
"pingen",
)
],
)
move_and_migrate_data(
env.cr,
old_model_table,
old_field_definition,
new_model_table,
new_field_definition,
old_model_id,
new_model_id,
values_mapping=values_mapping,
)
def migrate_data(cr, table_name, old_field_definition, new_field_definition):
query = sql.SQL(
"""
UPDATE {table_name}
SET {new_fname} = {old_fname};
"""
)
format_params = {
"table_name": sql.Identifier(table_name),
"new_fname": sql.Identifier(new_field_definition.name),
"old_fname": sql.Identifier(old_field_definition.name),
}
if old_field_definition.db_type != new_field_definition.db_type:
format_params.update(
{
"old_fname": sql.SQL(
"%s::%s" % (old_field_definition.name, new_field_definition.db_type)
)
}
)
query = query.format(**format_params)
logged_query(cr, query)
def move_and_migrate_data(
cr,
old_table,
old_field_definition,
new_table,
new_field_definition,
old_table_key,
new_table_key,
values_mapping={},
):
query = sql.SQL(
"""
UPDATE {table_to}
SET {table_to_col} = {table_from_col}
FROM {table_from}
WHERE {table_to}.{table_to_id} = {table_from}.{table_from_id};"""
)
format_params = {
"table_to": sql.Identifier(new_table),
"table_from": sql.Identifier(old_table),
"table_to_col": sql.Identifier(new_field_definition.name),
"table_from_col": sql.Identifier(old_field_definition.name),
"table_to_id": sql.Identifier(new_table_key),
"table_from_id": sql.Identifier(old_table_key),
}
query = query.format(**format_params)
logged_query(cr, query)
for old_val, new_val in values_mapping.items():
values_query = sql.SQL(
"""
UPDATE {table_to}
SET {table_to_col} = {new_val}
WHERE {table_to_col} = {old_val};
"""
)
if new_val.isdigit():
format_params["new_val"] = sql.SQL(new_val)
else:
format_params["new_val"] = sql.Literal(new_val)
format_params.update({"old_val": sql.SQL(old_val)})
if old_field_definition.db_type != new_field_definition.db_type:
format_params.update(
{"old_val": sql.SQL("%s::%s" % (old_val, new_field_definition.db_type))}
)
values_query = values_query.format(**format_params)
logged_query(cr, values_query)

5
pingen/models/base_config_settings.py
View File

@@ -6,5 +6,8 @@ from odoo import fields, models
class BaseConfigSettings(models.TransientModel):
_inherit = "base.config.settings"
pingen_token = fields.Char(related="company_id.pingen_token")
pingen_clientid = fields.Char(related="company_id.pingen_clientid")
pingen_client_secretid = fields.Char(related="company_id.pingen_client_secretid")
pingen_organization = fields.Char(related="company_id.pingen_organization")
pingen_webhook_secret = fields.Char(related="company_id.pingen_webhook_secret")
pingen_staging = fields.Boolean(related="company_id.pingen_staging")

19
pingen/models/ir_attachment.py
View File

@@ -18,23 +18,12 @@ class IrAttachment(models.Model):
pingen_document_ids = fields.One2many(
"pingen.document", "attachment_id", string="Pingen Document", readonly=True
)
pingen_send = fields.Boolean(
"Send",
help="Defines if a document is merely uploaded or also sent",
default=True,
)
pingen_speed = fields.Selection(
[("1", "Priority"), ("2", "Economy")],
"Speed",
default="2",
help="Defines the sending speed if the document is automatically sent",
)
pingen_color = fields.Selection(
[("0", "B/W"), ("1", "Color")], "Type of print", default="0"
)
def _prepare_pingen_document_vals(self):
return {"attachment_id": self.id, "config": "created from attachment"}
return {
"attachment_id": self.id,
# 'config': 'created from attachment'
}
def _handle_pingen_document(self):
"""Reponsible of the related ``pingen.document``

287
pingen/models/pingen.py
View File

@@ -9,35 +9,23 @@ from datetime import datetime
import pytz
import requests
import urlparse
from requests.packages.urllib3.filepost import encode_multipart_formdata
from dateutil import parser
from oauthlib.oauth2 import BackendApplicationClient
from requests_oauthlib import OAuth2Session
_logger = logging.getLogger(__name__)
POST_SENDING_STATUS = {
100: "Ready/Pending",
101: "Processing",
102: "Waiting for confirmation",
1: "Sent",
300: "Some error occured and object wasn't sent",
400: "Sending cancelled",
}
DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S" # this is the format used by pingen API
TZ = pytz.timezone("Europe/Zurich") # this is the timezone of the pingen API
def pingen_datetime_to_utc(dt):
"""Convert a date/time used by pingen.com to UTC timezone
:param dt: pingen date/time as string (as received from the API)
:param dt: pingen date/time iso string (as received from the API)
to convert to UTC
:return: datetime in the UTC timezone
:return: TZ naive datetime in the UTC timezone
"""
utc = pytz.utc
dt = datetime.strptime(dt, DATETIME_FORMAT)
localized_dt = TZ.localize(dt, is_dst=True)
return localized_dt.astimezone(utc)
localized_dt = parser.parse(dt)
return localized_dt.astimezone(utc).replace(tzinfo=None)
class PingenException(RuntimeError):
@@ -52,28 +40,102 @@ class APIError(PingenException):
class Pingen(object):
"""Interface to the pingen.com API"""
def __init__(self, token, staging=True):
self._token = token
def __init__(self, clientid, secretid, organization, staging=True):
self.clientid = clientid
self.secretid = secretid
self.organization = organization
self.staging = staging
self._session = None
self._init_token_registry()
super(Pingen, self).__init__()
@property
def url(self):
def api_url(self):
if self.staging:
return "https://stage-api.pingen.com"
return "https://api.pingen.com"
return "https://api-staging.v2.pingen.com"
return "https://api.v2.pingen.com"
@property
def identity_url(self):
if self.staging:
return "https://identity-staging.pingen.com"
return "https://identity.pingen.com"
@property
def token_url(self):
return "auth/access-tokens"
@property
def file_upload_url(self):
return "file-upload"
@property
def session(self):
"""Build a requests session"""
if self._session is not None:
return self._session
self._session = requests.Session()
self._session.params = {"token": self._token}
self._session.verify = not self.staging
client = BackendApplicationClient(client_id=self.clientid)
self._session = OAuth2Session(client=client)
self._set_session_header_token()
return self._session
@classmethod
def _init_token_registry(cls):
if hasattr(cls, "token_registry"):
return
cls.token_registry = {
"staging": {"token": "", "expiry": datetime.now()},
"prod": {"token": "", "expiry": datetime.now()},
}
@classmethod
def _get_token_infos(cls, staging):
if staging:
return cls.token_registry.get("staging")
else:
return cls.token_registry.get("prod")
@classmethod
def _set_token_data(cls, token_data, staging):
token_string = " ".join(
[token_data.get("token_type"), token_data.get("access_token")]
)
token_expiry = datetime.fromtimestamp(token_data.get("expires_at"))
if staging:
cls.token_registry["staging"] = {
"token": token_string,
"expiry": token_expiry,
}
else:
cls.token_registry["prod"] = {"token": token_string, "expiry": token_expiry}
def _fetch_token(self):
# TODO: Handle scope 'letter' only?
token_url = urlparse.urljoin(self.identity_url, self.token_url)
# FIXME: requests.exceptions.SSLError: [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed (_ssl.c:581)
# without verify=False parameter on prod/staging
_logger.debug("Fetching new token from %s" % token_url)
return self._session.fetch_token(
token_url=token_url,
client_id=self.clientid,
client_secret=self.secretid,
verify=False,
)
def _set_session_header_token(self):
if self._is_token_expired():
token_data = self._fetch_token()
self._set_token_data(token_data, self.staging)
token_infos = self._get_token_infos(self.staging)
self._session.headers["Authorization"] = token_infos.get("token")
def _is_token_expired(self):
token_infos = self._get_token_infos(self.staging)
expired = token_infos.get("expiry") <= datetime.now()
if expired:
_logger.debug("Pingen token is expired")
return expired
def __enter__(self):
return self
@@ -85,7 +147,7 @@ class Pingen(object):
if self._session:
self._session.close()
def _send(self, method, endpoint, **kwargs):
def _send(self, method, endpoint, letter_id="", **kwargs):
"""Send a request to the pingen API using requests
Add necessary boilerplate to call pingen.com API
@@ -96,110 +158,159 @@ class Pingen(object):
:param kwargs: additional arguments forwarded to the requests method
"""
p_url = urlparse.urljoin(self.url, endpoint)
if self._is_token_expired():
self._set_session_header_token()
p_url = urlparse.urljoin(self.api_url, endpoint)
if endpoint == "document/get":
complete_url = "{}{}{}{}{}".format(
p_url, "/id/", kwargs["params"]["id"], "/token/", self._token
)
else:
complete_url = "{}{}{}".format(p_url, "/token/", self._token)
response = method(complete_url, **kwargs)
if response.json()["error"]:
raise APIError(
"%s: %s"
% (response.json()["errorcode"], response.json()["errormessage"])
complete_url = p_url.format(
organisationId=self.organization, letterId=letter_id
)
response = method(complete_url, verify=False, **kwargs)
errors = response.json().get("errors")
if errors:
raise APIError(
"\n".join(
[
"%s (%s): %s"
% (err.get("code"), err.get("title"), err.get("detail"))
for err in errors
]
)
)
return response
def push_document(self, filename, filestream, send=None, speed=None, color=None):
def _get_file_upload(self):
_logger.debug("Getting new URL for file upload")
response = self._send(self.session.get, self.file_upload_url)
json_response_attributes = response.json().get("data", {}).get("attributes")
url = json_response_attributes.get("url")
url_signature = json_response_attributes.get("url_signature")
return url, url_signature
def upload_file(self, url, multipart, content_type):
_logger.debug("Uploading new file")
response = requests.put(
url, data=multipart, headers={"Content-Type": content_type}
)
return response
def push_document(
self,
filename,
filestream,
content_type,
send=None,
delivery_product=None,
print_spectrum=None,
print_mode=None,
):
"""Upload a document to pingen.com and eventually ask to send it
:param str filename: name of the file to push
:param StringIO filestream: file to push
:param boolean send: if True, the document will be sent by pingen.com
:param int/str speed: sending speed of the document if it is send
1 = Priority, 2 = Economy
:param int/str color: type of print, 0 = B/W, 1 = Color
:param str delivery_product: sending product of the document if it is send
:param str print_spectrum: type of print, grayscale or color
:return: tuple with 3 items:
1. document_id on pingen.com
2. post_id on pingen.com if it has been sent or None
3. dict of the created item on pingen (details)
"""
data = {
"send": send,
"speed": speed,
"color": color,
}
# we cannot use the `files` param alongside
# with the `datas`param when data is a
# JSON-encoded data. We have to construct
# the entire body and send it to `data`
# https://github.com/kennethreitz/requests/issues/950
formdata = {
"file": (filename, filestream.read()),
"data": json.dumps(data),
# formdata = {
# 'file': (filename, filestream.read()),
# }
url, url_signature = self._get_file_upload()
# file_upload = self._get_file_upload()
# multipart, content_type = encode_multipart_formdata(formdata)
self.upload_file(url, filestream.read(), content_type)
data_attributes = {
"file_original_name": filename,
"file_url": url,
"file_url_signature": url_signature,
# TODO Use parameters and mapping
"address_position": "left",
"auto_send": send,
"delivery_product": delivery_product,
"print_spectrum": print_spectrum,
"print_mode": print_mode,
}
multipart, content_type = encode_multipart_formdata(formdata)
data = {"data": {"type": "letters", "attributes": data_attributes}}
response = self._send(
self.session.post,
"document/upload",
headers={"Content-Type": content_type},
data=multipart,
"organisations/{organisationId}/letters",
headers={"Content-Type": "application/vnd.api+json"},
data=json.dumps(data),
)
rjson_data = response.json().get("data", {})
rjson = response.json()
document_id = rjson_data.get("id")
# if rjson.get('send'):
# # confusing name but send_id is the posted id
# posted_id = rjson['send'][0]['send_id']
# item = rjson['item']
item = rjson_data.get("attributes")
document_id = rjson["id"]
if rjson.get("send"):
# confusing name but send_id is the posted id
posted_id = rjson["send"][0]["send_id"]
item = rjson["item"]
return document_id, False, item
return document_id, posted_id, item
def send_document(self, document_id, speed=None, color=None):
def send_document(
self, document_uuid, delivery_product=None, print_spectrum=None, print_mode=None
):
"""Send a uploaded document to pingen.com
:param int document_id: id of the document to send
:param int/str speed: sending speed of the document if it is send
1 = Priority, 2 = Economy
:param int/str color: type of print, 0 = B/W, 1 = Color
:param str document_uuid: id of the document to send
:param str delivery_product: sending product of the document
:param str print_spectrum: type of print, grayscale or color
:return: id of the post on pingen.com
"""
data_attributes = {
"delivery_product": delivery_product,
"print_mode": print_mode,
"print_spectrum": print_spectrum,
}
data = {
"speed": speed,
"color": color,
"data": {
"id": document_uuid,
"type": "letters",
"attributes": data_attributes,
}
}
response = self._send(
self.session.post,
"document/send",
params={"id": document_id},
data={"data": json.dumps(data)},
self.session.patch,
"organisations/{organisationId}/letters/{letterId}/send",
letter_id=document_uuid,
headers={"Content-Type": "application/vnd.api+json"},
data=json.dumps(data),
)
return response.json().get("data", {}).get("attributes")
return response.json()["id"]
def post_infos(self, post_id):
def post_infos(self, document_uuid):
"""Return the information of a post
:param int post_id: id of the document to send
:param str document_uuid: id of the document to send
:return: dict of infos of the post
"""
response = self._send(self.session.get, "document/get", params={"id": post_id})
return response.json()["item"]
@staticmethod
def is_posted(post_infos):
"""return True if the post has been sent
:param dict post_infos: post infos returned by `post_infos`
"""
return post_infos["status"] == 1
response = self._send(
self.session.get,
"organisations/{organisationId}/letters/{letterId}",
letter_id=document_uuid,
)
return response.json().get("data", {}).get("attributes")
# return response.json()['item']

247
pingen/models/pingen_document.py
View File

@@ -3,15 +3,16 @@
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
import logging
from itertools import groupby
from cStringIO import StringIO
from requests.exceptions import ConnectionError
from oauthlib.oauth2.rfc6749.errors import OAuth2Error
import odoo
from odoo import _, fields, models
from odoo import _, api, fields, models
from odoo.exceptions import UserError
from .pingen import POST_SENDING_STATUS, APIError, pingen_datetime_to_utc
from .pingen import APIError, pingen_datetime_to_utc
_logger = logging.getLogger(__name__)
@@ -26,6 +27,7 @@ class PingenDocument(models.Model):
_name = "pingen.document"
_inherits = {"ir.attachment": "attachment_id"}
_order = "push_date desc, id desc"
attachment_id = fields.Many2one(
"ir.attachment", "Document", required=True, readonly=True, ondelete="cascade"
@@ -36,6 +38,7 @@ class PingenDocument(models.Model):
("pushed", "Pushed"),
("sendcenter", "In Sendcenter"),
("sent", "Sent"),
("error_undeliverable", "Undeliverable"),
("error", "Connection Error"),
("pingen_error", "Pingen Error"),
("canceled", "Canceled"),
@@ -45,26 +48,58 @@ class PingenDocument(models.Model):
required=True,
default="pending",
)
auto_send = fields.Boolean(
"Auto Send",
help="Defines if a document is merely uploaded or also sent",
default=True,
)
delivery_product = fields.Selection(
[
("fast", "fast"),
("cheap", "cheap"),
("bulk", "bulk"),
("track", "track"),
("sign", "sign"),
("atpost_economy", "atpost_economy"),
("atpost_priority", "atpost_priority"),
("postag_a", "postag_a"),
("postag_b", "postag_b"),
("postag_b2", "postag_b2"),
("postag_registered", "postag_registered"),
("postag_aplus", "postag_aplus"),
("dpag_standard", "dpag_standard"),
("dpag_economy", "dpag_economy"),
("indpost_mail", "indpost_mail"),
("indpost_speedmail", "indpost_speedmail"),
("nlpost_priority", "nlpost_priority"),
("dhl_priority", "dhl_priority"),
],
"Delivery product",
default="cheap",
)
print_spectrum = fields.Selection(
[("grayscale", "Grayscale"), ("color", "Color")],
"Print Spectrum",
default="grayscale",
)
print_mode = fields.Selection(
[("simplex", "Simplex"), ("duplex", "Duplex")], "Print mode", default="simplex"
)
push_date = fields.Datetime("Push Date", readonly=True)
# for `error` and `pingen_error` states when we push
last_error_message = fields.Text("Error Message", readonly=True)
# pingen IDs
pingen_id = fields.Integer(
"Pingen ID", readonly=True, help="ID of the document in the Pingen Documents"
)
post_id = fields.Integer(
"Pingen Post ID",
readonly=True,
help="ID of the document in the Pingen Sendcenter",
)
# pingen API v2 fields
pingen_uuid = fields.Char(readonly=True)
pingen_status = fields.Char(readonly=True)
# sendcenter infos
post_status = fields.Char("Post Status", size=128, readonly=True)
parsed_address = fields.Text("Parsed Address", readonly=True)
cost = fields.Float("Cost", readonly=True)
currency_id = fields.Many2one("res.currency", "Currency", readonly=True)
country_id = fields.Many2one("res.country", "Country", readonly=True)
send_date = fields.Datetime("Date of sending", readonly=True)
pages = fields.Integer("Pages", readonly=True)
company_id = fields.Many2one(related="attachment_id.company_id")
_sql_constraints = [
(
@@ -74,55 +109,53 @@ class PingenDocument(models.Model):
),
]
def _get_pingen_session(self):
"""Returns a pingen session for a user"""
return self.company_id._pingen()
def _push_to_pingen(self, pingen=None):
"""Push a document to pingen.com
:param Pingen pingen: optional pingen object to reuse session
"""
decoded_document = self.attachment_id._decoded_content()
if pingen is None:
pingen = self._get_pingen_session()
pingen = self.company_id._get_pingen_client()
try:
doc_id, post_id, infos = pingen.push_document(
self.datas_fname,
self.name,
StringIO(decoded_document),
self.pingen_send,
self.pingen_speed,
self.pingen_color,
self.attachment_id.mimetype,
self.auto_send,
self.delivery_product,
self.print_spectrum,
self.print_mode,
)
except ConnectionError:
except OAuth2Error as e:
_logger.exception(
"Connection Error when pushing Pingen Document %s to %s."
% (self.id, pingen.url)
"Connection Error when pushing Pingen Document with ID %s to %s: %s"
% (self.id, pingen.api_url, e.description)
)
raise
except APIError:
_logger.error(
"API Error when pushing Pingen Document %s to %s."
% (self.id, pingen.url)
% (self.id, pingen.api_url)
)
raise
error = False
state = "pushed"
if post_id:
state = "sendcenter"
elif infos["requirement_failure"]:
state = "pingen_error"
error = _("The document does not meet the Pingen requirements.")
push_date = pingen_datetime_to_utc(infos["date"])
# if post_id:
# state = 'sendcenter'
# elif infos['requirement_failure']:
# state = 'pingen_error'
# error = _('The document does not meet the Pingen requirements.')
push_date = pingen_datetime_to_utc(infos.get("created_at"))
self.write(
{
"last_error_message": error,
"state": state,
"push_date": fields.Datetime.to_string(push_date),
"pingen_id": doc_id,
"post_id": post_id,
},
"pingen_uuid": doc_id,
"pingen_status": infos.get("status"),
}
)
_logger.info("Pingen Document %s: pushed to %s" % (self.id, pingen.url))
_logger.info("Pingen Document %s: pushed to %s" % (self.id, pingen.api_url))
def push_to_pingen(self):
"""Push a document to pingen.com
@@ -134,31 +167,24 @@ class PingenDocument(models.Model):
state = False
error_msg = False
try:
session = self._get_pingen_session()
session = self.company_id._get_pingen_client()
self._push_to_pingen(pingen=session)
except ConnectionError:
except OAuth2Error:
state = "error"
error_msg = (
_(
"Connection Error when asking for "
"sending the document %s to Pingen"
)
% self.name
_("Connection Error when pushing document %s to Pingen") % self.name
)
except APIError as e:
state = "pingen_error"
error_msg = _("Error when pushing the document %s to Pingen:\n%s") % (
self.name,
e,
)
except Exception as e:
error_msg = _(
"Error when asking Pingen to send the document %s: " "\n%s"
"Unexpected Error when pushing the document %s to Pingen:\n%s"
) % (self.name, e)
except Exception:
_logger.exception(
"Unexpected Error when updating the status of pingen.document "
"%s: " % self.id
)
error_msg = (
_("Unexpected Error when updating the " "status of Document %s")
% self.name
)
_logger.exception(error_msg)
finally:
if error_msg:
vals = {"last_error_message": error_msg}
@@ -184,18 +210,23 @@ class PingenDocument(models.Model):
new_env = odoo.api.Environment(new_cr, self.env.uid, self.env.context)
# Instead of raising, store the error in the pingen.document
self = self.with_env(new_env)
not_sent_docs = self.search([("state", "!=", "sent")])
for document in not_sent_docs:
session = document._get_pingen_session()
not_sent_docs = self.search(
[("state", "!=", "sent")], order="company_id"
)
for company, documents in groupby(
not_sent_docs, lambda d: d.company_id
):
session = company._get_pingen_client()
for document in documents:
if document.state == "error":
document._resolve_error()
document.refresh()
try:
if document.state == "pending":
document._push_to_pingen(pingen=session)
elif document.state == "pushed":
elif document.state == "pushed" and not document.auto_send:
document._ask_pingen_send(pingen=session)
except ConnectionError as e:
except OAuth2Error as e:
document.write({"last_error_message": e, "state": "error"})
except APIError as e:
document.write(
@@ -207,9 +238,9 @@ class PingenDocument(models.Model):
def _resolve_error(self):
"""A document as resolved, put in the correct state"""
if self.post_id:
state = "sendcenter"
elif self.pingen_id:
if self.send_date:
state = "sent"
elif self.pingen_uuid:
state = "pushed"
else:
state = "pending"
@@ -225,32 +256,34 @@ class PingenDocument(models.Model):
"""For a document already pushed to pingen, ask to send it.
:param Pingen pingen: pingen object to reuse
"""
# sending has been explicitely asked so we change the option
# for consistency
if not self.pingen_send:
self.write({"pingen_send": True})
try:
post_id = pingen.send_document(
self.pingen_id, self.pingen_speed, self.pingen_color
infos = pingen.send_document(
self.pingen_uuid,
self.delivery_product,
self.print_spectrum,
self.print_mode,
)
except ConnectionError:
except OAuth2Error:
_logger.exception(
"Connection Error when asking for sending Pingen Document %s "
"to %s." % (self.id, pingen.url)
"to %s." % (self.id, pingen.api_url)
)
raise
except APIError:
_logger.exception(
"API Error when asking for sending Pingen Document %s to %s."
% (self.id, pingen.url)
% (self.id, pingen.api_url)
)
raise
self.write(
{"last_error_message": False, "state": "sendcenter", "post_id": post_id}
{
"last_error_message": False,
"state": "sendcenter",
"pingen_status": infos.get("status"),
}
)
_logger.info(
"Pingen Document %s: asked for sending to %s" % (self.id, pingen.url)
"Pingen Document %s: asked for sending to %s" % (self.id, pingen.api_url)
)
return True
@@ -261,9 +294,9 @@ class PingenDocument(models.Model):
"""
self.ensure_one()
try:
session = self._get_pingen_session()
session = self.company_id._get_pingen_client()
self._ask_pingen_send(pingen=session)
except ConnectionError:
except OAuth2Error:
raise UserError(
_(
"Connection Error when asking for "
@@ -289,40 +322,64 @@ class PingenDocument(models.Model):
)
return True
def _update_post_infos(self, pingen):
def _get_and_update_post_infos(self, pingen):
"""Update the informations from
pingen of a document in the Sendcenter
:param Pingen pingen: pingen object to reuse
"""
if not self.pingen_id:
post_infos = self._get_post_infos(pingen)
self._update_post_infos(post_infos)
def _get_post_infos(self, pingen):
if not self.pingen_uuid:
return
try:
post_infos = pingen.post_infos(self.pingen_id)
except ConnectionError:
post_infos = pingen.post_infos(self.pingen_uuid)
except OAuth2Error:
_logger.exception(
"Connection Error when asking for "
"sending Pingen Document %s to %s." % (self.id, pingen.url)
"sending Pingen Document %s to %s." % (self.id, pingen.api_url)
)
raise
except APIError:
_logger.exception(
"API Error when asking for sending Pingen Document %s to %s."
% (self.id, pingen.url)
% (self.id, pingen.api_url)
)
raise
country = self.env["res.country"].search([("code", "=", post_infos["country"])])
send_date = pingen_datetime_to_utc(post_infos["date"])
return post_infos
@api.model
def _prepare_values_from_post_infos(self, post_infos):
country = self.env["res.country"].search(
[("code", "=", post_infos.get("country"))]
)
currency = self.env["res.currency"].search(
[("name", "=", post_infos.get("price_currency"))]
)
vals = {
"post_status": POST_SENDING_STATUS[post_infos["status"]],
"parsed_address": post_infos["address"],
"pingen_status": post_infos.get("status"),
"parsed_address": post_infos.get("address"),
"country_id": country.id,
"send_date": fields.Datetime.to_string(send_date),
"pages": post_infos["pages"],
"pages": post_infos.get("file_pages"),
"last_error_message": False,
"cost": post_infos.get("price_value"),
"currency_id": currency.id,
}
if pingen.is_posted(post_infos):
is_posted = post_infos.get("status") == "sent"
if is_posted:
post_date = post_infos.get("submitted_at")
send_date = fields.Datetime.to_string(pingen_datetime_to_utc(post_date))
vals["state"] = "sent"
self.write(vals)
else:
send_date = False
vals["send_date"] = send_date
return vals
def _update_post_infos(self, post_infos):
self.ensure_one()
values = self._prepare_values_from_post_infos(post_infos)
self.write(values)
_logger.info("Pingen Document %s: status updated" % self.id)
def _update_post_infos_cron(self):
@@ -338,10 +395,10 @@ class PingenDocument(models.Model):
self = self.with_env(new_env)
pushed_docs = self.search([("state", "!=", "sent")])
for document in pushed_docs:
session = document._get_pingen_session()
session = document.company_id._get_pingen_client()
try:
document._update_post_infos(pingen=session)
except (ConnectionError, APIError):
document._get_and_update_post_infos(pingen=session)
except (OAuth2Error, APIError):
# will be retried the next time
# In any case, the error has been
# logged by _update_post_infos
@@ -358,9 +415,9 @@ class PingenDocument(models.Model):
"""
self.ensure_one()
try:
session = self._get_pingen_session()
self._update_post_infos(pingen=session)
except ConnectionError:
session = self.company_id._get_pingen_client()
self._get_and_update_post_infos(pingen=session)
except OAuth2Error:
raise UserError(
_(
"Connection Error when updating the status "

19
pingen/models/res_company.py
View File

@@ -11,10 +11,25 @@ class ResCompany(models.Model):
_inherit = "res.company"
pingen_token = fields.Char("Pingen Token", size=32)
pingen_clientid = fields.Char("Pingen Client ID", size=20)
pingen_client_secretid = fields.Char("Pingen Client Secret ID", size=80)
pingen_organization = fields.Char("Pingen organization ID")
pingen_webhook_secret = fields.Char("Pingen Webhooks secret")
pingen_staging = fields.Boolean("Pingen Staging")
def _pingen(self):
"""Return a Pingen instance to work on"""
self.ensure_one()
return Pingen(self.pingen_token, staging=self.pingen_staging)
clientid = self.pingen_clientid
secretid = self.pingen_client_secretid
return Pingen(
clientid,
secretid,
organization=self.pingen_organization,
staging=self.pingen_staging,
)
def _get_pingen_client(self):
"""Returns a pingen session for a user"""
return self._pingen()

5
pingen/views/base_config_settings.xml
View File

@@ -7,7 +7,10 @@
<field name="arch" type="xml">
<group name="report" position="before">
<group string="Pingen Integration">
<field name="pingen_token" groups="base.group_system" />
<field name="pingen_clientid" groups="base.group_system" />
<field name="pingen_client_secretid" groups="base.group_system" />
<field name="pingen_organization" groups="base.group_system" />
<field name="pingen_webhook_secret" groups="base.group_system" />
<field name="pingen_staging" groups="base.group_system" />
</group>
</group>

9
pingen/views/ir_attachment_view.xml
View File

@@ -9,15 +9,6 @@
<xpath expr="//group/group[2]" position="after">
<group string="Pingen info" groups="base.group_no_one">
<field name="send_to_pingen" />
<field
name="pingen_send"
attrs="{'required': [('send_to_pingen', '=', True)]}"
/>
<field
name="pingen_speed"
attrs="{'required': [('pingen_send', '=', True)]}"
/>
<field name="pingen_color" />
</group>
</xpath>
</field>

168
pingen/views/pingen_document_view.xml
View File

@@ -7,12 +7,13 @@
<field name="type">tree</field>
<field name="arch" type="xml">
<tree string="Pingen Document">
<field name="push_date" />
<field name="name" />
<field name="datas_fname" />
<field name="pingen_send" />
<field name="pingen_speed" />
<field name="pingen_color" />
<field name="auto_send" />
<field name="delivery_product" />
<field name="print_spectrum" />
<field name="state" />
<field name="pingen_status" />
</tree>
</field>
</record>
@@ -24,82 +25,6 @@
<field name="arch" type="xml">
<form string="Pingen Document">
<header>
<field
name="state"
widget="statusbar"
statusbar_visible="pending,pushed,sent"
statusbar_colors='{"error":"red","pingen_error":"red","canceled":"grey","pushed":"blue","sent":"green"}'
/>
</header>
<group colspan="4" col="6">
<field name="name" readonly="True" />
<field name="type" readonly="True" />
<field
name="company_id"
readonly="True"
groups="base.group_multi_company"
widget="selection"
/>
</group>
<notebook colspan="4">
<page string="Pingen.com">
<separator string="Options" colspan="4" />
<newline />
<group col="2" colspan="2">
<field
name="pingen_send"
attrs="{'readonly': [('state', 'in', ['sendcenter', 'sent'])]}"
/>
<field
name="pingen_speed"
attrs="{'readonly': [('state', 'in', ['sendcenter', 'sent'])], 'required': [('pingen_send', '=', True)]}"
/>
<field
name="pingen_color"
attrs="{'readonly': [('state', 'in', ['sendcenter', 'sent'])]}"
/>
</group>
<separator string="Dates" colspan="4" />
<newline />
<group col="2" colspan="2">
<field name="push_date" />
</group>
<group
colspan="4"
attrs="{'invisible': [('last_error_message', '=', False)]}"
>
<separator string="Errors" colspan="4" />
<newline />
<group col="2" colspan="2">
<field nolabel="1" name="last_error_message" />
</group>
</group>
<group
colspan="4"
attrs="{'invisible': [('state', 'not in', ['sendcenter', 'sent'])]}"
>
<separator string="Sendcenter" colspan="4" />
<newline />
<group col="4" colspan="2">
<field colspan="4" name="post_status" />
<group col="3" colspan="2">
<field name="cost" />
<field colspan="1" nolabel="1" name="currency_id" />
</group>
<newline />
<field name="parsed_address" />
<field name="country_id" />
<field name="send_date" />
<field name="pages" />
</group>
</group>
<separator string="Actions" colspan="4" />
<newline />
<group col="2" colspan="2">
<button
name="push_to_pingen"
type="object"
@@ -110,9 +35,9 @@
<button
name="ask_pingen_send"
type="object"
states="pushed"
string="Ask pingen.com to send the document"
icon="fa-share"
attrs="{'invisible': ['|', ('state', '!=', 'pushed'),('auto_send', '=', True)]}"
/>
<button
name="resolve_error"
@@ -124,10 +49,89 @@
<button
name="update_post_infos"
type="object"
states="sendcenter"
states="pushed,sendcenter,sent"
string="Update the letter's informations"
icon="fa-refresh"
/>
<field
name="state"
widget="statusbar"
statusbar_visible="pending,pushed,sent"
statusbar_colors='{"error":"red","pingen_error":"red","canceled":"grey","pushed":"blue","sent":"green"}'
/>
</header>
<group>
<field name="name" readonly="True" />
<field name="type" readonly="True" />
<field
name="company_id"
readonly="True"
groups="base.group_multi_company"
widget="selection"
/>
</group>
<notebook>
<page string="Pingen.com">
<group>
<group>
<field name="pingen_uuid" />
<field name="pingen_status" />
</group>
</group>
<separator string="Options" />
<newline />
<group>
<group>
<field
name="auto_send"
attrs="{'readonly': [('state', 'in', ['sendcenter', 'sent'])]}"
/>
<field
name="delivery_product"
attrs="{'readonly': [('state', 'in', ['sendcenter', 'sent'])], 'required': [('auto_send', '=', True)]}"
/>
<field
name="print_spectrum"
attrs="{'readonly': [('state', 'in', ['sendcenter', 'sent'])]}"
/>
<field
name="print_mode"
attrs="{'readonly': [('state', 'in', ['sendcenter', 'sent'])]}"
/>
</group>
</group>
<separator string="Dates" />
<newline />
<group>
<field name="push_date" />
</group>
<group attrs="{'invisible': [('last_error_message', '=', False)]}">
<separator string="Errors" />
<newline />
<group>
<field nolabel="1" name="last_error_message" />
</group>
</group>
<group attrs="{'invisible': [('state', 'not in', ['sendcenter', 'sent'])]}">
<separator string="Sendcenter" colspan="4" />
<newline />
<group>
<label for="cost" />
<div>
<field name="cost" class="oe_inline" />
<field
name="currency_id"
class="oe_inline"
groups="base.group_multi_currency"
/>
</div>
<newline />
<field name="parsed_address" />
<field name="country_id" />
<field name="send_date" />
<field name="pages" />
</group>
</group>
</page>
<page string="Attachment">

2
requirements.txt
View File

@@ -1,3 +1,3 @@
# generated from manifests external_dependencies
pycups
requests
requests_oauthlib