Verified Commit 52fa21a8 authored by Cyril Vazquez's avatar Cyril Vazquez
Browse files

WIP

parent 1a2f1f95
Pipeline #15930 failed with stages
in 37 seconds
......@@ -19,7 +19,7 @@
* along with Maarch RM. If not, see <http://www.gnu.org/licenses/>.
*/
namespace dependency\Transformation;
namespace dependency\transformation;
/**
* The transformation engine
......@@ -34,31 +34,35 @@ class Processor
protected $jsonPath;
/**
* @var mixed
* @var object
*/
protected $source;
protected $template;
/**
* Constructs a new processor with the given template
* @param object $template
*/
public function __construct($template)
{
$this->template = $template;
}
/**
* Applies a set of rules on a source object
*
* @param object $source
* @param object $template
*/
public function transform($template, $source)
public function transform($source)
{
$this->jsonPath = \laabs::newService('dependency/json/Jsonpath', $source);
return $this->process($template);
return $this->processTemplate($this->template);
}
protected function process($instruction, $context = null)
{
if (is_string($instruction)) {
if (substr($instruction, 0, 2) == '$.' || substr($instruction, 0, 2) == '@.') {
return $this->processValue($instruction, $context);
}
return $instruction;
if ($this->isExpression($instruction)) {
return $this->processValue($instruction, $context);
}
return $this->processTemplate($instruction, $context);
......@@ -79,49 +83,50 @@ class Processor
{
$target = (object) [];
if (isset($template->select)) {
$items = $this->select($template->select, $context);
} else {
$items = [$context];
}
if (isset($template->properties)) {
foreach ($template->properties as $name => $property) {
if (!$this->isExpression($name)) {
$target->{$name} = $this->process($property, $context);
} else {
foreach ($items as $item) {
$pname = $this->process($name, $item);
$pvalue = $this->process($property, $item);
$target->{$pname} = $pvalue;
}
}
$target->{$name} = $this->process($property, $context);
}
}
return $target;
}
if (isset($template->templateProperties)) {
foreach ($template->templateProperties as $templateName => $templateProperty) {
$names = $this->select($templateName, $context);
$values = $this->select($templateProperty, $context);
while (current($names)) {
$target->{current($names)} = current($values);
protected function processTemplateProperties($templates, $target, $context = null)
{
foreach ($templates as $template) {
next($names);
next($values);
}
}
}
return $target;
}
protected function processArray($template, $context = null)
{
$items = $this->select($template->select, $context);
$target = [];
if (!isset($template->items)) {
return $items;
if (isset($template->items)) {
if (is_string($template->items)) {
$target = array_merge($target, $this->select($template->items, $context));
}
if (is_object($template->items)) {
$items = $this->select($template->items->select, $context);
foreach ($items as $item) {
$target[] = $this->process($template->items, $item);
}
}
}
$target = [];
foreach ($items as $item) {
$target[] = $this->process($template->items, $item);
if (isset($template->templateItems)) {
foreach ($template->templateItems as $templateItem) {
$target[] = $this->process($templateItem, $context);
}
}
return $target;
......@@ -131,7 +136,10 @@ class Processor
{
return (
is_string($value)
&& (substr($value, 0, 2) == '$.' || substr($value, 0, 2) == '@.')
&& (
(substr($value, 0, 2) == '$.' || substr($value, 0, 2) == '@.')
|| substr($value, 0, 6) == 'CONCAT'
)
);
}
......
......@@ -4,23 +4,21 @@ Transformation
Le composant permet de transformer des structures de données
grâce à des modèles paramétrés.
Usage
-----
La classe `Processor` fournit le moteur d'application des modèles
aux données d'entrée pour fournir les données de sortie.
Son usage est très simple : une fois le moteur instancié,
la méthode `transform` reçoit en paramètres les données en entrée
et le modèle de données;
il retourne les données transformées selon le modèle.
Le processeur ets instancié en fournissant un modèle d'application.
Une fois le moteur instancié, la méthode `transform` reçoit en paramètres
les données en entrés et retourne les données transformées selon le modèle.
```
$transformationProcessor = new Processor();
$transformationProcessor = new Processor($template);
$b = $transformationProcessor->transform($a, $template);
$b = $transformationProcessor->transform($a);
```
......@@ -56,44 +54,32 @@ modèles de transformation.
```
type: object
properties:
{value} : {template} | {expression}
{name} : {template} | {value_expression}
```
```
type: object
templateProperties:
{name_expression} : {template} | {value_expression}
```
### Modèle de tableau
Le modèle de type `array` décrit une structure qui sera retournée sous la forme d'un tableau
indexé.
Il fournit une requête de sélection des éléments à intégrer au tableau via une
instruction `select`:
instruction `items`:
```
type: array
select: {expression}
items: {values_expression}
```
Il peut fournir la définitions des éléments à évaluer avec la structure
`items`.
Chaque élément de données sélectionné par l'instruction `select` se verra
appliquer le modèle.
```
type: array
select: {expression}
items: {template} | {expression}
```
Valeurs
-------
L'instruction `value` fournit une requête de sélection de la valeur de sortie
via une expression :
templateItems: [value_expression, value_expression...]
```
value: {expression}
```
Les expressions sont le plus souvent utilisées pour fournir des valeurs
de propriétés ou éléments de tableaux scalaires.
Exemples
--------
......@@ -106,8 +92,8 @@ sources de type objet, mais en modifiant les noms :
```
type: object
properties:
targetProperty1: $.sourceProperty1
targetProperty2: $.sourceProperty2
targetPropertyName1: $.sourceValueExpression1
targetPropertyName2: $.sourceValueExpression2
```
### Objet avec propriétés nommées dynamiquement
......@@ -117,28 +103,15 @@ les valeurs** sont fournies par des expressions:
```
type: object
properties:
$.path.to.sourcePropertyName1: $.path.to.sourcePropertyValue1
$.path.to.sourcePropertyName2: $.path.to.sourcePropertyValue2
```
### Objet avec propriétés dynamiques
Le modèle suivant va prodire un objet comportant autant de propriétés que de résultats
fournis par l'expression `select`, dont le nom et les valeurs sont fournies par des expressions:
```
type: object
select: $.path.to.array.of.items
properties:
@.relative.path.to.sourcePropertyNames: @.relative.path.to.sourcePropertyValues
templateProperties:
$.sourceNameExpression1: $.sourceValueExpression1
$.sourceNameExpression2: $.sourceValueExpression2
```
### Tableau de valeurs de propriété d'objet
```
type: array
select: $.sourceArray[*]
items: @.sourcePropertyName
items: @.sourcePropertyNameExpression
```
......@@ -29,11 +29,12 @@ $sdo = \laabs::newService('dependency/sdo/Factory');
$rules = json_decode(file_get_contents('../data/maarchRM/profiles/facture.json'))->inputs->seda2_2;
$processor = \laabs::newService('dependency/Transformation/Processor');
$processor = \laabs::newService('dependency/transformation/Processor', $rules);
$message = $sdo->read('medona/message', 'MaarchRMAP_r32y2f-idih-pic1vz');
$medonaArchiveTransferController->loadData($message);
$res = $seda2ArchiveTransferController->process($message);
$res0 = $res[0]['archive_1'];
......@@ -42,7 +43,11 @@ $res0->descriptionObject->keyword[1] = clone $res0->descriptionObject->keyword[0
$res0->descriptionObject->keyword[1]->keywordContent = "TEST";
$res0->descriptionObject->keyword[1]->keywordType = "name";
var_dump($processor->transform($rules, $res0->descriptionObject));
$jsonPath = \laabs::newService('dependency/json/Jsonpath', $res0->descriptionObject);
var_dump($jsonPath->query("$.keyword.*.keywordContent"));
var_dump($processor->transform($res0->descriptionObject));
exit;
......
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment