Bit4bit Integraciones

FreeSWITCH talks to MS Teams

bit4bit@riseup.net (Jovany Leandro G.C) — Mon, 20 Nov 2023 13:13:16 -0500

Voy explicar como logre conectar FreeSWITCH con MS Team.

Para configurar MS TEAMS ver Kamailio SBC MS Teams

Escenario confirmado.

flowchart LR MSTeams["MS Teams v.2023.6.21.5 "] PBX["FreeSWITCH v1.10.10 "] MSTeams ---|TLS/PUBLIC IP| PBX

Funcionalidades confirmadas:

Llamadas MSTeams a PBX
Llamadas PBX a MSTeams
MSTeams Hold
MSTeams Park
MSTeams Unpark

Crear sofia profile para ser usado en las conexiones a MS Teams,

en este profile habilitar:

 <param name="tls-only" value="true"/>
 <param name="full-id-in-dialplan" value="true"/>
 <param name="inbound-use-callid-as-uuid" value="true"/>
 <param name="outbound-use-uuid-as-callid" value="true"/>

crear pasarela a MS Teams:

 <!-- sustituir mysbc.bit4bit.in por el nombre registrado en MS Teams -->
 <gateway name="mysbc.bit4bit.in">
 <param name="realm" value="mysbc.bit4bit.in"/>
 <param name="register" value="false"/>
 <param name="caller-id-in-from" value="true"/>
 <param name="contact-in-ping" value="true"/>
 <param name="contact-host" value="mysbc.bit4bit.in"/>
 <param name="extension-in-contact" value="true"/>
 <param name="ping" value="30"/>
 <param name="register-transport" value="tls"/>
 <param name="cid-type" value="pid"/>
 </gateway>

al refrescar los perfiles y pasarelas en FreeSWITCH, ya podríamos ver que tenemos conexiones en ambos sentidos.

Ahora para lanzar llamadas al MS Teams desde FreeSWITCH.

<condition...>
 <action application="export" data="nolocal:sip_secure_media=true"/>
 <action application="export" data="nolocal:rtp_secure_media=true"/>
 <action application="bridge" data="{absolute_codec_string=G722}sofia/gateway/mysbc.bit4bit.in/+NUMERO"/>
</condition>

Y para gestionar Hold y Transferencias desde MS Teams.

<extension name="refer-msteams extract referred_by" continue="true">
 <condition field="${sip_refer_to}" expression="microsoft\.com"/>
 <condition field="${sip_h_Referred-By}" expression="^<(.+)>$">
 <action application="set" data="sip_referrer_by_extracted=$1"/>
 </condition>
</extension>

<extension name="refer-msteam">
 <condition field="${sip_refer_to}" expression="microsoft\.com"/>
 <condition field="${sip_referrer_by_extracted}" expresion="(.+)">
 <action application="export" data="nolocal:sip_invite_to_uri=$1"/>
 <action application="export" data="nolocal:sip_invite_req_uri=$1"/>
 <action application="export" data="nolocal:sip_secure_media=true"/>
 <action application="export" data="nolocal:rtp_secure_media=true"/>
 <action application="bridge" data="{absolute_codec_string=G722}sofia/gateway/mysbc.bit4bit.in"/>
 </condition>
</extension>

Para recibir llamadas desde MS Teams, debemos ajustar los planes de la siguiente manera.

<!-- las llamadas desde MS Teams llegarian como 31000@mysbc.bit4bit.in -->
<condition field="destination_number" expresion="^3(\d{9})@.+$">

...
<action application="set" data="sip_secure_media=true"/>
<action application="set" data="disable_q850_reason=true"/>
...

Emacs - Básico 1

bit4bit@riseup.net (Jovany Leandro G.C) — Sun, 09 Jul 2023 21:54:27 -0500

GNU EMACS es un editor altamente extensible y vamos aprovechar esta posibilidad que nos ofrecen y construir un paquete que nos permita cubrir varios elementos (peticiones HTTP, SON, TDD, EMACS), el ejercicio entorna a implementar un módulo de EMACS que nos permita obtener el titulo de una incidencia, procediendo con:

Autenticar a Gitea
Solicitar id de incidencia
Consultar titulo de incidencia indicado
E insertar titulo en el árbol del documento org.

importante antes de empezar:

ser usuario de EMACS.
nociones en desarrollo de software.
nociones del lenguaje LISP o uno de sus dialectos.

Vamos a usar el dialecto ELisp de EMACS el cual iremos conociendo poco a poco en el transcurso de la implementación.

Empecemos por crear la estructura mínima del paquete.

Makefile

.PHONY: test
test:
 emacs --batch -L . -L tests -l grieta-tests.el -f ert-run-tests-batch

make test

Cannot open load file: No such file or directory, grieta-tests.el
make: *** [Makefile:3: test] Error 255

Empecemos a ilustrarnos a partir del error

Cannot open load file: No such file or directory, grieta-tests.el

no ubica el archivo grieta-tests.el, debemos indicar el directorio donde se encuentra el archivo, usamos los siguientes parametros.

en el parametro -L le indicamos a ENACS donde ubicar archivos Lisp.
en el parametro -l le indicamos interpretar el archivo Lisp.
en el parametro -f le indicamos una función a ejecutar.

En otras palabras le estamos indicando a EMACS que ejecuta la función ert-run-tests-batch además que interprete el archivo grieta-tests.el y que posiblemente lo puede encontrar en el directorio tests. .

tests/grieta-tests.el

mkdir tests
touch tests/grieta-tests.el

make test

Running 0 tests (2023-07-10 21:29:29-0500, selector ‘t’)

Ran 0 tests, 0 results as expected, 0 unexpected (2023-07-10 21:29:29-0500, 0.000060 sec)

muy bien no mas errores por ahora, ahora vamos a proceder a iniciar con las pruebas y por medio de estas iremos realizando la implementación. Para automatizar las pruebas utilizaremos ERT.

Para empezar definimos como agrupar las pruebas:

UNIT funciones que solo varían su comportamiento según los argumentos.
INTEGRATION funciones que varían su comportamiento según los argumentos u otros medios como variables globales o lecturas fuera del proceso (lectura disco, red, etc..).
ACCEPTANCE los mismo criterios que INTEGRATION pero solo sobre las funciones publicadas es decir sobre las funciones que son accesible por el usuario u otros paquetes.
MANUAL pruebas que se deben realizar manualmente ya que el contexto no se puede reproduccir en ACCEPTANCE.

tests/grieta-tests.el

(require 'el-mock)

;; UNIT
;; INTEGRATION
;; ACCEPTANCE
;; MANUAL

(provide 'grieta-tests)

make test

Cannot open load file: No such file or directory, el-mock
make: *** [Makefile:3: test] Error 255

Uumm ya hemos visto anteriormente este error, el-mock es una dependencia que utilizaremos para verificar el comportamiento en las pruebas de INTEGRATION y ACCEPTANCE.

curl -q https://raw.githubusercontent.com/rejeep/el-mock.el/master/el-mock.el --output tests/el-mock.el

make test

Running 0 tests (2023-07-10 21:46:25-0500, selector ‘t’)

Ran 0 tests, 0 results as expected, 0 unexpected (2023-07-10 21:46:25-0500, 0.000052 sec)

Excelente, ya no tenemos error al importar la dependencia el-mock con (require ’el-mock).

tests/grieta-tests.el

(require 'el-mock)

;; UNIT
;; INTEGRATION
(ert-deftest grieta-test-grieta--gitea-issue-check-url-path ()
 (with-mock
 ;; https://try.gitea.io/api/swagger#/issue/issueGetIssue
 (mock (grieta--gitea-call "gitea.test.org" "GET" "/api/v1/repos/demo/grieta/issues/99"))
 (grieta--gitea-issue "gitea.test.org" "demo" "grieta" 99)))

;; ACCEPTANCE
;; MANUAL
(provide 'grieta-tests)

make test

Test grieta-test-grieta--gitea-issue-check-url-path condition:
 (void-function grieta--gitea-issue)
 FAILED 1/1 grieta-test-grieta--gitea-issue-check-url-path (0.000067 sec)

Iniciar las pruebas desde INTEGRATION o ACCEPTANCE nos facilita tener una perspectiva más cercana a su uso y empezar con anterioridad el flujo de la implementación, hemos decido empezar por confirmar que la petición este en la estructura esperada por la API de gitea.

(void-function grieta--gitea-issue) lo vamos a ver cuando no logra llamar la función, en nuestro caso es por que no existe.

tests/grieta-tests.el

(require 'el-mock)

(defun grieta--gitea-issue (host owner repo issue-id))

;; UNIT
;; INTEGRATION
(ert-deftest grieta-test-grieta--gitea-issue-check-url-path ()
 (with-mock
 ;; https://try.gitea.io/api/swagger#/issue/issueGetIssue
 (mock (grieta--gitea-call "gitea.test.org" "GET" "/api/v1/repos/demo/grieta/issues/99"))
 (grieta--gitea-issue "gitea.test.org" "demo" "grieta" 99)))

;; ACCEPTANCE
;; MANUAL
(provide 'grieta-tests)

make test

 (mock-error not-called grieta--gitea-call)
 FAILED 1/1 grieta-test-grieta--gitea-issue-check-url-path (0.000075 sec)

(mock-error not-called grieta--gitea-call) nos indica que se esperaba que se invocará esa función pero no sucedió.

tests/grieta-tests.el

(require 'el-mock)

(defun grieta--gitea-call (host method path))
(defun grieta--gitea-issue (host owner repo issue-id)
 (grieta--gitea-call host "GET" (format "/api/v1/repos/%s/%s/issues/%d" owner repo issue-id)))

;; UNIT
;; INTEGRATION
(ert-deftest grieta-test-grieta--gitea-issue-check-url-path ()
 (with-mock
 ;; https://try.gitea.io/api/swagger#/issue/issueGetIssue
 (mock (grieta--gitea-call "gitea.test.org" "GET" "/api/v1/repos/demo/grieta/issues/99"))
 (grieta--gitea-issue "gitea.test.org" "demo" "grieta" 99)))

;; ACCEPTANCE
;; MANUAL
(provide 'grieta-tests)

make test

Running 1 tests (2023-07-10 22:03:12-0500, selector ‘t’)
 passed 1/1 grieta-test-grieta--gitea-issue-check-url-path (0.000062 sec)

Ran 1 tests, 1 results as expected, 0 unexpected (2023-07-10 22:03:12-0500, 0.000143 sec)

Muy bien hemos ajustado según lo ilustrado por la prueba, ahora juguemos un poco en
aclarar el código, las funciones que creamos grieta--gitea-issue y grieta--gitea-call están en las pruebas, movamos estas pruebas a su propio archivo.

grieta.el

(defun grieta--gitea-call (host method path))
(defun grieta--gitea-issue (host owner repo issue-id)
 (grieta--gitea-call host "GET" (format "/api/v1/repos/%s/%s/issues/%d" owner repo issue-id)))

;; https://www.gnu.org/software/emacs/manual/html_node/elisp/Named-Features.html
;; `provide` es necesario para luego importar con `require`
(provide 'grieta)

tests/grieta-tests.el

(require 'el-mock)

;; UNIT
;; INTEGRATION
(ert-deftest grieta-test-grieta--gitea-issue-check-url-path ()
 (with-mock
 ;; https://try.gitea.io/api/swagger#/issue/issueGetIssue
 (mock (grieta--gitea-call "gitea.test.org" "GET" "/api/v1/repos/demo/grieta/issues/99"))
 (grieta--gitea-issue "gitea.test.org" "demo" "grieta" 99)))

;; ACCEPTANCE
;; MANUAL
(provide 'grieta-tests)

make test

Test grieta-test-grieta--gitea-issue-check-url-path condition:
 (void-function grieta--gitea-issue)
 FAILED 1/1 grieta-test-grieta--gitea-issue-check-url-path (0.000073 sec)

(void-function grieta--gitea-issue) ya hemos lo hemos vistos anteriormente, no logra ubicar la función y claro es debido a que movimos la función a otro archivo, debemos importar el archivo.

tests/grieta-tests.el

(require 'el-mock)
(require 'grieta)

;; UNIT
;; INTEGRATION
(ert-deftest grieta-test-grieta--gitea-issue-check-url-path ()
 (with-mock
 ;; https://try.gitea.io/api/swagger#/issue/issueGetIssue
 (mock (grieta--gitea-call "gitea.test.org" "GET" "/api/v1/repos/demo/grieta/issues/99"))
 (grieta--gitea-issue "gitea.test.org" "demo" "grieta" 99)))

;; ACCEPTANCE
;; MANUAL
(provide 'grieta-tests)

make test

Running 1 tests (2023-07-10 22:08:57-0500, selector ‘t’)
passed 1/1 grieta-test-grieta--gitea-issue-check-url-path (0.000060 sec)
Ran 1 tests, 1 results as expected, 0 unexpected (2023-07-10 22:08:57-0500, 0.000137 sec)

Muy bien volvimos a estar estables, ya que empezamos por validar la estructura de la URL podemos continuar sobre el mismo tema de validar elementos hacia la API externa, procedamos por ejemplo con traducir la respuesta JSON a una estructura interna.

tests/grieta-tests.el

(require 'el-mock)
(require 'grieta)

;; UNIT
;; INTEGRATION
(ert-deftest grieta-test-grieta--gitea-json->issues ()
 (with-mock
 ;; https://try.gitea.io/api/swagger#/issue/issueGetIssue
 ;; respuesta simplificada
 (stub grieta--gitea-call => "{\"id\": 1000, \"number\": 1, \"title\": \"Test\"}")

 (should (equal
 '(1 "Test")
 (grieta--gitea-issue "gitea.test.org" "demo" "grieta" 1)))))

(ert-deftest grieta-test-grieta--gitea-issue-check-url-path ()
 (with-mock
 ;; https://try.gitea.io/api/swagger#/issue/issueGetIssue
 (mock (grieta--gitea-call "gitea.test.org" "GET" "/api/v1/repos/demo/grieta/issues/99"))
 (grieta--gitea-issue "gitea.test.org" "demo" "grieta" 99)))

;; ACCEPTANCE
;; MANUAL
(provide 'grieta-tests)

make test

Test grieta-test-grieta--gitea-json->issues condition:
 (ert-test-failed
 ((should
 (equal '...
 (grieta--gitea-issue "gitea.test.org" "demo" "grieta" 1)))
 :form
 (equal
 ((1 "Test"))
 "{\"id\": 1000, \"number\": 1, \"title\": \"Test\"}")
 :value nil :explanation
 (different-types
 ((1 "Test"))
 "{\"id\": 1000, \"number\": 1, \"title\": \"Test\"}")))
 FAILED 2/2 grieta-test-grieta--gitea-json->issues (0.000051 sec)

miremos solo una parte

 :form
 (equal
 ((1 "Test"))
 "{\"id\": 1000, \"number\": 1, \"title\": \"Test\"}")

evidentemente los resultados no son iguales estamos retornando directamente la respuesta de la API, procedamos a implementar el traductor.

grieta.el

(defun grieta--gitea-call (host method path))
(defun grieta--gitea-issue (host owner repo issue-id)
 (let* ((response (grieta--gitea-call host "GET" (format "/api/v1/repos/%s/%s/issues/%d" owner repo issue-id))))
 (if response
 (let ((remote-issue (json-parse-string response)))
 (list (gethash "number" remote-issue)
 (gethash "title" remote-issue)))
 nil)))

;; https://www.gnu.org/software/emacs/manual/html_node/elisp/Named-Features.html
;; `provide` es necesario para luego importar con `require`
(provide 'grieta)

make test

Running 2 tests (2023-07-10 22:35:19-0500, selector ‘t’)
 passed 1/2 grieta-test-grieta--gitea-issue-check-url-path (0.000058 sec)
 passed 2/2 grieta-test-grieta--gitea-json->issues (0.000062 sec)

Ran 2 tests, 2 results as expected, 0 unexpected (2023-07-10 22:35:19-0500, 0.000208 sec

Hemos logrado estar otra vez estables, pero en este caso adicionamos un if lo cual nos invita que debemos verificar cual sera el comportamiento cuando no se obtenga una respuesta desde el servidor.

tests/grieta-tests.el

(require 'el-mock)
(require 'grieta)

;; UNIT
;; INTEGRATION
(ert-deftest grieta-test-grieta--gitea-json->issues-on-valid-data ()
 (with-mock
 ;; https://try.gitea.io/api/swagger#/issue/issueGetIssue
 ;; respuesta simplificada
 (stub grieta--gitea-call => "{\"id\": 1000, \"number\": 1, \"title\": \"Test\"}")

 (should (equal
 '(1 "Test")
 (grieta--gitea-issue "gitea.test.org" "demo" "grieta" 1)))))

(ert-deftest grieta-test-grieta--gitea-json->issues-on-invalid-data ()
 (with-mock
 ;; https://try.gitea.io/api/swagger#/issue/issueGetIssue
 (stub grieta--gitea-call => nil)

 (should (equal
 nil ; volveremos a revisar luego si esta valor nos lleva a tener que usar condicionales
 (grieta--gitea-issue "gitea.test.org" "demo" "grieta" 1)))))

(ert-deftest grieta-test-grieta--gitea-issue-check-url-path ()
 (with-mock
 ;; https://try.gitea.io/api/swagger#/issue/issueGetIssue
 (mock (grieta--gitea-call "gitea.test.org" "GET" "/api/v1/repos/demo/grieta/issues/99"))
 (grieta--gitea-issue "gitea.test.org" "demo" "grieta" 99)))

;; ACCEPTANCE
;; MANUAL
(provide 'grieta-tests)

make test

Running 3 tests (2023-07-10 22:39:39-0500, selector ‘t’)
 passed 1/3 grieta-test-grieta--gitea-issue-check-url-path (0.000064 sec)
 passed 2/3 grieta-test-grieta--gitea-json->issues-on-invalid-data (0.000030 sec)
 passed 3/3 grieta-test-grieta--gitea-json->issues-on-valid-data (0.000067 sec)

Ran 3 tests, 3 results as expected, 0 unexpected (2023-07-10 22:39:39-0500, 0.000269 sec)

Ya con las pruebas en curso pasemos a completar la implementación es decir hacer la petición HTTP.

grieta.el

(defun grieta--gitea-call (host method path)
 (let ((url-request-method method)
 (url-request-data path))
 (with-current-buffer
 (url-retrieve-synchronously (concat "https://" host path))
 (goto-char (point-min))
 (search-forward-regexp "\n\n")
 (buffer-substring (point) (point-max)))))

(defun grieta--gitea-issue (host owner repo issue-id)
 (let* ((response (grieta--gitea-call host "GET" (format "/api/v1/repos/%s/%s/issues/%d" owner repo issue-id))))
 (if response
 (let ((remote-issue (json-parse-string response)))
 (list (gethash "number" remote-issue)
 (gethash "title" remote-issue)))
 nil)))

;; https://www.gnu.org/software/emacs/manual/html_node/elisp/Named-Features.html
;; `provide` es necesario para luego importar con `require`
(provide 'grieta)

Verificamos manualmente que funcione la petición al servidor.

emacs --batch -l grieta.el --eval='(print (grieta--gitea-call "gitea.demo.org" "GET" "/api/v1/repos/bit4bit/prueba/issues/1"))'

"{\"errors\":null,\"message\":\"The target couldn't be found.\",\"url\":\"https://gitea.onecluster.org/api/swagger\"}
"

uuum, consultemos a un repositorio público

emacs --batch -l grieta.el --eval='(print (grieta--gitea-call "gitea.onecluster.org" "GET" "/api/v1/repos/OneTeam/trytondo-analytic_operations/issues/1"))'

"{\"id\":1846,\"url\":\"https://gitea.onecluster.org/api/v1/repos/OneTeam/trytondo-analytic_operations/issues/1\",\"html_url\":\"https://gitea.onecluster.org/OneTeam/trytondo-analytic_operations/issues/1\",\"number\":1,\"user\":{\"id\":5,\"login\":\"Rodia\",\"login_name\":\"\",\"full_name\":\"\",\"email\":\"rodia@noreply.onecluster.org\",\"avatar_url\":\"https://gitea.onecluster.org/avatar/2bb02a97b20d83fd00f4e7e044e9c1ef\",\"language\":\"\",\"is_admin\":false,\"last_login\":\"0001-01-01T00:00:00Z\",\"created\":\"2021-09-05T14:03:55-05:00\",\"restricted\":false,\"active\":false,\"prohibit_login\":false,\"location\":\"\",\"website\":\"\",\"description\":\"\",\"visibility\":\"public\",\"followers_count\":0,\"following_count\":0,\"starred_repos_count\":0,\"username\":\"Rodia\"},\"original_author\":\"\",\"original_author_id\":0,\"title\":\"AÃ±adir Centro de Costos en Encabezado a Facturas de Cliente y de Proveedor\",\"body\":\"\",\"ref\":\"\",\"assets\":[],\"labels\":[],\"milestone\":null,\"assignee\":null,\"assignees\":null,\"state\":\"open\",\"is_locked\":false,\"comments\":0,\"created_at\":\"2023-07-01T00:01:50-05:00\",\"updated_at\":\"2023-07-01T00:01:50-05:00\",\"closed_at\":null,\"due_date\":null,\"pull_request\":null,\"repository\":{\"id\":2134,\"name\":\"trytondo-analytic_operations\",\"owner\":\"OneTeam\",\"full_name\":\"OneTeam/trytondo-analytic_operations\"}}
"

ajaa, investigando un poco sobre la API nos indica que para repositorios privados debemos que una Api Key, y ya ilustrados sobre este escenario procedamos a implementarlo, pero antes revisemos algunos caminos.

crear otra función ejemplo grieta--gitea-auth-call.
usar una variable global o función que nos entregue el api-key.
adicionar otro parámetro a la función grieta-gitea-call.

La primera ya que aunque puede ser la más “sencilla” tendríamos redundancia en la lógica que a posterior nos afectaría el mantenimiento, entonces la descartamos.

Ahora valoremos la segunda, especulemos sobre una posible implementación

(defvar grieta-gitea-api-key-call nil)

(defun grieta--gitea-call (host method path)
 (let ((url-request-method method)
 ((url-request-data path))

 (if grieta-gitea-api-key-call
 (url-request-extra-headers
 ;; acoplamiento
 (cons "Authorization" (cons "token " grieta-gitea-api-key-call)))))

 (with-current-buffer
 (url-retrieve-synchronously (concat "https://" host path))
 (goto-char (point-min))
 (search-forward-regexp "\n\n")
 (buffer-substring (point) (point-max)))))

al ejecutar las pruebas estas pasan, pero miremos algo, recordando lo siguiente:

UNIT funciones que solo varían su comportamiento según los argumentos.
INTEGRATION funciones que varían su comportamiento según los argumentos u otros medios como variables globales o lecturas fuera del proceso (lectura disco, red, etc..).
ACCEPTANCE los mismo criterios que INTEGRATION pero solo sobre las funciones publicadas es decir sobre las funciones que son accesible por el usuario u otros paquetes.
MANUAL pruebas que se deben realizar manualmente.

hasta ahora hemos realizado las pruebas en el grupo de INTEGRATION donde hemos verificado la interacción con grieta--gitea-call por medio de un doble, hasta ahora no nos hemos interesado en probar la función ya que esta es una pasarela un servicio externo donde no tenemos mas lógica que la peticion al servicio pero ahora la situación cambia ya que creamos una dependencia implícita (ya que solo leyendo la implementación podemos determinarla) a una variable que va ser modificada por el usuario creando un acoplamiento de un mecanismo privado a un mecanismo netamente publico, acá es de suma importancia mantener una clara separacion entre capas, grieta--gitea-call pertenece a una capa privada mientras que grieta-gitea-api-key-call pertenece a una capa publica, por lo tanto necesitaríamos algún mecanismo que nos permita pasar la configuración desde la capa publica a la privada. ahora especulemos sobre adicionar un parámetro

grieta.el

(defun grieta--gitea-call (host api-key method path)
 (let ((url-request-method method)
 (url-request-data path)
 (url-request-extra-headers
 (list (cons "Authorization" (concat "token " api-key)))))

 (with-current-buffer
 (url-retrieve-synchronously (concat "https://" host path))
 (goto-char (point-min))
 (search-forward-regexp "\n\n")
 (buffer-substring (point) (point-max)))))

(defun grieta--gitea-issue (host owner repo issue-id)
 (let* ((response (grieta--gitea-call host "GET" (format "/api/v1/repos/%s/%s/issues/%d" owner repo issue-id))))
 (if response
 (let ((remote-issue (json-parse-string response)))
 (list (gethash "number" remote-issue)
 (gethash "title" remote-issue)))
 nil)))

;; https://www.gnu.org/software/emacs/manual/html_node/elisp/Named-Features.html
;; `provide` es necesario para luego importar con `require`
(provide 'grieta)

al cambiar la firma de la función debemos actualizar todas las funciones dependientes Martin Fowler en Refactoring propone una metodología estructura de realizar esto, ya que es algo que estamos haciendo constantemente y es de suma importancia aprender a refactorizar para no tomar caminos mas “rápidos” que a largo plazo son perjudiciales, ahora si valoramos nuevamente donde realizaríamos las pruebas estas irían en INTEGRATION ya que realizan lecturas fuera de proceso, y mirando un poco mas de cerca la función esta solo realiza actividades fuera de proceso osea que si realizáramos pruebas tendríamos que usar dobles para simular el comportamiento de funciones como url-retrieve-synchronously pero este tipo de pruebas seria falsas ya que no conocemos o participamos del ciclo de desarrollo de las funciones, por lo cual este tipo de funciones las verificaremos indirectamente en comportamientos de INTEGRATION o ACCEPTANCE o bien MANUAL.

emacs --batch -l grieta.el --eval='(print (grieta--gitea-call "gitea.demo.org" "oeuaeiaoi" "GET" "/api/v1/repos/bit4bit/prueba/issues/1"))'

"{\"id\":1861,\"url\":\"https://gitea.onecluster.org/api/v1/repos/bit4bit/prueba/issues/1\",\"html_url\":\"https://gitea.onecluster.org/bit4bit/prueba/issues/1\",\"number\":1,\"user\":{\"id\":10,\"login\":\"bit4bit\",\"login_name\":\"\",\"full_name\":\"\",\"email\":\"bit4bit@noreply.onecluster.org\",\"avatar_url\":\"https://gitea.onecluster.org/avatar/5984dea48f59d0cbf32c81e80cc81525\",\"language\":\"\",\"is_admin\":false,\"last_login\":\"0001-01-01T00:00:00Z\",\"created\":\"2021-11-24T14:59:21-05:00\",\"restricted\":false,\"active\":false,\"prohibit_login\":false,\"location\":\"\",\"website\":\"\",\"description\":\"\",\"visibility\":\"private\",\"followers_count\":0,\"following_count\":0,\"starred_repos_count\":0,\"username\":\"bit4bit\"},\"original_author\":\"\",\"original_author_id\":0,\"title\":\"prueba\",\"body\":\"\",\"ref\":\"\",\"assets\":[],\"labels\":[],\"milestone\":null,\"assignee\":null,\"assignees\":null,\"state\":\"open\",\"is_locked\":false,\"comments\":0,\"created_at\":\"2023-07-07T13:57:25-05:00\",\"updated_at\":\"2023-07-08T10:07:39-05:00\",\"closed_at\":null,\"due_date\":null,\"pull_request\":null,\"repository\":{\"id\":2098,\"name\":\"prueba\",\"owner\":\"bit4bit\",\"full_name\":\"bit4bit/prueba\"}}
"

make test

Running 3 tests (2023-07-14 20:36:23-0500, selector ‘t’)
 passed 1/3 grieta-test-grieta--gitea-issue-check-url-path (0.000058 sec)
 passed 2/3 grieta-test-grieta--gitea-json->issues-on-invalid-data (0.000029 sec)
 passed 3/3 grieta-test-grieta--gitea-json->issues-on-valid-data (0.000061 sec)

Ran 3 tests, 3 results as expected, 0 unexpected (2023-07-14 20:36:23-0500, 0.000264 sec)

aaa pero que paso?? porque pasaron las pruebas si cambio la firma de la función?? esto es algo que suele ocurre cuando usamos dobles, por algo se le llama dobles no es el elemento de origen, esto puede aclarar un poco de porque se recomienda evitar los dobles sobre elementos que no sean implementados por el proyecto,

por ejemplo url-request-method tiene un ciclo de desarrollo diferente.

ahora miremos un poco como podemos mitigar el efecto de los dobles

grieta.el

(defun grieta--gitea-call (host api-key method path)
 (let ((url-request-method method)
 (url-request-data path)
 (url-request-extra-headers
 (list (cons "Authorization" (concat "token " api-key)))))

 (with-current-buffer
 (url-retrieve-synchronously (concat "https://" host path))
 (goto-char (point-min))
 (search-forward-regexp "\n\n")
 (buffer-substring (point) (point-max)))))

(defun grieta--gitea-issue (host owner repo issue-id)
 ;; es una abstraccion sobre la comunicacion con gitea
 (let* ((response (grieta--gitea-call host "GET" (format "/api/v1/repos/%s/%s/issues/%d" owner repo issue-id))))
 (if response
 ;; pero aca tenemos un mecanismo de implementacion
 (let ((remote-issue (json-parse-string response)))

 ;; nuevamente una abstraccion
 (list (gethash "number" remote-issue)
 (gethash "title" remote-issue)))
 nil)))

;; https://www.gnu.org/software/emacs/manual/html_node/elisp/Named-Features.html
;; `provide` es necesario para luego importar con `require`
(provide 'grieta)

antes que nada no debemos forzar los conceptos, si algo no cuadra es porque no va, revisando nuevamente la función grieta--gitea-issue se puede ver que ahí un brinco entre diferentes niveles de abstracción (grieta-gitea-call json-parse-string, gethash), vamos a llevar esto a un solo nivel.

grieta.el

(defun grieta--url-auth-request (method token path)
 (let ((url-request-method method)
 (url-request-data path)
 (url-request-extra-headers
 (list (cons "Authorization" (concat "token " token)))))

 (with-current-buffer
 (url-retrieve-synchronously path)
 (goto-char (point-min))
 (search-forward-regexp "\n\n")
 (buffer-substring (point) (point-max)))))

(defun grieta--gitea-call (host api-key method path)
 (let ((response (grieta--url-auth-request method api-key (concat "https://" host path))))
 (if response
 (json-parse-string response)
 nil)))

(defun grieta--gitea-issue (host owner repo issue-id)
 (let* ((remote-issue (grieta--gitea-call host "GET" (format "/api/v1/repos/%s/%s/issues/%d" owner repo issue-id))))
 (if remote-issue
 (list (gethash "number" remote-issue)
 (gethash "title" remote-issue))
 nil)))

;; https://www.gnu.org/software/emacs/manual/html_node/elisp/Named-Features.html
;; `provide` es necesario para luego importar con `require`
(provide 'grieta)

la mitigación se da aislando en lo posible la peticion HTTP grieta—url-auth-request. Hemos aplanado los niveles de abstracción; por ejemplo grieta--gitea-issue habla en términos de una petición y la traducción a estructura interna, mientras que grieta--gitea-call habla en términos de petición HTTP. Como movimos las responsabilidades debemos actualizar los dobles usados en las pruebas.

tests/grieta-tests.el

(require 'el-mock)
(require 'grieta)

;; UNIT
;; INTEGRATION
(ert-deftest grieta-test-grieta--gitea-json->issues-on-valid-data ()
 (with-mock
 ;; https://try.gitea.io/api/swagger#/issue/issueGetIssue
 ;; respuesta simplificada
 (stub grieta--url-auth-request => "{\"id\": 1000, \"number\": 1, \"title\": \"Test\"}")

 (should (equal
 '(1 "Test")
 (grieta--gitea-issue "gitea.test.org" "demo" "grieta" 1)))))

(ert-deftest grieta-test-grieta--gitea-json->issues-on-invalid-data ()
 (with-mock
 ;; https://try.gitea.io/api/swagger#/issue/issueGetIssue
 (stub grieta--url-auth-request => nil)

 (should (equal
 nil ; volveremos a revisar luego si esta valor nos lleva a tener que usar condicionales
 (grieta--gitea-issue "gitea.test.org" "demo" "grieta" 1)))))

(ert-deftest grieta-test-grieta--gitea-issue-check-url-path ()
 (with-mock
 ;; https://try.gitea.io/api/swagger#/issue/issueGetIssue
 (mock (grieta--url-auth-request "gitea.test.org" "GET" "/api/v1/repos/demo/grieta/issues/99"))
 (grieta--gitea-issue "gitea.test.org" "demo" "grieta" 99)))

;; ACCEPTANCE
;; MANUAL
(provide 'grieta-tests)

make test

Test grieta-test-grieta--gitea-json->issues-on-valid-data condition:
 (wrong-number-of-arguments
 (lambda
 (host api-key method path)
 (let
 ((response ...))
 (json-parse-string response)))
 3)
 FAILED 3/3 grieta-test-grieta--gitea-json->issues-on-valid-data (0.000073 sec)

Ran 3 tests, 0 results as expected, 3 unexpected (2023-07-14 21:01:44-0500, 0.114529 sec)

3 unexpected results:
 FAILED grieta-test-grieta--gitea-issue-check-url-path
 FAILED grieta-test-grieta--gitea-json->issues-on-invalid-data
 FAILED grieta-test-grieta--gitea-json->issues-on-valid-data

Excelente ya se nos manifestó el error, procedamos a actualizar.

grieta.el

(defun grieta--url-auth-request (method token path)
 (let ((url-request-method method)
 (url-request-data path)
 (url-request-extra-headers
 (list (cons "Authorization" (concat "token " token)))))

 (with-current-buffer
 (url-retrieve-synchronously path)
 (goto-char (point-min))
 (search-forward-regexp "\n\n")
 (buffer-substring (point) (point-max)))))

(defun grieta--gitea-call (host api-key method path)
 (let ((response (grieta--url-auth-request method api-key (concat "https://" host path))))
 (if response
 (json-parse-string response)
 nil)))

(defun grieta--gitea-issue (host owner repo issue-id)
 ;; TODO: api-key?
 (let* ((remote-issue (grieta--gitea-call host nil "GET" (format "/api/v1/repos/%s/%s/issues/%d" owner repo issue-id))))
 (if remote-issue
 (list (gethash "number" remote-issue)
 (gethash "title" remote-issue))
 nil)))

;; https://www.gnu.org/software/emacs/manual/html_node/elisp/Named-Features.html
;; `provide` es necesario para luego importar con `require`
(provide 'grieta)

make test

Test grieta-test-grieta--gitea-issue-check-url-path condition:
 (mock-error
 (grieta--url-auth-request "gitea.test.org" "GET" "/api/v1/repos/demo/grieta/issues/99")
 (grieta--url-auth-request "GET" nil "https://gitea.test.org/api/v1/repos/demo/grieta/issues/99"))
 FAILED 1/3 grieta-test-grieta--gitea-issue-check-url-path (0.000096 sec)
 passed 2/3 grieta-test-grieta--gitea-json->issues-on-invalid-data (0.000044 sec)
 passed 3/3 grieta-test-grieta--gitea-json->issues-on-valid-data (0.000082 sec)

Ran 3 tests, 2 results as expected, 1 unexpected (2023-07-14 21:11:49-0500, 0.040699 sec)

excelente nos estamos ilustrando.

tests/grieta-tests.el

(require 'el-mock)
(require 'grieta)

;; UNIT
;; INTEGRATION
(ert-deftest grieta-test-grieta--gitea-json->issues-on-valid-data ()
 (with-mock
 ;; https://try.gitea.io/api/swagger#/issue/issueGetIssue
 ;; respuesta simplificada
 (stub grieta--url-auth-request => "{\"id\": 1000, \"number\": 1, \"title\": \"Test\"}")

 (should (equal
 '(1 "Test")
 (grieta--gitea-issue "gitea.test.org" "demo" "grieta" 1)))))

(ert-deftest grieta-test-grieta--gitea-json->issues-on-invalid-data ()
 (with-mock
 ;; https://try.gitea.io/api/swagger#/issue/issueGetIssue
 (stub grieta--url-auth-request => nil)

 (should (equal
 nil ; volveremos a revisar luego si esta valor nos lleva a tener que usar condicionales
 (grieta--gitea-issue "gitea.test.org" "demo" "grieta" 1)))))

(ert-deftest grieta-test-grieta--gitea-issue-check-url-path ()
 (with-mock
 ;; https://try.gitea.io/api/swagger#/issue/issueGetIssue
 (mock (grieta--url-auth-request "GET" "token" "https://gitea.test.org/api/v1/repos/demo/grieta/issues/99"))
 (grieta--gitea-issue "gitea.test.org" "demo" "grieta" 99)))

;; ACCEPTANCE
;; MANUAL
(provide 'grieta-tests)

make test

Test grieta-test-grieta--gitea-issue-check-url-path condition:
 (mock-error
 (grieta--url-auth-request "GET" "token" "/api/v1/repos/demo/grieta/issues/99")
 (grieta--url-auth-request "GET" nil "https://gitea.test.org/api/v1/repos/demo/grieta/issues/99"))
 FAILED 1/3 grieta-test-grieta--gitea-issue-check-url-path (0.000098 sec)
 passed 2/3 grieta-test-grieta--gitea-json->issues-on-invalid-data (0.000043 sec)
 passed 3/3 grieta-test-grieta--gitea-json->issues-on-valid-data (0.000080 sec)

Ran 3 tests, 2 results as expected, 1 unexpected (2023-07-14 21:14:39-0500, 0.041251 sec)

las pruebas nos esta ilustrando, diciéndonos que piensa hacer con el token? nuevamente tenemos varios caminos

crear otra función ejemplo grieta--gitea-auth-issue
usar una variable global o función que nos entregue el api-key.
adicionar otro parámetro a la función grieta--gitea-issue.

ya conocemos las implicaciones de las dos primeras, vayámonos directamente por la tercera.

invito hacer el ejerció de llegar al estado presentado desde al archivo anteriormente expuesto a este, haciendo cambios que no dejen fallar las pruebas grieta.el

(defun grieta--url-auth-request (method token path)
 (let ((url-request-method method)
 (url-request-data path)
 (url-request-extra-headers
 (list (cons "Authorization" (concat "token " token)))))

 (with-current-buffer
 (url-retrieve-synchronously path)
 (goto-char (point-min))
 (search-forward-regexp "\n\n")
 (buffer-substring (point) (point-max)))))

(defun grieta--gitea-call (host api-key method path)
 (let ((response (grieta--url-auth-request method api-key (concat "https://" host path))))
 (if response
 (json-parse-string response)
 nil)))

(defun grieta--gitea-issue (host api-key owner repo issue-id)
 ;; TODO: api-key?
 (let* ((remote-issue (grieta--gitea-call host api-key "GET" (format "/api/v1/repos/%s/%s/issues/%d" owner repo issue-id))))
 (if remote-issue
 (list (gethash "number" remote-issue)
 (gethash "title" remote-issue))
 nil)))

;; https://www.gnu.org/software/emacs/manual/html_node/elisp/Named-Features.html
;; `provide` es necesario para luego importar con `require`
(provide 'grieta)

tests/grieta-tests.el

(require 'el-mock)
(require 'grieta)

;; UNIT
;; INTEGRATION
(ert-deftest grieta-test-grieta--gitea-json->issues-on-valid-data ()
 (with-mock
 ;; https://try.gitea.io/api/swagger#/issue/issueGetIssue
 ;; respuesta simplificada
 (stub grieta--url-auth-request => "{\"id\": 1000, \"number\": 1, \"title\": \"Test\"}")

 (should (equal
 '(1 "Test")
 (grieta--gitea-issue "gitea.test.org" "token" "demo" "grieta" 1)))))

(ert-deftest grieta-test-grieta--gitea-json->issues-on-invalid-data ()
 (with-mock
 ;; https://try.gitea.io/api/swagger#/issue/issueGetIssue
 (stub grieta--url-auth-request => nil)

 (should (equal
 nil ; volveremos a revisar luego si esta valor nos lleva a tener que usar condicionales
 (grieta--gitea-issue "gitea.test.org" "token" "demo" "grieta" 1)))))

(ert-deftest grieta-test-grieta--gitea-issue-check-url-path ()
 (with-mock
 ;; https://try.gitea.io/api/swagger#/issue/issueGetIssue
 (mock (grieta--url-auth-request "GET" "token" "https://gitea.test.org/api/v1/repos/demo/grieta/issues/99"))
 (grieta--gitea-issue "gitea.test.org" "token" "demo" "grieta" 99)))

;; ACCEPTANCE
;; MANUAL
(provide 'grieta-tests)

make test

Running 3 tests (2023-07-14 21:19:48-0500, selector ‘t’)
 passed 1/3 grieta-test-grieta--gitea-issue-check-url-path (0.000064 sec)
 passed 2/3 grieta-test-grieta--gitea-json->issues-on-invalid-data (0.000033 sec)
 passed 3/3 grieta-test-grieta--gitea-json->issues-on-valid-data (0.000069 sec)

Ran 3 tests, 3 results as expected, 0 unexpected (2023-07-14 21:19:48-0500, 0.000305 sec)

boom, nuevamente estables, el proceso que realizamos de:

especular
ilustrar
ajustar (+ importante no olvidar limpiar y aclarar lo escrito)

se realiza rápidamente en cuestión de segundos.

Freeswitch Integración - event2dial

bit4bit@riseup.net (Jovany Leandro G.C) — Sat, 01 Jul 2023 16:15:01 -0500

Una de las funcionalidades más prácticas o almenos más usadas por empresas en la gestión de sus usuarios es un mecanimo que conecte al usuario con un agente ante un evento, los eventos más comunes son:

el usuario solicita que lo contacten (ejemplo al diligenciar un formulario)
un agente solicita contactar con otro usuario sin conocer el número destino (ejemplo gestión en un CRM).
contactar a usuario ante una campaña de mercadeo.

Para FreeSWITCH tenemos muy poca documentación de como realizar este tipo de integraciones así que vamos a realizar una implementación de este tipo de servicio (event2dial) desde FreeSWITCH.

Nuestro escenario sería:

Como consumidor debo estar en la capacidad de solicitar que me contacten lo más antes posible.

Para satisfacer el escenario anterio en un ambiente web, llegamos al acuerdo que el usuario pueda diligenciar un formulario para ser contactado.

FreeSWITCH es un softswitch extenso el cual ofrece diferentes medios para realizar integraciónes, donde por nombrar algunos:

por medio de mod_event_socket
por medio de lenguage integrados como: mod_lua, mod_python, mod_perl
por medio de mod_xml_curl
por medio de mod_xml_rpc
por medio de mod_httapi
o bien una mezcla de todo

para esta implementación usaremos el modulo mod_xml_rpc el cual nos ofrece un rpc para comandar el FreeSWITCH siendo la ejecución de forma sincronica es decir al comandar esperaremos por el resultado, para unas decenas de llamadas por minuto esto es suficiente pero para superar estos limites necesitariamos otra estrategia diferente.

importante antes de empezar:

conocer como instalar y operar un FreeSWITCH
ejecutable freeswitch 1.10.9 con los modulos mod_xml_rpc y mod_sofia

freeswitch.xml

<?xml version="1.0"?>
<document type="freeswitch/xml">
 <section name="configuration" description="Various Configuration">
 <configuration name="modules.conf" description="Modules">
 <modules>
 <load module="mod_console"/>
 <load module="mod_commands"/>
 <load module="mod_dptools"/>
 <!-- habilitamos el modulo de nuestro interes -->
 <load module="mod_xml_rpc"/>
 </modules>
 </configuration>

 <!-- resto de configuración -->

 <!-- configuracion minima para xml_rpc.conf OJO actualmente escucha en todas la interfaz -->
 <configuration name="xml_rpc.conf" description="XML RPC">
 <settings>
 <param name="http-port" value="8080"/>
 </settings>
 </configuration>
 </section>

 <section name="dialplan" description="Regex/XML Dialplan">
 <!-- cuando contactemos el usuario con el `originate` el FreeSWITCH
 ejecutará el siguiente plan de marcado para controlar su flujo
 áca podemos indicar acciones como:
 - conectar con un usuario/extensión
 - conectar con una linea de tierra o mobil
 - reproducir un audio
 - mover la llamada a una queue
 - iniciar un IVR
 -->
 <context name="event2dial">
 <!-- acciones a realizar una vez se logro contactar al usuario -->
 <extension name="event2dial">
 <condition>
 <!-- todas las llamadas son contestadas por el agente 1000 -->
 <action application="set" data="hangup_after_bridge=true"/>
 <action application="bridge" data="user/1000"/>
 <action application="hangup"/>
 </condition>
 </extension>
 </context>
 </section>
</document>

primero confirmamos actividad del puerto, en caso de no obtener respuesta revisar configuración de FreeSWITCH.

curl -sSG -XGET 'http://localhost:8080/xmlapi/uptime'
# 2

ahora, asumamos que tenemos configurada la pasarela celulares que nos da salida a llamadas a celulares en colombia, entonces para lanzar la llamada al numero 3001234567 seria:

curl -sSG -XGET 'http://localhost:8080/api/originate?"%7Boriginate_timeout%3D30%2Corigination_uuid%3DMYUUID%2Corigination_caller_id_name%3D123%2Corigination_caller_id_number%3D123%7Dsofia%2Fcelulares%2F3001234567%20event2dial%20XML%20event2dial%29"'

aclaraciónes:

se debe codificar por partes los argumentos del comando se separan con %20 y cada argumento se codifica con url, ejemplo de codificacion en ruby seria:
- ['{originate_timeout=30}sofia/gateway/celulares/3001234576', 'event2dial', 'XML', 'event2dial'].map { |v| URI.encode_www_form_component(v) }.join('%20')
originate_timeout = 30, esperamos almenos 30 segundos que contesten o colgamos (este comportamiento no aplica para destinos con buzón de voz).
origination_uuid = UUIDv4, asignamos identificador a la llamada.
origination_caller_id_name = 123, dependiendo de la linea destino podemos enviar un nombre a ser visualizado en el telefono.
origination_caller_id_number = 123, dependiendo de la linea destino podemos enviar el numero de origen.

estados de retorno:

+OK <uuidv4> indicando que fue exitoso el lanzamiento de la llamada

-ERR <cause> indica el motivo por el cual no se puedo lanzar la llamada

Resumiendo:

requerimos un FreeSWITCH previamente configurado con una o varias pasarelas a que nos den salida a los destinos requeridos
activar y configurar mod_xml_rpc
comandar llamada con originate por medio de HTTP.

Con lo anterior tenemos todas las herramientas para integrar FreeSWITCH en los flujos de negoció.

Kamailio as SBC for MS Teams

bit4bit@riseup.net (Jovany Leandro G.C) — Sun, 25 Jun 2023 09:11:44 -0500

Este post complementa con un ejemplo mínimo pero funcional de lo expuesto en Kamailio as SBC for MS Teams.

Escenario confirmado.

flowchart LR MSTeams["MS Teams v.2023.6.21.5 "] Kamailio["Kamailio v5.4.4 RTPEngine 11.3.1.4 "] PBX["FreeSWITCH v1.10.9 "] MSTeams ---|TLS/PUBLIC IP| Kamailio Kamailio ---|UDP/PUBLIC IP| PBX

Funcionalidades confirmadas:

Llamadas MSTeams a PBX
Llamadas PBX a MSTeams
MSTeams Hold
MSTeams Park
MSTeams Unpark

Para que esta configuracion sea efectiva debes conectar Kamailio a MS Teams y una vez confirmes que MS Teams detecta el Kamailio puedes proceder a usar la configuracion entregada.

kamailio/kamailio.cfg

#!KAMAILIO
#
# Asesorias y Consultorias a contacto@bit4bit.in
# ACTUALIZAR LOS VALORES A CONTINUACION
#!substdef "!SIPS_PORT!7062!g"
#!substdef "!SIP_PORT!5073!g"
#!substdef "!PBX_IP!3.3.3.3!g"
#!substdef "!PBX_SIP_PORT!5060!g"
#!substdef "!EXTERNAL_IP!2.2.2.2!g"
#!substdef "!EXTERNAL_FQDN!demo.bit4bit.in!g"
debug=2
log_stderror=no
log_facility=LOG_LOCAL0
log_prefix="{$mt $hdr(CSeq) $ci} "
children=8
alias=EXTERNAL_FQDN:SIPS_PORT
alias=EXTERNAL_FQDN:SIP_PORT
listen=tls:EXTERNAL_IP:SIPS_PORT advertise EXTERNAL_FQDN:SIPS_PORT
listen=udp:EXTERNAL_IP:SIP_PORT advertise EXTERNAL_FQDN:SIP_PORT
enable_tls=yes
tls_max_connections=2048
enable_sctp=no
loadmodule "kex.so"
loadmodule "corex.so"
loadmodule "tm.so"
loadmodule "tmx.so"
loadmodule "sl.so"
loadmodule "rr.so"
loadmodule "pv.so"
loadmodule "maxfwd.so"
loadmodule "textops.so"
loadmodule "textopsx.so"
loadmodule "siputils.so"
loadmodule "xlog.so"
loadmodule "ctl.so"
loadmodule "dispatcher.so"
loadmodule "rtpengine.so"
loadmodule "nathelper.so"
loadmodule "tls.so"
modparam("rtpengine", "rtpengine_sock", "udp:127.0.0.1:2223")
modparam("tls", "config", "/etc/kamailio/tls.cfg")
modparam("dispatcher", "list_file", "/etc/kamailio/dispatcher.list")
modparam("dispatcher", "ds_probing_mode", 1)
modparam("dispatcher", "ds_ping_interval", 10)
####### Routing Logic ########
request_route {
if (!mf_process_maxfwd_header("10")) {
sl_send_reply("483","Too Many Hops");
exit;
}
if(is_method("OPTIONS") && uri==myself && $rU==$null) {
sl_send_reply("200","Keepalive");
exit;
}
# FROM MSTEAMS
if($hdr(User-Agent) =~ "Microsoft.PSTNHub") {
$du = "sip:PBX_IP:PBX_SIP_PORT;transport=udp";
}
# TO MSTEAMS
else {
$du = "sip:sip.pstnhub.microsoft.com;transport=tls";
}
if ($rU==$null) {
sl_send_reply("484","Address Incomplete");
exit;
}
record_route();
route(RELAY);
}
route[RELAY] {
route(REFER);
if (is_method("INVITE|BYE|CANCEL")) {
if(!t_is_set("branch_route")) t_on_branch("MANAGE_BRANCH");
}
if (is_method("INVITE")) {
if(!t_is_set("onreply_route")) t_on_reply("MANAGE_REPLY");
}
if (!t_relay()) {
sl_reply_error();
}
exit;
}
route[RTPMANAGE] {
if (!has_body("application/sdp")) {
return;
}
if($dd =~ "sip.pstnhub.microsoft.com") {
rtpengine_offer("trust-address replace-origin replace-session-connection ICE=force transcode-PCMU transcode-G722 RTP/SAVP");
} else {
rtpengine_answer("trust-address replace-origin replace-session-connection ICE=remove RTP/AVP");
}
return;
}
route[RTPREPLY] {
if (!has_body("application/sdp")) {
return;
}
if ($fd == "PBX_IP") {
rtpengine_offer("trust-address replace-origin replace-session-connection ICE=remove RTP/AVP");
} else {
rtpengine_answer("trust-address replace-origin replace-session-connection ICE=force transcode-PCMU transcode-G722 RTP/SAVP");
}
return;
}
route[REFER] {
exclude_hf_value("Allow", "REFER");
return;
}
branch_route[MANAGE_BRANCH] {
route(RTPMANAGE);
}
onreply_route[MANAGE_REPLY] {
route(REFER);
if(status=~"[12][0-9][0-9]") {
route(RTPREPLY);
}
}
event_route[tm:local-request] {
if (is_method("OPTIONS") && $ru =~ "pstnhub.microsoft.com") {
append_hf("Contact: <sip:$fd:SIPS_PORT;transport=tls>\r\n");
}
}

kamailio/tls.cfg

[server:default]
method = TLSv1.2+
verify_certificate = no
require_certificate = no
private_key = HERE YOUR PRIVATE KEY
certificate = HERE YOUR CERTIFICATE
[client:default]
method = TLSv1.2+
verify_certificate = no
require_certificate = no
private_key = HERE YOUR PRIVATE KEY
certificate = HERE YOUR CERTIFICATE

kamailio/dispatcher.list

# setid(integer) destination(sip uri) flags (integer, optional), priority(int,opt), attrs (str,optional)
1 sip:sip.pstnhub.microsoft.com;transport=tls 0 3 socket=tls:HERE EXTERNAL IP:HERE SIPS PORT;ping_from=sip:HERE EXTERNAL FQDN
1 sip:sip2.pstnhub.microsoft.com;transport=tls 0 2 socket=tls:HERE EXTERNAL IP:HERE SIPS PORT;ping_from=sip:HERE EXTERNAL FQDN
1 sip:sip3.pstnhub.microsoft.com;transport=tls 0 1 socket=tls:HERE EXTERNAL IP:HERE SIPS PORT;ping_from=sip:HERE EXTERNAL FQDN

Para escenarios más complejos o funcionalidades no presentes puedes contactarme a contacto@bit4bit.in.

Referencias

Escribiendo un Módulo de Tryton ERP Básico 2

bit4bit@riseup.net (Jovany Leandro G.C) — Thu, 22 Jun 2023 16:40:04 -0500

Ahora el siguiente paso para personalizar trytond a nivel de código es la creación de modelos, para una solución efectiva al problema vamos a dar prioridad a la comunicación entre modelos para expresar la solución, es decir la solución no esta en los modelos en si sino en la conversación entre estos, lo anterior es importante ternelo presente cuando modelamos ya que trytond sigue el patron Active Record el cual nos invita a adherir la solución (comportamiento) a las carácteristicas (attributos) y apoyados en indicar que hacer en vez de preguntar que hacer podemos hacer más flexible el modelado antes los cambios, ahora cuando hablo de conversación entre modelos técnicamente seria la llamada de los métodos de los objetos representativos de los modelos, veamos un ejercicio un poco más complejo que el presentado en Básico 1.

Digamos que nuestro cliente vende minutos de telefonía y mensajes de texto SMS, actualmente se encuentra con el inconveniente que no tiene una plataforma para llevar control de la facturación y una vez conversado sobre el asunto se llega a la conclusión de que:

Tryton ERP es el software adecuado
se debe vincular Tryton ERP a la plataforma de telefonía para llevar el control.

En la siguiente conversación con el equipo de telefonía, nos comentan que diariamente a las 00:00-05 suben el archivo a un servidor y nos podrían dar acceso por medio de HTTP para descargar el archivo de nombre formateado yyyy-mm-dd.csv

client_code,billsec,sms,day
AB123,1000,1,2023-06-22
CP535,2000,100,2023-06-22

Con la información anterior se plantean los siguientes escenarios con el cliente para coordinar la entregar del proyecto:

Como administrador debo ser capaz de asociar tercero a un cliente de telefonía.
Diariamente conciliar los saldos entregados por telefonía.

creamos el modulo

pip3 install trytond==6.8.0 --user
pip3 install proteus --user

cookiecutter git+https://gitlab.com/bit4bit/cookiecutter-tryton-module.git --directory template --no-input module_name=charging_tel version=6.8.0 test_with_scenario=charging_tel.rst

cd charging_tel
python3 setup.py develop --user

confirmamos que tengamos operatividad

cd charging_tel
python3 -munittest

Ran 23 tests in 4.381s
OK

Escenario: Como administrador debo ser capaz de asociar Party a un cliente de telefonía.

tests/scenario_administrator_create_party_with_client_code.rst

===================
Administrador Crear Party con campo client_code Scenario
===================

Dependencias::

 >>> from proteus import Model, Wizard
 >>> from trytond.tests.tools import activate_modules

Activacion de modulos::

 >>> config = activate_modules('charging_tel')

Party con client_code::

 >>> Party = Model.get('party.party')
 >>> party = Party()
 >>> party.client_code = 'AB123' # valor real uno de los entregados
 >>> party.save()
 >>> party.client_code
 'AB123'

python3 -munittest

Failed example:
Party = Model.get('party.party')
...
return self._pool[self.database_name][type][name]
KeyError: 'party.party'

KeyError: 'party.party' ya conocemos que debemos hacer

pip3 install trytond-party==6.8.0 --user

tryton.cfg

[tryton]
version=6.8.0
depends:
ir
party
xml:

python3 -munittest

Failed example:
party.client_code = 'AB123' # valor real uno de los entregados
Exception raised:
Traceback (most recent call last):
File "/usr/lib/python3.9/doctest.py", line 1336, in __run
exec(compile(example.source, filename, "single",
File "", line 1, in 
party.client_code = 'AB123' # valor real uno de los entregados
AttributeError: 'party.party' object has no attribute 'client_code'

AttributeError: 'party.party' ya conocemos que debemos hacer

party.py

from trytond.pool import PoolMeta
from trytond.model import fields

class Party(metaclass=PoolMeta):
 __name__ = 'party.party'

 # campo para relacionar party con el cliente de telefonia
 client_code = fields.Char('Client Code', required=False)

Le indicamos a trytond el modelo que hemos extendido

init.py

from trytond.pool import Pool

from . import party

__all__ = ['register']

def register():
 Pool.register(
 party.Party,
 module='charging_tel', type_='model')

python3 -munittest

Ran 24 tests in 8.997s
OK

por ahora dejare por fuera la gestión de permisos por usuario, ya que los usuarios no administradores no deberían ser capaces de cambiar el campo client_code

ahora pasamos a verificar que el client_code sea en el formato esperado

tests/test_party_client_code.py

from trytond.tests.test_tryton import ModuleTestCase, with_transaction
from trytond.pool import Pool
from trytond.model.exceptions import ValidationError

class Party_client_code_TestCase(ModuleTestCase):
 "Test Party client_code"
 module = 'charging_tel'

 @with_transaction()
 def test_para_entrada_invalida_hay_error(self):
 pool = Pool()
 Party = pool.get('party.party')

 party, = Party.create([{'name': 'TEL'}])

 with self.assertRaises(ValidationError):
 party.client_code = '123546'
 party.save()

 with self.assertRaises(ValidationError):
 party.client_code = '3515ABC'
 party.save()

 with self.assertRaises(ValidationError):
 party.client_code = '_535'
 party.save()

 with self.assertRaises(ValidationError):
 party.client_code = 'A535.'
 party.save()

 @with_transaction()
 def test_para_entrada_valida_no_hay_error(self):
 pool = Pool()
 Party = pool.get('party.party')

 party, = Party.create([{'name': 'TELO'}])

 party.client_code = 'AB123'
 party.save()

 party.client_code = 'CP535'
 party.save()

del ModuleTestCase

python3 -munittest

Traceback (most recent call last):
File "/home/bit4bit/.local/lib/python3.9/site-packages/trytond/tests/test_tryton.py", line 223, in wrapper
result = func(*args, **kwargs)
File "/tmp/d20230622-6588-e3ry82/charging_tel/tests/test_party_client_code.py", line 18, in test_para_entrada_invalida_UserError
party.save()
AssertionError: ValidationError not raised

AssertionError: ValidationError not raised ya conocemos como proceder

party.py

import re

from trytond.pool import PoolMeta
from trytond.model import fields
from trytond.i18n import gettext
from trytond.model.exceptions import ValidationError

class Party(metaclass=PoolMeta):
 __name__ = 'party.party'

 # relacionamos party con cliente de telefonia
 client_code = fields.Char('Client Code', required=False)

 @classmethod
 def validate_fields(cls, records, field_names):
 super().validate_fields(records, field_names)
 cls.check_fields(records, field_names)

 @classmethod
 def check_fields(cls, records, field_names):
 if field_names and not (field_names & {'client_code'}):
 return

 for record in records:
 if not cls.is_allowed_client_code(record.client_code):
 raise ValidationError(gettext('charging_tel.client_code_invalid'))

 @classmethod
 def is_allowed_client_code(cls, code):
 # opcional
 if code is None:
 return True

 # formato entregado por area de telefonia
 return bool(re.match(r"^[A-Z]{2,10}[0-9]{2,8}$", code))

python3 -munittest

Ran 47 tests in 11.937s
OK

a este punto nos preguntamos si client_code debe ser único por cliente, lo cual es luego confirmado por el equipo técnico de telefonía, entonces procedemos confirmar esta restricción.

tests/test_party_client_code.py

from trytond.tests.test_tryton import ModuleTestCase, with_transaction
from trytond.pool import Pool
from trytond.model.exceptions import ValidationError

class Party_client_code_TestCase(ModuleTestCase):
 "Test Party client_code"
 module = 'charging_tel'

 @with_transaction()
 def test_para_entrada_valida_debe_ser_unico(self):
 pool = Pool()
 Party = pool.get('party.party')

 _, party = Party.create([{'name': 'TEL A', 'client_code': 'AB123'},
 {'name': 'TEL B'}])

 with self.assertRaises(Exception):
 party.client_code = 'AB123'
 party.save()

 @with_transaction()
 def test_para_entrada_invalida_hay_error(self):
 pool = Pool()
 Party = pool.get('party.party')

 party, = Party.create([{'name': 'TEL'}])

 with self.assertRaises(ValidationError):
 party.client_code = '123546'
 party.save()

 with self.assertRaises(ValidationError):
 party.client_code = '3515ABC'
 party.save()

 with self.assertRaises(ValidationError):
 party.client_code = '_535'
 party.save()

 with self.assertRaises(ValidationError):
 party.client_code = 'A535.'
 party.save()

 @with_transaction()
 def test_para_entrada_valida_no_hay_error(self):
 pool = Pool()
 Party = pool.get('party.party')

 party, = Party.create([{'name': 'TELO'}])

 party.client_code = 'AB123'
 party.save()

 party.client_code = 'CP535'
 party.save()

del ModuleTestCase

python3 -munittest

Traceback (most recent call last):
File "/home/bit4bit/.local/lib/python3.9/site-packages/trytond/tests/test_tryton.py", line 223, in wrapper
result = func(*args, **kwargs)
File "/tmp/d20230622-7701-1wybgva/charging_tel/tests/test_party_client_code.py", line 99, in test_para_entrada_valida_debe_ser_unico
party.save()
AssertionError: Exception not raised

aja ya sabemos que hacer ;)

party.py

import re

from trytond.pool import PoolMeta
from trytond.model import (Unique, fields)
from trytond.i18n import gettext
from trytond.model.exceptions import ValidationError

class Party(metaclass=PoolMeta):
 __name__ = 'party.party'

 # relacionamos party con cliente de telefonia
 client_code = fields.Char('Client Code', required=False)

 @classmethod
 def __setup__(cls):
 super().__setup__()

 # ver https://docs.tryton.org/projects/server/en/latest/ref/models.html#trytond.model.ModelSQL._sql_constraints
 t = cls.__table__()
 # hacemos efectiva la restriccion desde base de datos
 cls._sql_constraints += [
 ('client_code_unique', Unique(t, t.client_code),
 'charging_tel.msg_client_code_unique')
 ]

 @classmethod
 def validate_fields(cls, records, field_names):
 super().validate_fields(records, field_names)
 cls.check_fields(records, field_names)

 @classmethod
 def check_fields(cls, records, field_names):
 if field_names and not (field_names & {'client_code'}):
 return

 for record in records:
 if not cls.is_allowed_client_code(record.client_code):
 raise ValidationError(gettext('charging_tel.client_code_invalid'))

 @classmethod
 def is_allowed_client_code(cls, code):
 # opcional
 if code is None:
 return True

 # formato entregado por area de telefonia
 return bool(re.match(r"^[A-Z]{2,10}[0-9]{2,8}$", code))

python3 -munittest

Ran 49 tests in 12.318s
OK

Escenario: Como servicio autónomo concilio diariamente los saldos entregados por telefonía.

tests/scenario_create_recharge_tel.rst

===================
Crear Cargo de Telefonia
===================

Dependencias::

 >>> from proteus import Model, Wizard
 >>> from trytond.tests.tools import activate_modules

Activacion de modulos::

 >>> config = activate_modules('charging_tel')

Crear cargo de telefonia:

 >>> example_csv = open('tests/tel_2023-06-23.csv').read().encode()
 >>> ChargeTel = Model.get('charging_tel.charge_tel')
 >>> ChargeTel.import_csv(example_csv)
 >>> len(ChargeTel.find())
 2

python3 -munittest

Failed example:
example_csv = open('tests/tel_2023-06-23.csv').read().encode()
Exception raised:
Traceback (most recent call last):
File "/usr/lib/python3.9/doctest.py", line 1336, in __run
exec(compile(example.source, filename, "single",
File "", line 1, in 
example_csv = open('tests/tel_2023-06-23.csv').read().encode()
FileNotFoundError: [Errno 2] No such file or directory: 'tests/tel_2023-06-23.csv'

Efectivamente nos informa que no tenemos el archivo de muestra, vamos a crearlo

tests/tel_2023-06-23.csv

client_code,billsec,sms,day
ABC123,1000,1,2023-06-22
CP535,2000,100,2023-06-22

python3 -munittest

Failed example:
ChargeTel = Model.get('charging_tel.charge_tel')
...
return self._pool[self.database_name][type][name]
KeyError: 'charging_tel.charge_tel'

Aja, ya vamos volviéndonos hábiles en esto, ya sabemos que debemos hacer y es crear el modelo, para esto debemos indicarle a trytond que nuestro modelo va a gestionar datos extendiendo la clase de ModelSQL y que a su vez va ser visible al usuario ModelView adicionalmente le indicamos cuales son los campos que vamos a gestionar.

charge_tel.py

from trytond.model import ModelView, ModelSQL, fields

# le indicamos a trytond que nuestra modelo va a gestionar datos `ModelSQL`
# y va ha ser presentable desde la interfaz `ModelView`
class ChargeTel(ModelSQL, ModelView):
 "Charge Tel"
 __name__ = 'charging_tel.charge_tel'

 # habilitamos `readonly` para indicar que no puede ser editado luego de creado
 client_code = fields.Char('Client Code', readonly=True)
 billsec = fields.Integer('Billsec', readonly=True)
 sms = fields.Integer('SMS', readonly=True)
 day = fields.Date('DAY', readonly=True)

init.py

from trytond.pool import Pool

from . import party
from . import charge_tel

__all__ = ['register']

def register():
 Pool.register(
 party.Party,
 charge_tel.ChargeTel,
 module='charging_tel', type_='model')

python3 -munittest

Failed example:
ChargeTel.import_csv(example_csv)
Exception raised:
Traceback (most recent call last):
File "/usr/lib/python3.9/doctest.py", line 1336, in __run
exec(compile(example.source, filename, "single",
File "", line 1, in 
ChargeTel.import_csv(example_csv)
AttributeError: type object 'charging_tel.charge_tel' has no attribute 'import_csv'

charge_tel.py

from trytond.model import ModelView, ModelSQL, fields

class ChargeTel(ModelSQL, ModelView):
 "Charge Tel"
 __name__ = 'charging_tel.charge_tel'

 # habilitamos `readonly` para indicar que no puede ser editado luego de creado
 client_code = fields.Char('Client Code', readonly=True)
 billsec = fields.Integer('Billsec', readonly=True)
 sms = fields.Integer('SMS', readonly=True)
 day = fields.Date('DAY', readonly=True)

 @classmethod
 def import_csv(cls, path):
 pass

python3 -munittest

Failed example:
ChargeTel.import_csv(example_csv)
Exception raised:
Traceback (most recent call last):
File "/usr/lib/python3.9/doctest.py", line 1336, in __run
exec(compile(example.source, filename, "single",
File "", line 1, in 
ChargeTel.import_csv(example_csv)
AttributeError: type object 'charging_tel.charge_tel' has no attribute 'import_csv'

uuu nos indica que el modelo no tiene el atributo import_csv, que en nuestro caso esperamos sea el método de importación, podríamos hacer accesible este método a proteus usando el mecanismo RPC de trytond pero en nuestro caso publicaríamos este método solo con el objetivo de realizar la prueba, estas situaciones es un indicio que el camino que hemos tomado no es el mas adecuado sea que la prueba que planteamos es confusa o bien el mecanismo para probar no es el mas adecuado, vamos a trasladar la prueba como prueba de unidad.

rm -f tests/scenario_create_charge_tel.rst

tests/test_create_charge_tel.py

import datetime

from trytond.tests.test_tryton import ModuleTestCase, with_transaction
from trytond.pool import Pool

class CreateChargeTel(ModuleTestCase):
 "Test Create Charge Tel"
 module = 'charging_tel'

 @with_transaction()
 def test_crear_cargos_desde_csv(self):
 pool = Pool()
 ChargeTel = pool.get('charging_tel.charge_tel')

 ChargeTel.import_csv('tests/tel_2023-06-23.csv')

 charges = ChargeTel.search([])
 got = [{'client_code': c.client_code,
 'billsec': c.billsec,
 'sms': c.sms,
 'day': c.day} for c in charges]
 self.assertListEqual([
 {'client_code': 'ABC123',
 'billsec': 1000,
 'sms': 1,
 'day': datetime.date(2023, 6, 22)},
 {'client_code': 'CP535',
 'billsec': 2000,
 'sms': 100,
 'day': datetime.date(2023, 6, 22)}
 ], got)


del ModuleTestCase

python3 -munittest

Traceback (most recent call last):
File "/home/bit4bit/.local/lib/python3.9/site-packages/trytond/tests/test_tryton.py", line 223, in wrapper
result = func(*args, **kwargs)
File "/tmp/d20230623-7356-1tmqcx4/charging_tel/tests/test_create_charge_tel.py", line 16, in test_crear_cargos_desde_csv
self.assertEqual(len(charges), 2)
AssertionError: 0 != 2
----------------------------------------------------------------------
Ran 72 tests in 15.397s
FAILED (failures=1, errors=1)

excelente ya nos reconoció el método import_csv y ya con la prueba ilustrando nos, procedemos a realizar los ajustes sobre el método import_csv.

charge_tel.py

import csv
from trytond.model import ModelView, ModelSQL, fields

class ChargeTel(ModelSQL, ModelView):
 "Charge Tel"
 __name__ = 'charging_tel.charge_tel'

 # habilitamos `readonly` para indicar que no puede ser editado luego de creado
 client_code = fields.Char('Client Code', readonly=True)
 billsec = fields.Integer('Billsec', readonly=True)
 sms = fields.Integer('SMS', readonly=True)
 day = fields.Date('DAY', readonly=True)

 @classmethod
 def import_csv(cls, path):
 # https://docs.python.org/3/library/csv.html
 with open(path, newline='') as csvfile:
 reader = list(csv.DictReader(csvfile))
 return cls.create(reader)

python3 -munittest

Ran 72 tests in 15.477s
OK

muy bien, ya tenemos el metodo que nos importaría desde csv los cargos de telefonía

ahora vamos a proceder a obtener el archivo desde el endpoint entregado por telefonía.

tests/test_import_remote_charge_tel.py

import datetime
import unittest

from trytond.tests.test_tryton import ModuleTestCase, with_transaction
from trytond.pool import Pool

class ImportFromRemoteChargeTel(ModuleTestCase):
 "Import from remote endpoint Charge Tel"
 module = 'charging_tel'

 @with_transaction()
 def test_importar_cargos_desde_servicio_remote(self):
 pool = Pool()
 ChargeTel = pool.get('charging_tel.charge_tel')
 # sustituimos el metodo de descarga por una version
 # ajustada para las pruebas, evitamos las acciones sobre
 # el servicio remoto
 ChargeTel._downloader = self._fake_downloader

 ChargeTel.import_remote()

 charges = ChargeTel.search([])
 got = [{'client_code': c.client_code,
 'billsec': c.billsec,
 'sms': c.sms,
 'day': c.day} for c in charges]
 self.assertListEqual([
 {'client_code': 'ABC123',
 'billsec': 1000,
 'sms': 1,
 'day': datetime.date(2023, 6, 22)},
 {'client_code': 'CP535',
 'billsec': 2000,
 'sms': 100,
 'day': datetime.date(2023, 6, 22)}
 ], got)

 def _fake_downloader(self, year, month, day):
 with open('tests/tel_2023-06-23.csv') as f:
 return f.read().encode()

del ModuleTestCase

python3 -munittest

Traceback (most recent call last):
File "/home/bit4bit/.local/lib/python3.9/site-packages/trytond/tests/test_tryton.py", line 223, in wrapper
result = func(*args, **kwargs)
File "/tmp/d20230623-35869-15s1jvk/charging_tel/tests/test_import_remote_charge_tel.py", line 16, in test_importar_cargos_desde_servicio_remote
ChargeTel.import_remote(downloader=self._fake_downloader)
AttributeError: type object 'charging_tel.charge_tel' has no attribute 'import_remote'

Tal cual, ya vamos conociendo el ciclo de: especular, ilustrar y ajustar :).

charge_tel.py

import csv
from trytond.model import ModelView, ModelSQL, fields

class ChargeTel(ModelSQL, ModelView):
 "Charge Tel"
 __name__ = 'charging_tel.charge_tel'

 # habilitamos `readonly` para indicar que no puede ser editado luego de creado
 client_code = fields.Char('Client Code', readonly=True)
 billsec = fields.Integer('Billsec', readonly=True)
 sms = fields.Integer('SMS', readonly=True)
 day = fields.Date('DAY', readonly=True)

 @classmethod
 def import_csv(cls, path):
 # https://docs.python.org/3/library/csv.html
 with open(path, newline='') as csvfile:
 reader = list(csv.DictReader(csvfile))
 return cls.create(reader)

 @classmethod
 def import_remote(cls, downloader=None):
 if downloader is None:
 downloader = cls._downloader
 pass

 @classmethod
 def _downloader(cls):
 pass

python3 -munittest

First list contains 2 additional elements.
First extra element 0:
{'client_code': 'ABC123', 'billsec': 1000, 'sms': 1, 'day': datetime.date(2023, 6, 22)}
+ []
- [{'billsec': 1000,
- 'client_code': 'ABC123',
- 'day': datetime.date(2023, 6, 22),
- 'sms': 1},
- {'billsec': 2000,
- 'client_code': 'CP535',
- 'day': datetime.date(2023, 6, 22),
- 'sms': 100}]

Excelente, ya no tenemos errores por parte Python, ahora la prueba nos indica que no coinciden los valores, pasemos a ajustar la implementación es decir vamos a sustituir los pass por nuestra primera versión de código ejecutable.

charge_tel.py

import csv
import tempfile
import urllib.request

from trytond.model import ModelView, ModelSQL, fields
from trytond.pool import Pool

class ChargeTel(ModelSQL, ModelView):
 "Charge Tel"
 __name__ = 'charging_tel.charge_tel'

 # habilitamos `readonly` para indicar que no puede ser editado luego de creado
 # si esto es un requerimiento por parte del cliente, debemos realizar
 # una prueba para garantizar este comportamiento.
 # TODO: como procedemos si la codificacion es incorrecta a la entregada?
 client_code = fields.Char('Client Code', readonly=True)
 billsec = fields.Integer('Billsec', readonly=True)
 sms = fields.Integer('SMS', readonly=True)
 day = fields.Date('DAY', readonly=True)

 @classmethod
 def import_csv(cls, path):
 # https://docs.python.org/3/library/csv.html
 with open(path, newline='') as csvfile:
 reader = list(csv.DictReader(csvfile))
 return cls.create(reader)

 @classmethod
 def import_remote(cls, downloader=None):
 pool = Pool()
 Date = pool.get('ir.date')
 today = Date.today()

 content = cls._downloader(year=today.year,
 month=today.month,
 day=today.day)

 with tempfile.NamedTemporaryFile(prefix='charge-tel') as f:
 f.write(content)
 f.flush()
 cls.import_csv(f.name)

 @classmethod
 def _downloader(cls, year, month, day):
 return urllib.request.urlopen(f"http://example.com/{year}-{month}-{day}.csv").read()

python3 -munittest

Ran 95 tests in 0.579s
OK

uii yuiyuii, volvimos a estar estable y ya mas cerca de cerrar este escenario, ahora para hacer la importación diaria podemos usar Cron de trytond que nos facilita programar acciones.

tests/scenario_cron_importer.rst

=====================
Cron Charge Importer
=====================

Dependencias::

 >>> from proteus import Model, Wizard
 >>> from trytond.tests.tools import activate_modules

Activacion de modulos::

 >>> config = activate_modules('charging_tel')

Disparar importador desde Cron::

 >>> Cron = Model.get('ir.cron')
 >>> cron = Cron()
 >>> cron.method = 'charging_tel.charge_tel|import_remote'
 >>> cron.interval_number = 1
 >>> cron.interval_type = 'days'
 >>> cron.save()
 >>> cron.click('run_once')

python3 -munittest

raise SelectionValidationError(gettext(
trytond.model.modelstorage.SelectionValidationError: The value "charging_tel.charge_tel" for field "Method" in "4" of "Cron" is not one of the allowed options. -

como nos indica el mensaje de error no logra ubicar ese valor, el ajuste que podemos hacer es indicarle a Cron acerca de nuestro interés.

cron.py

from trytond.pool import PoolMeta

class ChargeTelCron(metaclass=PoolMeta):
 __name__ = 'ir.cron'

 @classmethod
 def __setup__(cls):
 super().__setup__()
 cls.method.selection.append(
 ('charging_tel.charge_tel|import_remote', "Import Charges From Remote Server"),
 )

e informamos a trytond

init.py

from trytond.pool import Pool

from . import party
from . import charge_tel
from . import cron

__all__ = ['register']

def register():
 Pool.register(
 party.Party,
 charge_tel.ChargeTel,
 cron.ChargeTelCron,
 module='charging_tel', type_='model')

python3 -munittest

Ran 95 tests in 0.585s
OK

muy bien todo sigue operativo y ademas ya hemos indicado a trytond nuestra intención de poder registrar un Cron para importar los registros del servidor remoto.

Ahora aunque tenemos una implementación trabajando no necesariamente es la mas adecuada, este punto es crucial ya que si continuamos adicionando caracteristicas sin reajustar el código a nuevos conceptos o eliminando los que ya cambiaron, rápidamente perderíamos el control sobre la mantenibilidad y legibilidad, las palabras que usamos en clases, métodos,variables,archivos o carpetas nos crean un vocabulario y si este vocabulario es obsoleto o distorsionado se nos dificultaría entender que es lo que el software esta realizando o bien este como participa de los objetivos del cliente, lo anterior es llamado Refactorizacion, si queremos construir un software solido debemos constantemente estar refactorizando.

Como vemos el modelo ChargeTel tienen los métodos import_csv y import_remote que tiene en común importar un archivo de formato csv, con los cargos de telefonía? nada, cuando tenemos un comportamiento que no aporta al modelo, movemos este comportamiento por fuera del modelo.

charge_tel_importer.py

from trytond.model import Model
from trytond.pool import Pool

class ChargeTelImporter(Model):
 "Charge Tel Importer"
 __name__ = 'charging_tel.charge_tel_importer'

 @classmethod
 def import_csv(cls, path):
 # https://docs.python.org/3/library/csv.html
 with open(path, newline='') as csvfile:
 reader = list(csv.DictReader(csvfile))
 return cls.create(reader)

 @classmethod
 def import_remote(cls, downloader=None):
 pool = Pool()
 Date = pool.get('ir.date')
 today = Date.today()

 content = cls._downloader(year=today.year,
 month=today.month,
 day=today.day)

 with tempfile.NamedTemporaryFile(prefix='charge-tel') as f:
 f.write(content)
 f.flush()
 cls.import_csv(f.name)

 @classmethod
 def _downloader(cls, year, month, day):
 return urllib.request.urlopen(f"http://example.com/{year}-{month}-{day}.csv").read()

python3 -munittest

File "/home/bit4bit/.local/lib/python3.9/site-packages/trytond/pool.py", line 190, in get
return self._pool[self.database_name][type][name]
KeyError: 'charging_tel.charge_tel_importer'

ya hemos visto anteriormente este error.

init.py

from trytond.pool import Pool

from . import party
from . import charge_tel
from . import cron
from . import charge_tel_importer

__all__ = ['register']

def register():
 Pool.register(
 party.Party,
 charge_tel.ChargeTel,
 cron.ChargeTelCron,
 charge_tel_importer.ChargeTelImporter,
 module='charging_tel', type_='model')

python3 -munittest

reader = list(csv.DictReader(csvfile))
NameError: name 'csv' is not defined
...
return urllib.request.urlopen(f"http://example.com/{year}-{month}-{day}.csv").read()
NameError: name 'urllib' is not defined

uuups faltaron importar las dependencias

charge_tel_importer.py

import csv
import urllib
from trytond.model import Model
from trytond.pool import Pool

class ChargeTelImporter(Model):
 "Charge Tel Importer"
 __name__ = 'charging_tel.charge_tel_importer'

 @classmethod
 def import_csv(cls, path):
 # https://docs.python.org/3/library/csv.html
 with open(path, newline='') as csvfile:
 reader = list(csv.DictReader(csvfile))
 return cls.create(reader)

 @classmethod
 def import_remote(cls, downloader=None):
 pool = Pool()
 Date = pool.get('ir.date')
 today = Date.today()

 content = cls._downloader(year=today.year,
 month=today.month,
 day=today.day)

 with tempfile.NamedTemporaryFile(prefix='charge-tel') as f:
 f.write(content)
 f.flush()
 cls.import_csv(f.name)

 @classmethod
 def _downloader(cls, year, month, day):
 return urllib.request.urlopen(f"http://example.com/{year}-{month}-{day}.csv").read()

python3 -munittest

return cls.create(reader)
AttributeError: type object 'charging_tel.charge_tel_importer' has no attribute 'create'

epa, eso nos pasa por duplicar el código.

charge_tel_importer.py

import csv
import urllib
from trytond.model import Model
from trytond.pool import Pool

class ChargeTelImporter(Model):
 "Charge Tel Importer"
 __name__ = 'charging_tel.charge_tel_importer'

 @classmethod
 def import_csv(cls, path):
 pool = Pool()
 ChargeTel = pool.get('charging_tel.charge_tel')
 # https://docs.python.org/3/library/csv.html
 with open(path, newline='') as csvfile:
 reader = list(csv.DictReader(csvfile))
 return ChargeTel.create(reader)

 @classmethod
 def import_remote(cls, downloader=None):
 pool = Pool()
 Date = pool.get('ir.date')
 today = Date.today()

 content = cls._downloader(year=today.year,
 month=today.month,
 day=today.day)

 with tempfile.NamedTemporaryFile(prefix='charge-tel') as f:
 f.write(content)
 f.flush()
 cls.import_csv(f.name)

 @classmethod
 def _downloader(cls, year, month, day):
 return urllib.request.urlopen(f"http://example.com/{year}-{month}-{day}.csv").read()

python3 -munittest

File "/usr/lib/python3.9/urllib/request.py", line 641, in http_error_default
raise HTTPError(req.full_url, code, msg, hdrs, fp)
urllib.error.HTTPError: HTTP Error 404: Not Found

urllib.error.HTTPError: HTTP Error 404: Not Found nos informa que el un hubo respuesta del servidor,esto nos esta indicando que la prueba esta haciendo la petición al servidor el cual no existe.

tests/test_import_remote_charge_tel.py

import datetime
import unittest

from trytond.tests.test_tryton import ModuleTestCase, with_transaction
from trytond.pool import Pool

class ImportFromRemoteChargeTel(ModuleTestCase):
 "Import from remote endpoint Charge Tel"
 module = 'charging_tel'

 @with_transaction()
 def test_importar_cargos_desde_servicio_remote(self):
 pool = Pool()
 ChargeTel = pool.get('charging_tel.charge_tel')
 ChargeTelImporter = pool.get('charging_tel.charge_tel_importer')
 # sustituimos el metodo de descarga por una version
 # ajustada para las pruebas, evitamos las acciones sobre
 # el servicio remoto
 ChargeTelImporter._downloader = self._fake_downloader

 ChargeTelImporter.import_remote()

 charges = ChargeTel.search([])
 got = [{'client_code': c.client_code,
 'billsec': c.billsec,
 'sms': c.sms,
 'day': c.day} for c in charges]
 self.assertListEqual([
 {'client_code': 'ABC123',
 'billsec': 1000,
 'sms': 1,
 'day': datetime.date(2023, 6, 22)},
 {'client_code': 'CP535',
 'billsec': 2000,
 'sms': 100,
 'day': datetime.date(2023, 6, 22)}
 ], got)

 def _fake_downloader(self, year, month, day):
 with open('tests/tel_2023-06-23.csv') as f:
 return f.read().encode()

del ModuleTestCase

python3 -munittest

File "/tmp/d20230624-6103-16gzx79/charging_tel/charge_tel_importer.py", line 29, in import_remote
with tempfile.NamedTemporaryFile(prefix='charge-tel') as f:
NameError: name 'tempfile' is not defined

NameError: name 'tempfile' is not defined de nuevo una dependencia que no trasladamos al crear el importador, acá se ve lo importante de las pruebas, Python es un código interpretado y hasta que el interprete no ejecute la linea en cuestión no nos enteraríamos que el comportamiento es inconsistente o bien hasta que el usuario del software lo reporte.

charge_tel_importer.py

import csv
import urllib
import tempfile
from trytond.model import Model
from trytond.pool import Pool

class ChargeTelImporter(Model):
 "Charge Tel Importer"
 __name__ = 'charging_tel.charge_tel_importer'

 @classmethod
 def import_csv(cls, path):
 pool = Pool()
 ChargeTel = pool.get('charging_tel.charge_tel')
 # https://docs.python.org/3/library/csv.html
 with open(path, newline='') as csvfile:
 reader = list(csv.DictReader(csvfile))
 return ChargeTel.create(reader)

 @classmethod
 def import_remote(cls, downloader=None):
 pool = Pool()
 Date = pool.get('ir.date')
 today = Date.today()

 content = cls._downloader(year=today.year,
 month=today.month,
 day=today.day)

 with tempfile.NamedTemporaryFile(prefix='charge-tel') as f:
 f.write(content)
 f.flush()
 cls.import_csv(f.name)

 @classmethod
 def _downloader(cls, year, month, day):
 return urllib.request.urlopen(f"http://example.com/{year}-{month}-{day}.csv").read()

charge_tel.py

from trytond.model import ModelView, ModelSQL, fields

class ChargeTel(ModelSQL, ModelView):
 "Charge Tel"
 __name__ = 'charging_tel.charge_tel'

 # habilitamos `readonly` para indicar que no puede ser editado luego de creado
 client_code = fields.Char('Client Code', readonly=True)
 billsec = fields.Integer('Billsec', readonly=True)
 sms = fields.Integer('SMS', readonly=True)
 day = fields.Date('DAY', readonly=True)

python3 -munittest

Ran 95 tests in 0.597s
OK

ahora renombramos la prueba para hacer la aclaración de que el responsable de importar es ChargeTelImporter.

tests/test_charge_tel_importer.py

import datetime

from trytond.tests.test_tryton import ModuleTestCase, with_transaction
from trytond.pool import Pool

class ChargeTelImporter(ModuleTestCase):
 "Test Charge Tel Importer"
 module = 'charging_tel'

 @with_transaction()
 def test_crear_cargos_desde_csv(self):
 pool = Pool()
 ChargeTel = pool.get('charging_tel.charge_tel')
 ChargeTelImporter = pool.get('charging_tel.charge_tel_importer')

 ChargeTelImporter.import_csv('tests/tel_2023-06-23.csv')

 charges = ChargeTel.search([])
 got = [{'client_code': c.client_code,
 'billsec': c.billsec,
 'sms': c.sms,
 'day': c.day} for c in charges]
 self.assertListEqual([
 {'client_code': 'ABC123',
 'billsec': 1000,
 'sms': 1,
 'day': datetime.date(2023, 6, 22)},
 {'client_code': 'CP535',
 'billsec': 2000,
 'sms': 100,
 'day': datetime.date(2023, 6, 22)}
 ], got)


del ModuleTestCase

eliminamos la prueba obsoleta.

rm tests/test_create_charge_tel.py

python3 -munittest

Ran 95 tests in 0.623s
OK

Excelente ya estamos estables nuevamente, ahora vamos actualizar el cron para usar el importador.

cron.py

from trytond.pool import PoolMeta

class ChargeTelCron(metaclass=PoolMeta):
 __name__ = 'ir.cron'

 @classmethod
 def __setup__(cls):
 super().__setup__()
 cls.method.selection.append(
 ('charging_tel.charge_tel_importer|import_remote', "Import Charges From Remote Server"),
 )

python3 -munittest

File "/tmp/d20230624-9646-5mhmjy/charging_tel/tests/scenario_cron_importer.rst", line 21, in scenario_cron_importer.rst
Failed example:
cron.save()
...
raise SelectionValidationError(gettext(
trytond.model.modelstorage.SelectionValidationError: The value "charging_tel.charge_tel|import_remote" for field "Method" in "4" of "Cron" is not one of the allowed options. -

efectivamente ya Cron no puede ubicar el método, debemos actualizar la prueba ya que cambio el método de importación

tests/scenario_cron_importer.rst

======================
Cron Charge Importer
======================

Dependencias::

 >>> from proteus import Model, Wizard
 >>> from trytond.tests.tools import activate_modules

Activacion de modulos::

 >>> config = activate_modules('charging_tel')

Disparar importador desde Cron::

 >>> Cron = Model.get('ir.cron')
 >>> cron = Cron()
 >>> cron.method = 'charging_tel.charge_tel_importer|import_remote'
 >>> cron.interval_number = 1
 >>> cron.interval_type = 'days'
 >>> cron.save()
 >>> cron.click('run_once')

python3 -munittest

Ran 96 tests in 0.695s
OK

Con la ultima implementación daríamos por cerrado los escenarios planteados con el cliente ademas quedamos con una suite de pruebas para garantizar lo acordado y documentación de como el software participa de los objetivos del cliente.

Por ultimo dejo como ejercicio al lector la implementación de las vistas.

En resumen:

creación del módulo usando la plantilla
escribir el módulo usando el un ciclo de: especular, ilustrar y ajustar
plantear los escenarios aceptables acordados con el cliente en doctest
informar a trytond nuestra intención por medio de tryton.cfg y init.py
extender modelo usando PoolMeta
crear nuevo modelo usando ModelSQL y ModelView
informar a trytond por medio ir.cron la posibilidad de programar tareas recurrentes.

si deseas generar el proyecto creado en este post puedes usar mdtoapp

ARTIFACT=1 TO=/tmp/basico-2 ruby mdtoapp.rb 'https://chiselapp.com/user/bit4bit/repository/bit4bit_website/raw?ci=tip&filename=content/post%2fwriting_module_trytond_basics_2.md'

Escribiendo un Modulo de Tryton ERP Básico 1

bit4bit@riseup.net (Jovany Leandro G.C) — Tue, 20 Jun 2023 16:47:56 -0500

Tryton ERP además de ERP es un excelente framework y más su versatilidad a la hora de ser personalizado, a continuación estudiaremos un poco como se puede extender el comportamiento y la vista de los módulos, el que considero como primer paso para aprender a personalizar trytond a nivel de código, asumo que se tiene conocimiento de Python, Tryton ERP y desarrollo de software en general.

Como ejercicio de práctica vamos a realizar la extensión del módulo party y adicionarle un campo, en nuestro caso vamos adicionar el campo CIIU, que en Colombia se utiliza para describir la actividad económica del tercero.

Creación del modulo

Primero instalamos dependencias necesarias para el desarrollo del módulo.

pip3 install trytond==6.8.0 --user
pip3 install proteus --user

Ahora creamos el módulo usando plantilla por medio de cookiecutter

cookiecutter git+https://gitlab.com/bit4bit/cookiecutter-tryton-module.git --directory template --no-input module_name=party_ciiu version=6.8.0 test_with_scenario=party_ciiu.rst

Lo anterior nos crea un directorio party_ciiu con la estructura de un módulo de tryton.

Activamos el módulo en modo desarrollo.

cd party_ciiu
python3 setup.py develop --user

Para confirmar que el módulo este operativo ejecutamos las pruebas.

cd party_ciiu
python3 -munittest

Y si todo es correcto veríamos

Ran 22 tests in 2.268s
OK

Adición campo `ciiu_code`

Nos vamos a orientador durante el desarrollo de la siguiente manera:

mantener el módulo todo el tiempo en operación es decir, no deberíamos tener errores por mucho más que unos minutos.
aplazar lo que mas podamos el trabajo sobre vista del módulo, ya que cuando editamos la vista se hace visible para que el usuario interactué con el modulo y si este esta incompleto abrimos el camino a las inconsistencias en el sistema.

Para avanzar y conocer el progreso de nuestro desarrollo, procederemos de la siguiente manera:

describimos los escenarios o pruebas que esperamos (etapa de especulación)
ejecutamos los escenarios o pruebas (etapa de ilustración)
corregimos el error, aclaramos la intención y volvemos al primer paso (etapa de ajuste)

Vamos a empezar creando el escenario que refleje nuestro objetivo de adicionar el campo ciiu_code

tests/scenario_create_party_with_ciiu_code.rst

===================
Crear Party con campo ciiu_code Scenario
===================

Dependencias::

 >>> from proteus import Model, Wizard
 >>> from trytond.tests.tools import activate_modules

Activacion de modulos::

 >>> config = activate_modules('party_ciiu')

Party con ciiu_code::

 >>> Party = Model.get('party.party')
 >>> party = Party()
 >>> party.ciiu_code = '0111' # valor real esperados
 >>> party.save()
 >>> party.ciiu_code
 '0111'

ejecutamos los escenarios

python3 -munittest

y vemos nuestro primer error

Failed example:
Party = Model.get('party.party')
...
File "/home/bit4bit/.local/lib/python3.9/site-packages/trytond/pool.py", line 190, in get
return self._pool[self.database_name][type][name]
KeyError: 'party.party'

KeyError: 'party.party' nos indica que estamos intentado acceder a un modelo que no esta registrado, para corregir vamos a instalar el modulo y notificar que nuestro modulo requiere del modulo party para operar.

instalamos dependencia

pip3 install trytond-party==6.8.0 --user

indicamos a trytond que requerimos del modulo party

tryton.cfg

[tryton]
version=6.8.0
depends:
ir
party
xml:

ejecutamos los escenarios

python3 -munittest

y vemos nuestro siguiente error

Failed example:
party.ciiu_code = '0110'
Exception raised:
Traceback (most recent call last):
File "/usr/lib/python3.9/doctest.py", line 1336, in __run
exec(compile(example.source, filename, "single",
File "", line 1, in 
party.ciiu_code = '0110'
AttributeError: 'party.party' object has no attribute 'ciiu_code'

AttributeError: 'party.party' object has no attribute 'ciiu_code' nos indica que estamos intentando asignar un valor a un atributo que no existe en el modelo party.party, para corregir necesitamos este atributo en party.party.

Extendemos el modelo party.party y adicionamos el nuevo atributo.

party.py

from trytond.pool import PoolMeta
from trytond.model import fields

class Party( metaclass=PoolMeta):
 __name__ = 'party.party'

 ciiu_code = fields.Char('CIIU CODE', required=False)

Le indicamos a tryton el modelo que hemos extendido

init.py

from trytond.pool import Pool

from . import party

__all__ = ['register']

def register():
 Pool.register(
 party.Party,
 module='party_ciiu', type_='model')

ejecutamos los escenarios

python3 -munittest

y por fin ya no tenemos el error

Ran 24 tests in 9.231s
OK

Lo anterior nos indica que ya el party.party tiene el nuevo atributo, pero aun no hemos realizado una implementación aceptable, una implementación aceptable es una implementación que se ajuste a los escenarios planteados o acordados con el cliente, en nuestro caso tomaremos como aceptable la implementación del ciiu_code cuando este valide que el formato sea el correcto y este entre los valores esperados según cliente.

tests/test_entrada_es_opcional.py

from trytond.tests.test_tryton import ModuleTestCase, with_transaction
from trytond.pool import Pool
from trytond.model.exceptions import RequiredValidationError

class PartyCiiu_EntradasRequeridas_TestCase(ModuleTestCase):
 "Test Party Ciiu module"
 module = 'party_ciiu'

 @with_transaction()
 def test_ciiud_code_es_opcional(self):
 pool = Pool()
 Party = pool.get('party.party')
 try:
 party, = Party.create([{}])
 except RequiredValidationError:
 self.fail('se espera campo `ciiu_code` como opcional')

del ModuleTestCase

python3 -munittest

siendo la salida de la ejecución

Ran 47 tests in 12.323s
OK

Lo cual nos indica que no hubo errores, en nuestro caso esta prueba nos garantiza que si por algún motivo cambia la obligatoriedad del campo ciiu_code nos alerte y tomemos las acciones pertinentes.

Ahora procederemos con la validación del campo, es recomendable partir de la entradas erróneas, al iniciar con la validación de las entradas erróneas se nos reduce el margen de que el programa entre en un estado inconsistente, ya que en el manejo de estas entradas es donde usualmente se presenta la mayoría de inconsistencia.

tests/test_ciiu_code.py

from trytond.tests.test_tryton import ModuleTestCase, with_transaction
from trytond.pool import Pool
from trytond.model.exceptions import ValidationError

class PartyCiiu_ciiu_code_TestCase(ModuleTestCase):
 "Test Party Ciiu campo ciiu_code"
 module = 'party_ciiu'

 @with_transaction()
 def test_para_entrada_invalida_UserError(self):
 pool = Pool()
 Party = pool.get('party.party')

 party, = Party.create([{'name': 'CIIU'}])

 with self.assertRaises(ValidationError):
 party.ciiu_code = '99999'
 party.save()

 with self.assertRaises(ValidationError):
 party.ciiu_code = '0'
 party.save()

 with self.assertRaises(ValidationError):
 party.ciiu_code = '9999'
 party.save()

del ModuleTestCase

python3 -munittest

Traceback (most recent call last):
File "/home/bit4bit/.local/lib/python3.9/site-packages/trytond/tests/test_tryton.py", line 223, in wrapper
result = func(*args, **kwargs)
File "/tmp/d20230621-16221-7fnzm8/party_ciiu/tests/test_ciiu_code.py", line 18, in test_para_entrada_invalida_UserError
party.save()
AssertionError: ValidationError not raised

AssertionError: ValidationError not raised nos indica que no se lanza el error, ahora procederemos a corregir, como hemos visto corregir seria realizar la implementación del código o bien corregir un defecto.

party_ciiu/party.py

from trytond.pool import PoolMeta
from trytond.model import fields
from trytond.i18n import gettext
from trytond.model.exceptions import ValidationError

class Party( metaclass=PoolMeta):
 __name__ = 'party.party'

 ciiu_code = fields.Char('CIIU CODE', required=False)

 @classmethod
 def validate_fields(cls, records, field_names):
 super().validate_fields(records, field_names)
 cls.check_fields(records, field_names)

 @classmethod
 def check_fields(cls, records, field_names):
 if field_names and not (field_names & {'ciiu_code'}):
 return

 for record in records:
 if not cls.allowed_ciiu_code(record.ciiu_code):
 raise ValidationError(gettext('party_ciiu.ciiu_code_invalid'))

 @classmethod
 def allowed_ciiu_code(cls, code):
 # solo validamos los codigos de interes para nuestra implementacion
 codes = [None, '0111', '0170', '0210', '0240', '0311', '0510', '0520', '0610']
 return code in codes

python3 -munittest

Ran 70 tests in 15.363s
OK

ya volvimos a estar estables, ahora vamos a confirmar que el ciiu_code este operativo según los acordado con el cliente.

tests/test_ciiu_code.py

from trytond.tests.test_tryton import ModuleTestCase, with_transaction
from trytond.pool import Pool
from trytond.model.exceptions import ValidationError

class PartyCiiu_ciiu_code_TestCase(ModuleTestCase):
 "Test Party Ciiu campo ciiu_code"
 module = 'party_ciiu'

 @with_transaction()
 def test_para_entrada_valida_no_hay_error(self):
 pool = Pool()
 Party = pool.get('party.party')

 party, = Party.create([{'name': 'CIIU Valid'}])

 # solo validamos los de interes para nuestro cliente
 company_codes = [None, '0111', '0170', '0210', '0240', '0311', '0510', '0520', '0610']
 for code in company_codes:
 party.ciiu_code = code
 party.save()

 @with_transaction()
 def test_para_entrada_invalida_UserError(self):
 pool = Pool()
 Party = pool.get('party.party')

 party, = Party.create([{'name': 'CIIU'}])

 with self.assertRaises(ValidationError):
 party.ciiu_code = '99999'
 party.save()

 with self.assertRaises(ValidationError):
 party.ciiu_code = '0'
 party.save()

 with self.assertRaises(ValidationError):
 party.ciiu_code = '9999'
 party.save()

del ModuleTestCase

python3 -munittest

Ran 71 tests in 15.529s
OK

excelente ahora que hemos validado el comportamiento aceptable por el cliente, procedemos a activarlo en la interfaz del usuario.

le indicamos al tryton que vamos a extender las vista party.party_view_tree usando el archivo view/party_list.xml y party.party_view_form con el archivo view/party_form.xml

party.xml

<?xml version="1.0"?>
<tryton>
 <data>
 <record model="ir.ui.view" id="party_view_tree">
 <field name="model">party.party</field>
 <field name="inherit" ref="party.party_view_tree"/>
 <field name="name">party_list</field>
 </record>

 <record model="ir.ui.view" id="party_view_form">
 <field name="model">party.party</field>
 <field name="inherit" ref="party.party_view_form"/>
 <field name="name">party_form</field>
 </record>
 </data>
</tryton>

view/party_form.xml

<?xml version="1.0"?>
<data>
 <xpath expr="//page[@id='general']" position="after">
 <field name="ciiu_code"/>
 </xpath>
</data>

view/party_list.xml

<?xml version="1.0"?>
<data>
 <xpath expr="//field[@name='name']" position="after">
 <field name="ciiu_code"/>
 </xpath>
</data>

e informamos a tryton nuestra intención sobre cambios a la vista, adicionando party.xml a la lista xml en tryton.cfg

tryton.cfg

[tryton]
version=6.8.0
depends:
ir
party
xml:
party.xml

Aclaro que el objetivo del ejercicio no era entrar en las particularidades para la creación del módulo, sino conocer el procedimiento en general para escribir un módulo de trytond siendo este:

creación del módulo usando la plantilla
escribir el módulo usando el un ciclo de: especular, ilustrar y ajustar
plantear los escenarios aceptables acordados con el cliente en doctest
informar a trytond nuestra intención por medio de tryton.cfg y init.py

Y para finalizar me gustaría comentar acerca de como usamos los dos mecanismos que ofrece trytond para las pruebas, estos son:

archivos .rst o doctests
pruebas por medio de unittest

Usamos las pruebas doctests para verificar que el módulo opere aceptablemente en los escenarios planteados acordados con el cliente, y usamos unittest ya para verificar en detalle el comportamiento del módulo, diríamos que este último es una lupa a los escenarios de doctests.

Agradecimientos

@rakolnivok28 por las sugerencias

Markdown To Application

bit4bit@riseup.net (Jovany Leandro G.C) — Mon, 12 Jun 2023 20:59:24 -0500

mdotapp es otra herramienta más para la programación literaria, pero con un objetivo practico: hacer ejecutable los post de este sitio, la diferencia fundamental con otras herramientas es que fácilmente podemos crear una aplicación de software es decir múltiples archivos con código ejecutable.

Uso

se permiten los siguientes atributos en el bloque:

@mdtoapp marcar el bloque para ser procesado por mdtoapp
file:<archivo> escribir contenido en el archivo indicado, se puede indicar una ruta de directorios.
@execute el bloque se debe ejecutar
executable:<command> indicar un comando diferente a sh para ejecutar el bloque
@silence no imprimir salida de la ejecución del bloque
@tdd el bloque se debe ejecutar en modo TDD
@artifact el bloque se ejecutar en modo ARTIFACT

la ejecución de los bloques es en el orden declarados en el documento.

Ejemplos

ejecutar un script

```sh @mdtoapp file:date.sh @execute
date
```

se puede crear una jerarquía de archivos

```sh @mdtoapp file:demo/demo.sh
echo 'hola'
```

```sh @mdtoapp file:run.sh @execute
bash demo/demo.sh
```

para agrupar diferentes bloques en un mismo archivo usar el mismo nombre de archivo

```sh @mdtoapp file:demo.sh
NAME=mdtoapp
```

```sh @mdtoapp file:demo.sh @execute
echo $NAME
```

crear un archivo de python y ejecutar las pruebas

```python @mdtoapp file:test.py @execute executable:python3
import unittest
class TestStringMethods(unittest.TestCase):
def test_upper(self):
self.assertEqual('foo'.upper(), 'FOO')
def test_isupper(self):
self.assertTrue('FOO'.isupper())
self.assertFalse('Foo'.isupper())
def test_split(self):
s = 'hello world'
self.assertEqual(s.split(), ['hello', 'world'])
# check that s.split fails when the separator is not a string
with self.assertRaises(TypeError):
s.split(2)
if __name__ == '__main__':
unittest.main()
```

ruby mdtoapp.rb <mi archivo markdown a ejecutar>

los post de este sitio pueden ser ejecutados usando mdtoapp.rb, ejemplo

ruby mdtoapp.rb 'https://chiselapp.com/user/bit4bit/repository/bit4bit_website/raw?ci=tip&filename=content/post%2fmdtoapp.md'

si solo el interes es generar los archivos puedes usar

TO=/tmp/out ARTIFACT=1 ruby mdtoapp.rb 'https://chiselapp.com/user/bit4bit/repository/bit4bit_website/raw?ci=tip&filename=content/post%2fmdtoapp.md'

Infrastructure Behavior Driven-Development

bit4bit@riseup.net (Jovany Leandro G.C) — Mon, 12 Jun 2023 14:59:38 -0500

(WIP)

Ahí más inventores que inventos dice un amigo mio.

Como Desarrollador y Operador de plataformas de software orientadas a telefonía (VOIP) y como practicante de TDD, me he visto envuelto en mayores responsabilidades y por lo tanto en la necesidad de mejorar el proceso de configuración y mantenimiento de los diferentes servicios, en este ejercicio he llegado a la conclusión que muchos otros ya han llegado y es usar la práctica de un entorno de pruebas automatizadas para configurar y probar los servicios.

Lo que buscamos de esta práctica es:

que la configuración de servicios entre en un ciclo de integración y despliegue continuo.
que la configuración de los servicios este orientado a comportamientos esperados.
tener un mecanismo para obtener rápidamente feedback en la configuración de los servicios.

Para ilustrar como proceder vamos a configurar el servicio pure-ftpd en base a una serie de requerimientos, usando una librería de pruebas automatizadas, en este caso usare rspec y ruby para el ejercicio.

inicializamos el entorno de pruebas de rspec

rspec --init

iniciamos con una prueba fundamental y es verificar la sintaxis de configuración.

require 'spec_helper'
require 'tempfile'

def validate_syntax(config_path)
 %x[timeout 1 /usr/sbin/pure-ftpd #{config_path}]
 $?.exitstatus == 0 || $?.exitstatus == 124
end

describe 'pure-ftpd' do
 let (:conf) { Tempfile.new('pure-ftpd') }

 describe 'configuracion' do
 it 'al verificar archivo invalido falla' do
 conf.write('invalidline')
 conf.flush

 expect(validate_syntax(conf.path)).to be false
 end

 it 'al verificar archivo valido ok' do
 conf.write('ChrootEveryone yes')
 conf.flush

 expect(validate_syntax(conf.path)).to be true
 end
 end
end

una vez tenemos un mecanismo para confirmar que la sintaxis del archivo es correcta procedemos a confirmar que el servicio inicializa y finaliza correctamente en presencia del archivo de configuracion indicado.

require 'spec_helper'
require 'tempfile'

def ftpd_start(config_path)
 pid = Process.spawn("/usr/sbin/pure-ftpd #{config_path}")
 Process.detach(pid)

 sleep 1

 port = %x{lsof -p #{pid} -itcp -a -P -n 2> /dev/null}.chomp[/TCP.+:(\d+)/,1].to_i

 {pid: pid, port: port}
end

def ftpd_alive?(server)
 # http://dev.housetrip.com/2014/03/24/ruby-pid-tip/
 Process.kill(0, server[:pid])
 true
rescue Errno::ESRCH
 false
end

def ftpd_stop(server)
 Process.kill(9, server[:pid])
rescue Errno::ESRCH
 false
end

describe 'pure-ftpd' do
 let (:conf) { Tempfile.new('pure-ftpd') }

 describe 'gestión del servicio' do
 it 'iniciar cuando el archivo de configuracion es correcto' do
 conf.write('Bind 127.0.0.1,0')
 conf.flush

 pid = ftpd_start(conf.path)

 expect(ftpd_alive?(pid)).to be true
 ensure
 ftpd_stop(pid)
 end

 it 'not iniciar cuando el archivo de configuracion es invalido' do
 conf.write('asdfs')
 conf.flush

 pid = ftpd_start(conf.path)
 expect(ftpd_alive?(pid)).to be false
 ensure
 ftpd_stop(pid)
 end
 end
end

los ejercicios anteriores nos empiezan a dar una idea de como vamos a controlar el servicio durante las pruebas, ahora vamos a proceder a configurar el servicio en base los requerimientos.

pure-ftpd.conf

Bind 127.0.0.1,8021

# funcion de utilidad para reescribir archivos de configuracion durante las pruebas
def substitute(path, match, replace)
 content = File.read(path)
 File.write(path, content.sub(match, replace))
end

before { substitute('pure-ftpd.conf', '/etc/pure-ftpd.pdb', "#{Dir.pwd}/pure-ftpd.pdb") }

no se permite ingreso anonimo

pure-ftpd.conf

NoAnonymous yes

it 'no se permite logeo anonimo' do
 server = ftpd_start(conf)

 expect do
 Net::FTP.open("127.0.0.1", port: server[:port]) do |ftp|
 ftp.login
 end
 end.to raise_error(Net::FTPPermError)
ensure
 ftpd_stop(server)
end

ingreso solo a usuarios autorizados

pure-pw useradd foo -f pure-ftpd.users -u nobody -d /tmp/foo

pure-pw mkdb pure-ftpd.pdb -f pure-ftpd.users

pure-ftpd.conf

PureDB /etc/pure-ftpd.pdb

it 'ingreso a usuarios registrados' do
 server = ftpd_start(conf)

 expect do
 Net::FTP.open("127.0.0.1", port: server[:port]) do |ftp|
 ftp.login('foo', 'foo')
 end
 end.not_to raise_error
ensure
 ftpd_stop(server)
end

it 'subir archivos solo usuarios registrados' do
 server = ftpd_start(conf)

 expect do
 Net::FTP.open("127.0.0.1", port: server[:port]) do |ftp|
 ftp.login('foo', 'foo')
 ftp.puttextfile(__FILE__, 'demo.txt')
 end
 end.not_to raise_error
ensure
 ftpd_stop(server)
end

Como vemos es posible usar las pruebas automatizadas como mecanismo para confirmar el comportamiento esperado del servicio, algunos beneficios que tenemos son:

pruebas automatizadas de confirmación.
verificar que el servicio siempre inicie (cuantas veces nos ha pasado que hemos modificado incorrectamente un archivo de configuración y luego no inicia?).
nos incentiva a llevar los archivos de configuraciones en control de versiones.

Más inventores que inventos

https://developer.ibm.com/tutorials/d-bbd-guide-iac/

¿Público y/o Públicado?

bit4bit@riseup.net (Jovany Leandro G.C) — Thu, 16 Feb 2023 21:09:34 -0500

Cuando ré/factorizamos surgen nuevos elementos de los cuales es importante determinar si son públicos y adicionalmente estan publicados, si no hacemos esta aclaración podemos fácilmente crear referencias innecesarias, veamos un ejemplo.

class Billetera
 def initialize
 @movimientos = []
 end

 def ingreso(concepto, valor)
 @movimientos << [concepto, valor]
 end

 def gasto(concepto, valor)
 @movimientos << [concepto, -valor]
 end

 def saldo
 @movimientos.inject(0) { |saldo, movimiento| saldo + movimiento[1] }
 end
end

La clase Billetera es pública y publicada (concepto común al asumir que cualquiera puede referenciar la clase y hacer uso de esta).

Ahora realicemos una refactorización buscando la apertura del concepto movimiento.

class Movimiento
 def self.debito(concepto, valor)
 new(concepto, valor)
 end

 def self.credito(concepto, valor)
 new(concepto, -valor)
 end

 def balancear(saldo)
 saldo + @valor
 end

 private

 def initialize(concepto, valor)
 @concepto = concepto
 @valor = valor
 end
end

class Cuenta
 def initialize
 @movimientos = []
 end

 def registrar(movimiento)
 @movimientos << movimiento
 end

 def saldo
 @movimientos.inject(0) { |saldo, movimiento| movimiento.balancear(saldo) }
 end
end

class Billetera
 def initialize(cuenta)
 @cuenta = cuenta
 end

 def ingreso(concepto, valor)
 @cuenta.registrar Movimiento.debito(concepto, valor)
 end

 def gasto(concepto, valor)
 @cuenta.registrar Movimiento.credito(concepto, valor)
 end

 def saldo
 @cuenta.saldo
 end
end

Las clases Billetera, Cuenta, Movimiento son por defecto públicas (este es el alcance general pero cada lenguaje tiene un comportamiento diferente por ejemplo en C# el alcance por defecto es private) ahora, ¿las nuevas clases (Cuenta, Movimiento) deben estar publicadas, es decir podemos referenciarlas desde otras secciones del programa? no, no están publicadas son elementos que surgieron de la refactorización y tienen alta cohesión con el origen de la creación (Billetera), posteriorme a la llegada de nuevos requerimientos se valoraría si deben ser publicadas.

Ahora ¿Cómo podemos hacer explicito este concepto? ni idea (si tengo ideas), es algo que queda a la creatividad del equipo ya que depende de.

About

bit4bit@riseup.net (Jovany Leandro G.C) — Wed, 15 Feb 2023 21:38:19 -0500

Profesional en el desarrollo de software con más de 10 años de experiencia en areas diversas de IT.

enseña lo que sabes aprende lo que no

Consultoría en:

Implementaciones de infraestructura altamente escalable de servicios VOIP (Asterisk, Freeswitch y Kamailio).
Implementaciones de infraestructura on-premise,serveless o cloud en AWS.
Implementaciones de infraestructura como código.
Capacitación en desarrollo de software sólido.
Desarrollo de software en Elixir, Go, Ruby, Python, PHP u otros según cliente.
Adaptación y capacitación software contable Tryton ERP.
Soluciones integradoras telefonía sobre IP (VOIP) al negocio.
Operador de sistemas operativo GNU/Linux u BSD.
Operador de servicios IT en la nube AWS Certificación

Contactar contacto@bit4bit.in

Código Libre.

GITHUB CHISELAPP

Ubicación - Colombia.

Bit4bit Integraciones

FreeSWITCH talks to MS Teams

Emacs - Básico 1

Freeswitch Integración - event2dial

Kamailio as SBC for MS Teams

Referencias

Escribiendo un Módulo de Tryton ERP Básico 2

creamos el modulo

Escenario: Como administrador debo ser capaz de asociar Party a un cliente de telefonía.

ahora pasamos a verificar que el client_code sea en el formato esperado

Escenario: Como servicio autónomo concilio diariamente los saldos entregados por telefonía.

Escribiendo un Modulo de Tryton ERP Básico 1

Creación del modulo

Adición campo ciiu_code

Agradecimientos

Markdown To Application

Uso

Ejemplos

Infrastructure Behavior Driven-Development

no se permite ingreso anonimo

ingreso solo a usuarios autorizados

Más inventores que inventos

¿Público y/o Públicado?

About

Adición campo `ciiu_code`