ApiLogicServer 15.0.65__py3-none-any.whl → 15.1.2__py3-none-any.whl

api_logic_server_cli/prototypes/manager/samples/basic_demo/api/system/gen_csv_report.py

@@ -0,0 +1,41 @@
+import json 
+import contextlib
+import logging
+from api.system.expression_parser import parsePayload
+from base64 import b64encode
+from sqlalchemy.sql import text
+import safrs
+from io import BytesIO
+from flask import request, jsonify
+    
+
+app_logger = logging.getLogger(__name__)
+
+db = safrs.DB 
+session = db.session 
+
+def gen_report(api_clz, request, entity, queryParm, columns, columnTitles, attributes) -> any:
+    filter = None #queryParm,get("filter")
+    list_of_columns = []
+    for col in columns:
+        for attr in attributes:
+            if col == attr["name"]:
+                list_of_columns.append(attr['name'])
+    rows = get_rows(api_clz,request, list_of_columns, filter)
+    #from pprint import pprint
+    #print("rows: ", pprint(rows))
+    buffer = BytesIO()
+    buffer.write(bytes('\t'.join(list_of_columns) + '\n', 'utf-8')) 
+    for row in rows["data"]:
+        buffer.write(bytes('\t'.join([str(row[col]) for col in list_of_columns]) + '\n', 'utf-8'))
+
+    return buffer.getvalue()    
+
+
+def get_rows(api_clz, request, list_of_columns, filter) -> any:
+    key = api_clz.__name__.lower()
+    request.method = 'GET'
+    from api.system.custom_endpoint import CustomEndpoint
+    custom_endpoint = CustomEndpoint(model_class=api_clz, fields=list_of_columns, filter_by=filter)
+    result = custom_endpoint.execute(request=request)
+    return custom_endpoint.transform("OntimizeEE",key, result)

api_logic_server_cli/prototypes/manager/samples/basic_demo/api/system/gen_pdf_report.py

@@ -0,0 +1,215 @@
+import json 
+import contextlib
+import logging
+from api.system.expression_parser import parsePayload
+from base64 import b64encode
+from sqlalchemy.sql import text
+import safrs
+from reportlab.lib import colors
+from reportlab.lib.pagesizes import letter
+from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, PageTemplate, Frame, Spacer
+from reportlab.lib.pagesizes import A4, letter, landscape
+from reportlab.lib.styles import getSampleStyleSheet
+from reportlab.lib.units import inch
+from io import BytesIO
+from flask import request, jsonify
+
+app_logger = logging.getLogger(__name__)
+
+db = safrs.DB 
+session = db.session 
+def export_pdf(api_clz, request, entity, queryParm, columns, columnTitles, attributes) -> any:
+    filter = None #queryParm,get("filter")
+    list_of_columns = []
+    for col in columns:
+        for attr in attributes:
+            if col == attr["name"]:
+                list_of_columns.append(attr['name'])
+    rows = get_rows(api_clz,request, list_of_columns, filter)
+    
+    buffer = BytesIO()
+    doc = SimpleDocTemplate(buffer, pagesize=landscape(letter))
+    
+    def add_page_number(canvas, doc):
+        page_num = canvas.getPageNumber()
+        text = "Page %s" % page_num
+        canvas.drawRightString(letter[0] - inch, inch, text)
+
+    page_template = PageTemplate(id='my_page_template', frames=[], onPage=add_page_number)
+    #doc.addPageTemplates([page_template])
+    
+    content = []
+
+    # Add title
+    styles = getSampleStyleSheet()
+    title_style = styles["Title"]
+    title = f"PDF Export {entity.upper()} Report" # payload["title"] if 'title' in payload and payload["title"] != '' else f"{entity.upper()} Report"
+    content.append(Paragraph(title, title_style))
+    content.append(Spacer(1, 0.2 * inch)) 
+    # Column Header
+    data = []
+    col_data = []
+    for column in list_of_columns:
+        col_data.append(column)
+        
+    # Define table data (entity)
+    table_data = []
+    table_data.append(col_data)
+    for row in rows['data']:
+        row_data = []
+        for col in list_of_columns:
+            row_data.append(row[col])
+        table_data.append(row_data)
+
+    # Create table
+    table = Table(table_data)
+    table.setStyle(TableStyle([('BACKGROUND', (0, 0), (-1, 0), colors.grey),
+                            ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
+                            ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
+                            ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+                            ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
+                            ('BACKGROUND', (0, 1), (-1, -1), colors.white),
+                            ('GRID', (0, 0), (-1, -1), 1, colors.black)]))
+
+    content.append(table)
+    
+    # Build PDF document
+    doc.build(content)  
+    return buffer.getvalue()
+
+def gen_report(api_clz, request, project_dir, payload, attributes) -> any:
+        ''' Report PDF POC https://docs.reportlab.com/
+        pip install reportlab 
+        
+        Ontimize Payload:
+        
+        {"title":"","groups":[],
+        "entity":"Customer",
+        "path":"/Customer",
+        "service":"Customer",
+        "vertical":true,
+        "functions":[],
+        "groups": ['CompanyName', 'ContactTitle', 'Address', 'City']
+        "style":{"grid":false,"rowNumber":false,"columnName":true,"backgroundOnOddRows":false,"hideGroupDetails":false,"groupNewPage":false,"firstGroupNewPage":false},
+        "subtitle":"",
+        "columns":[{"id":"Id","name":"Id"},{"id":"CompanyName","name":" Company Name*"}],
+        "orderBy":[],
+        "language":"en",
+        "filters":{"columns":["Id","CompanyName","Balance","CreditLimit","OrderCount","UnpaidOrderCount","Client_id","ContactName","ContactTitle","Address","City","Region","PostalCode","Country","Phone","Fax"],
+        "sqltypes":{"Id":1111,"CompanyName":1111,"Balance":8,"CreditLimit":8,"OrderCount":4,"UnpaidOrderCount":4,"Client_id":4,"ContactName":1111,"ContactTitle":1111,"Address":1111,"City":1111,"Region":1111,"PostalCode":1111,"Country":1111,"Phone":1111,"Fax":1111},
+        "filter":{},
+        "offset":0,
+        "style":{'grid': False, 'rowNumber': True, 'columnName': True, 'backgroundOnOddRows': False, 'hideGroupDetails': False, 'groupNewPage': False, 'firstGroupNewPage': False}
+        "pageSize":20},
+        "advQuery":true}
+        '''
+
+        expression , filter, columns, sqltypes, offset, pagesize, orderBy, data = parsePayload(api_clz, payload)
+        if len(payload) == 3:
+            return jsonify({})
+        
+        entity = payload["entity"]
+        columns = payload["columns"]
+        groups = payload.get("groups", [])
+        style = payload.get("style", {})
+
+        list_of_columns = []
+        for col in columns:
+            for attr in attributes:
+                if col['id'] == attr["name"]:
+                    list_of_columns.append(attr['name'])
+        #TODO if groups is not empty, group by the columns - new function
+        rows = get_rows(api_clz,request, list_of_columns, filter, groups)
+        
+        buffer = BytesIO()
+        if payload["vertical"] == "true":
+            doc = SimpleDocTemplate(buffer, pagesize=letter)
+        else:
+            doc = SimpleDocTemplate(buffer, pagesize=landscape(letter))
+        
+        def add_page_number(canvas, doc):
+            page_num = canvas.getPageNumber()
+            text = "Page %s" % page_num
+            canvas.drawRightString(letter[0] - inch, inch, text)
+
+        page_template = PageTemplate(id='my_page_template', frames=[], onPage=add_page_number)
+        #doc.addPageTemplates([page_template])
+        
+        content = []
+
+        # Add title
+        styles = getSampleStyleSheet()
+        title_style = styles["Title"]
+        title = payload["title"] if 'title' in payload and payload["title"] != '' else f"{entity.upper()} Report"
+        content.append(Paragraph(title, title_style))
+        content.append(Spacer(1, 0.2 * inch)) 
+        if sub_title := payload.get("subtitle",None):
+            content.append(Paragraph(sub_title, title_style))
+            content.append(Spacer(1, 0.2 * inch)) 
+        # Column Header
+        data = []
+        col_data = []
+        for column in columns:
+            col_data.append(column['name'])
+        
+        if groups and len(groups) > 0:
+            for group in groups:
+                col_data.append('count')
+                columns.append({"id":"count","name":"count"})
+    
+        # Define table data (entity)
+
+        table_data = []
+        table_data.append(col_data)
+        for row in rows['data']:
+            row_data = []
+            for col in columns:
+                row_data.append(row[col["id"]])
+            table_data.append(row_data)
+
+        # Create table
+        table = Table(table_data)
+        table.setStyle(TableStyle([('BACKGROUND', (0, 0), (-1, 0), colors.grey),
+                                ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
+                                ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
+                                ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+                                ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
+                                ('BACKGROUND', (0, 1), (-1, -1), colors.white),
+                                ('GRID', (0, 0), (-1, -1), 1, colors.black)]))
+
+        content.append(table)
+        
+        # Build PDF document
+        doc.build(content)  
+
+        #with open(f"{project_dir}/{entity}.pdf", "wb") as binary_file:
+        #   binary_file.write(buffer.getvalue())
+        
+        output =  b64encode(buffer.getvalue())
+        
+        return {"code": 0,"message": "","data": [{"file":str(output)[2:-1] }],"sqlTypes": None}
+    
+def get_rows(api_clz, request, list_of_columns, filter, groups) -> any:
+    #sql = f"{columns} FROM {entity}"
+    #return session.query(clz).all()
+    key = api_clz.__name__.lower()
+    
+    request.method = 'GET'
+    from api.system.custom_endpoint import CustomEndpoint
+    from sqlalchemy import select, func
+    custom_endpoint = CustomEndpoint(model_class=api_clz, fields=list_of_columns, filter_by=filter)
+    result = custom_endpoint.execute(request=request)
+    if groups and len(groups) > 0:
+        group_by_columns = [getattr(api_clz, group) for group in groups]
+        stmt = session.query(*[getattr(api_clz, col) for col in list_of_columns], func.count().label('count')).group_by(*group_by_columns)
+    else:
+        stmt = session.query(*[getattr(api_clz, col) for col in list_of_columns])
+
+    if filter:
+        stmt = stmt.filter(text(filter))
+
+    result = stmt.all()
+    for col in result[0]._fields:
+        result = [dict(zip(result[0]._fields, row)) for row in result]
+        break
+    return custom_endpoint.transform("OntimizeEE",key, result)

api_logic_server_cli/prototypes/manager/samples/basic_demo/api/system/opt_locking/opt_locking.py

@@ -0,0 +1,158 @@
+import datetime
+from decimal import Decimal
+from logic_bank.exec_row_logic.logic_row import LogicRow
+from logic_bank.extensions.rule_extensions import RuleExtension
+from logic_bank.logic_bank import Rule
+from database import models
+import logging
+
+import sqlalchemy
+from sqlalchemy import inspect
+from sqlalchemy import event
+from safrs import SAFRSBase
+
+from safrs.util import classproperty
+from safrs.errors import JsonapiError
+from http import HTTPStatus
+
+from config.config import OptLocking
+from config.config import Args as args
+
+logger = logging.getLogger(__name__)
+
+def opt_locking_setup(session):
+    """
+    Listen_for read events - set rows' CheckSum property for optimistic locking
+
+    Called at Server start (api_logic_server_run)...
+    """
+    @event.listens_for(session, 'loaded_as_persistent')
+    def receive_loaded_as_persistent(session, instance):
+        "listen for the 'loaded_as_persistent' (get) event - set CheckSum"
+        checksum_value = checksum_row(instance)
+        logger.debug(f'checksum_value: {checksum_value}')
+        setattr(instance, "_check_sum_property", checksum_value)
+
+def checksum(list_arg: list) -> str:
+    """
+    Args:
+        list_arg (list): list of (rows') attribute values (tuple-ize and call hash)
+
+    Returns:
+        int: hash(list values), with special handling for None
+    """
+    real_tuple = []
+    skip_none = True  # work-around for non-repeatable hash(None)
+    if skip_none:     # https://bugs.python.org/issue19224
+        real_tuple = []
+        for each_entry in list_arg:
+            if each_entry is None:
+                real_tuple.append(13)
+            else:
+                if isinstance(each_entry, list):
+                    list_hash = checksum(each_entry)
+                    real_tuple.append(list_hash)
+                elif isinstance(each_entry, set):
+                    list_from_set = list(each_entry)
+                    list_hash = checksum(list_from_set)
+                    real_tuple.append(list_hash)
+                elif isinstance(each_entry, dict):
+                    dict_tuple = []
+                    for each_key, each_value in each_entry.items():
+                        dict_tuple.append(each_value)
+                    dict_hash = checksum(dict_tuple)
+                    real_tuple.append(dict_hash)
+                else:
+                    real_tuple.append(each_entry)
+    result = hash(tuple(real_tuple))
+    # print(f'checksum[{result}] from row: {list_arg})')
+    result = str(result)  # maxint 870744036720833075 https://stackoverflow.com/questions/47188449/json-max-int-number
+    return result
+
+def checksum_row(row: object) -> str:
+    """
+    Args:
+        row (object): SQLAlchemy row
+
+    Returns:
+        int: hash(row attributes), using checksum()
+    """
+    inspector = inspect(row)
+    mapper = inspector.mapper
+    iterate_properties = mapper.iterate_properties
+    attr_list = []
+    for each_property in iterate_properties:  # does not include CheckSum
+        if each_property.key == "CheckSum":
+            logger.debug(f'checksum_row (CheckSum) - good place for breakpoint')
+        if isinstance(each_property, sqlalchemy.orm.properties.ColumnProperty):
+            # logger.debug(f'row.property: {each_property} [{getattr(row, each_property.key)}] <{type(each_property)}>')
+            if hasattr(each_property.class_attribute, "key"):
+                attr_list.append(getattr(row, each_property.class_attribute.key))
+            else:
+                debug_stop = f'no key attr - probably @jsonapi_attr'
+    return_value = checksum(attr_list)
+    # logger.debug(f'checksum_row (get) [{return_value}], inspector: {inspector}')
+    return return_value
+
+def checksum_old_row(logic_row: object) -> str:
+    """
+    Args:
+        logic_row (object): old_row (from LogicBank via declare_logic)
+
+    Returns:
+        int: hash(old_row attributes), using checksum()
+    """
+
+    inspector = inspect(logic_row.row)  # get the mapper from row, values from old_row
+    mapper = inspector.mapper
+    iterate_properties = mapper.iterate_properties
+    attr_list = []
+    for each_property in iterate_properties:  # does not include CheckSum
+        if each_property.key == "CheckSum":
+            logger.debug(f'checksum_row (CheckSum) - good place for breakpoint')
+        if isinstance(each_property, sqlalchemy.orm.properties.ColumnProperty):
+            # logger.debug(f'old_row.property: {each_property} [{getattr(logic_row.old_row, each_property.key)}] <{type(each_property)}>')
+            attr_list.append(getattr(logic_row.old_row, each_property.class_attribute.key))
+    return_value = checksum(attr_list)
+    # logger.debug(f'checksum_row (get) [{return_value}], inspector: {inspector}')
+    return return_value
+
+
+class ALSError(JsonapiError):
+    
+    def __init__(self, message, status_code=HTTPStatus.BAD_REQUEST):
+        super().__init__()
+        self.message = message
+        self.status_code = status_code
+
+
+def opt_lock_patch(logic_row: LogicRow):
+    """
+    Called by logic/declare_logic in early (before logic) event for updates (patch)
+
+    Compares as_read_checksum to old_row_checksum, to determine whether row changed since read
+
+    - as_read_checksum is submitted in patch by client, from initial get (see receive_loaded_as_persistent)
+    - old_row_checksum is provided by Logicbank - it's the current row on disk
+
+    Args:
+        logic_row (LogicRow): LogicBank row being updated
+
+    Raises:
+        ALSError: "Sorry, row altered by another user - please note changes, cancel and retry"
+        ALSError: "Optimistic Locking error - required CheckSum not present"
+    """
+    logger.debug(f'Opt Lock Patch')
+    if args.instance.opt_locking == OptLocking.IGNORED.value:
+        pass
+    elif hasattr(logic_row.row, "S_CheckSum"):
+        as_read_checksum = logic_row.row.S_CheckSum
+        old_row_checksum = checksum_old_row(logic_row)
+        if as_read_checksum != old_row_checksum:
+            logger.info(f"optimistic lock failure - as-read vs current: {as_read_checksum} vs {old_row_checksum}")
+            raise ALSError(message="Sorry, row altered by another user - please note changes, cancel and retry")
+    else:
+        if args.instance.opt_locking == OptLocking.OPTIONAL.value:
+            logger.debug(f'No CheckSum -- ok, configured as optional')
+        else:
+            raise ALSError("Optimistic Locking error - required CheckSum not present")

api_logic_server_cli/prototypes/manager/samples/basic_demo/api/system/opt_locking/readme.md

@@ -0,0 +1,225 @@
+## Problem Statement
+
+Optimistic locking is a valuable feature for interactive systems, to **avoid update overwrites** and **maximize concurrency**, **without requiring special database columns**.
+
+ 
+
+### Constraints
+
+Most systems operate under the following constraints:
+
+1. **Maximize concurrency** by be eliminating long-duration locks
+   * Rows cannot be locked (pessimistically) on read, _in case_ they are updated
+2. **No special columns**, such as  `VersionNumber`
+   * Database design is often constrained by other applications, or by internal standards
+3. **Minimize network traffic** and keep client coding simple
+   * E.g., unwieldy to send all "old" values back  
+
+ 
+
+### Avoid Update Overwrites
+
+Within these constraints, the key objective is avoid overwriting updates.  Consider the following scenario:
+
+| Time | User | Action |
+|:----- |:-------|:----|
+| T0 | U1 | Reads Row.Column with value V1  |
+| T1 | U2 | Reads same row |
+| T2 | U1 | Updates row with value V2 |
+| T3 | U2 | Updates row with value V3 - V2 value overwritten, U1 not happy |
+
+The objective, then, is to ***avoid overwriting U1's update***.
+
+ 
+
+### Optimistic Locking
+
+A widely accepted solution is **optimistic locking:** 
+
+1. On reads, no database locks are acquired
+2. On update, ensure the row has not changed since the user read it
+
+ 
+
+## Approach: virtual `CheckSum` to detect changes
+
+Before summarizing the approach, we note some key elements provided by architectural components.
+
+ 
+
+### Background: Key Architectural Elements
+
+ 
+
+#### 1. SAFRS `@jsonapi_attr`
+
+SAFRS API provides adding derived virtual (non-stored) attributes: [`@jsonapi_attr`](https://github.com/thomaxxl/safrs/blob/master/examples/demo_pythonanywhere_com.py)
+   * This enables the server to compute unstored values, here, `S_CheckSum`
+   * SAFRS supports sending such values on client `patch` operations, so it is visible in logic
+
+ 
+
+#### 2. SQLAlchemy `loaded_as_persistent`
+
+SQLAlchemy provides the `loaded_as_persistent` [event](https://docs.sqlalchemy.org/en/20/orm/events.html#sqlalchemy.orm.SessionEvents.loaded_as_persistent), enabling us to compute the `CheckSum`, store it in the row, so we can later check it on update.
+
+ 
+
+#### 3. The rules engine supports generic `before_logic`
+
+This enables us to check the row compare `CheckSum` values before updates; see [`logic/declare_logic](https://github.com/ApiLogicServer/demo/blob/main/logic/declare_logic.py).  Note such logic has access to the about-to-be-updated row, and the old-row.
+
+ 
+
+### Creation options
+
+You can configure optimistic locking when you create projects, with the following 2 CLI arguments:
+
+1. `--opt_locking_attr` - this is the name of the attribute that contains the CheckSum.  It defaults to `S_CheckSum`
+
+2. `--opt_locking` - select one of the following (default is *optional*):
+
+| Option | Included on `Get` | Checked on `Patch` |
+|:----- |:-------|:----|
+| **ignored** | Never | Never |
+| **optional** | Always | Yes - but no error if omitted |
+| **required** | Always | Yes - error if omitted |
+
+ 
+
+### Configuration options
+
+You can override the created `opt_locking` on server startup:
+
+* by updating the Config file, and
+* by using the `OPT_LOCKING` Env variable.
+
+The options are the same as shown in the table above.
+
+Note the env variables can be set on your IDE Run Configurations.
+
+ 
+
+### Processing Overview
+
+The approach is summarized in the table below.  See the the code in [`api/system/opt_locking/opt_locking.py`](https://github.com/ApiLogicServer/demo/blob/main/api/system/opt_locking/opt_locking.py) for details.
+
+ 
+
+| Phase | Responsibility | Action | Notes |
+|:-----|:-------|:-------|:----|
+| Design Time | **System** | Declare <`opt_locking_attr`> as a `@jsonapi_attr` | Project creation (CLI) builds `models.py` with @json_attr |
+| Runtime - Read | **System** | Compute Checksum | `opt_locking#loaded_as` (setup from from api_logic_server_run.py) |
+| Runtime - Call Patch | **User** App Code,<br>Admin App | Return as-read-Checksum | See examples below |
+| Runtime - Process Patch | **System** | Compare CheckSums: as-read vs. current | `opt_locking#opt_locking_patch`, via `logic/declare_logic.py`: generic before event |
+
+&nbsp;
+
+----
+&nbsp;
+
+## Exploring Optimistic Locking
+
+You can explore this using the sample database with the the Admin App, or with the cURL commands below.
+
+Use the `No Security` run config.
+
+&nbsp;
+
+### Category `Patch` - Missing S_Checksum passes
+
+This should bypass optlock check and report "can't be x"
+
+```
+curl -X 'PATCH' \
+  'http://localhost:5656/api/Category/1/' \
+  -H 'accept: application/vnd.api+json' \
+  -H 'Content-Type: application/json' \
+  -d '{
+  "data": {
+    "attributes": {
+      "Description": "x"
+    },
+    "type": "Category",
+    "id": "1"
+  }
+}'
+```
+
+&nbsp;
+
+### Category `Patch` - Invalid S_Checksum raises exception
+
+This should fail "Sorry, row altered by another user..."
+
+```
+curl -X 'PATCH' \
+  'http://localhost:5656/api/Category/1/' \
+  -H 'accept: application/vnd.api+json' \
+  -H 'Content-Type: application/json' \
+  -d '{
+  "data": {
+    "attributes": {
+      "Description": "x",
+      "S_CheckSum": "Invalid S_Checksum raises exception"
+    },
+    "type": "Category",
+    "id": "1"
+  }
+}'
+```
+
+&nbsp;
+
+### Category 9 `Patch` valid S_CheckSum passes
+
+This should bypass optlock check and report "can't be x"
+
+```
+curl -X 'PATCH' \
+  'http://localhost:5656/api/Category/9/' \
+  -H 'accept: application/vnd.api+json' \
+  -H 'Content-Type: application/json' \
+  -d '{
+  "data": {
+    "attributes": {
+      "Description": "x",
+      "S_CheckSum": "83926768455664603"
+    },
+    "type": "Category",
+    "id": "9"
+  }
+}'
+```
+&nbsp;
+
+
+### Order 10643 Set Shipped (from null)
+
+This case tests different attribute ordering (per alias attribute), resulting in different checksums.
+
+Be sure to replace the db.sqlite after the test, since this changes it.
+
+```
+curl -X 'PATCH' \
+  'http://localhost:5656/api/Order/10643/' \
+  -H 'accept: application/vnd.api+json' \
+  -H 'Content-Type: application/json' \
+  -d '{
+  "data": {
+    "attributes": {
+        "RequiredDate": "2013-10-13",
+        "Id": 10643
+    },
+    "type": "Order",
+    "id": 10643
+  }
+}'
+```
+
+```
+curl -X 'GET' \
+  'http://localhost:5656/api/Order/10643/?include=parent%2COrderDetailList%2CCustomer%2CLocation%2CEmployee%2COrderList&fields%5BOrder%5D=ShipZip%2CId%2CCustomerId%2CEmployeeId%2COrderDate%2CRequiredDate%2CShippedDate%2CShipVia%2CFreight%2CShipName%2CShipAddress%2CShipCity%2CShipRegion%2CShipCountry%2CAmountTotal%2CCountry%2CCity%2CReady%2COrderDetailCount%2CCloneFromOrder%2C_check_sum_%2CCheckSum' \
+  -H 'accept: application/vnd.api+json' \
+  -H 'Content-Type: application/vnd.api+json'
+```