more work

Enums.py

@@ -0,0 +1 @@
+from enum import Enum

Models.py

@@ -0,0 +1,61 @@
+class ApiResponse:
+    def __init__(self, statusCode=None, data=None, message=None):
+        self.statusCode = statusCode
+        self.isSuccessful = int(statusCode) < 400
+        self.data = data
+        self.message = message
+
+class PagingRequest:
+    def __init__(self, pageNumber, pageSize):
+        self.pageNumber = pageNumber
+        self.pageSize = pageSize
+
+class App:
+    def __init__(self, href, id, name):
+        self.href = href
+        self.id = id
+        self.name = name
+
+class GetAppsResponse:
+    def __init__(self, pageNumber, pageSize, totalPages, totalRecords, apps: list[App]):
+        self.pageNumber = pageNumber
+        self.pageSize = pageSize
+        self.totalPages = totalPages
+        self.totalRecords = totalRecords
+        self.apps = apps
+
+class GetAppByIdResponse:
+    def __init__(self, app: App):
+        self.app = app
+
+class GetAppsByIdsResponse:
+    def __init__(self, count, apps: list[App]):
+        self.count = count
+        self.apps = apps
+
+class Field:
+    def __init__(self, id, appId, name, type, status, isRequired, isUnique):
+        self.id = id
+        self.appId = appId
+        self.name = name
+        self.type = type
+        self.status = status
+        self.isRequired = isRequired
+        self.isUnique = isUnique
+
+class GetFieldByIdResponse:
+    def __init__(self, field: Field):
+        self.field = field
+
+class GetFieldsByIdsResponse:
+    def __init__(self, count, fields: list[Field]):
+        self.count = count
+        self.fields = fields
+
+class GetFieldsByAppIdResponse:
+    def __init__(self, pageNumber, pageSize, totalPages, totalRecords, fields: list[Field]):
+        self.pageNumber = pageNumber
+        self.pageSize = pageSize
+        self.totalPages = totalPages
+        self.totalRecords = totalRecords
+        self.fields = fields

OnspringClient.py

@@ -1,6 +1,9 @@
+from dataclasses import fields
 import requests
 import json
 from UrlHelper import *
+from Models import *
+
 
 class OnspringClient:
     def __init__(self, url, key):
@@ -9,83 +12,336 @@ class OnspringClient:
             'x-apikey': key,
             'x-api-version': '2'
         }
-    
+
-    # verify connectivity 
+    # connectivity methods
 
     def canConnect(self):
-        
+
         endpoint = GetPingEndpoint(self.baseUrl)
 
-        response = requests.request('GET', endpoint, headers=self.headers)
+        response = requests.request(
+            'GET', 
+            endpoint, 
+            headers=self.headers)
 
         return response.status_code == 200
 
-    # apps
+    # app methods
+
+    def GetApps(self, pagingRequest=PagingRequest(1, 50)):
 
-    def GetApps(self, pageNumber=1, pageSize=50):
-        
         endpoint = GetAppsEndpoint(self.baseUrl)
 
-        params={
+        params = pagingRequest.__dict__
-            'PageNumber': pageNumber,
-            'PageSize': pageSize
-        }
 
-        response = requests.request('GET', endpoint, headers=self.headers, params=params)
+        response = requests.request(
+            'GET', 
+            endpoint, 
+            headers=self.headers, 
+            params=params)
 
-        if(response.status_code == 400):
+        if response.status_code == 400:
-            return {'Message': 'Invalid paging information.'}
+            return ApiResponse(
-        
+                response.status_code,
-        if(response.status_code == 401):
+                message='Invalid paging information')
-            return {'Message': 'Unauthorized request.'}
 
-        return response.json()
+        if response.status_code == 401:
+            return ApiResponse(
+                response.status_code, 
+                message='Unauthorized request')
+
+        responseJson = response.json()
+
+        apps = []
+
+        for item in responseJson['items']:
+            app = App(
+                item['href'], 
+                item['id'], 
+                item['name'])
+            
+            apps.append(app)
+
+        data = GetAppsResponse(
+            responseJson['pageNumber'], 
+            responseJson['pageSize'], 
+            responseJson['totalPages'], 
+            responseJson['totalRecords'], 
+            apps)
+
+        return ApiResponse(
+            response.status_code, 
+            data)
+
+    def GetAppById(self, appId: int):
 
-    def GetAppById(self, appId):
-        
         endpoint = GetAppByIdEndpoint(self.baseUrl, appId)
 
-        response = requests.request('GET', endpoint, headers=self.headers)
+        response = requests.request(
+            'GET', 
+            endpoint, 
+            headers=self.headers)
 
-        if(response.status_code == 401):
+        if response.status_code == 401:
-            return {'Message': 'Unauthorized request.'}
+            return ApiResponse(
-        
+                response.status_code,
-        if(response.status_code == 403):
+                message='Unauthorized request'
-            return {'Message': 'Client does not have read access to the app.'}
+            )
-        
-        if(response.status_code == 404):
-            return {'Message': 'App could not be found.'}
 
-        return response.json()
+        if response.status_code == 403:
+            return ApiResponse(
+                response.status_code,
+                message='Client does not have read access to the app'
+            )
 
-    def GetAppByIds(self, appIds):
+        if response.status_code == 404:
+            return ApiResponse(
+                response.status_code,
+                message='App could not be found'
+            )
         
+        responseJson = response.json()
+
+        app = App(
+            responseJson['href'],
+            responseJson['id'],
+            responseJson['name'])
+
+        data = GetAppByIdResponse(app)
+
+        return ApiResponse(
+            response.status_code,
+            data
+        )
+
+    def GetAppByIds(self, appIds: list):
+
         endpoint = GetAppByIdsEndpoint(self.baseUrl)
 
-        self.headers["Content-Type"] = "application/json"
+        self.headers['Content-Type'] = 'application/json'
+
+        # make sure appIds can be serialized to json string
+        if not isinstance(appIds, (list, tuple)):
+            return ApiResponse(
+                400,
+                message='App ids should be of type list or tuple')
+
+        appIds = json.dumps(appIds)
+
+        response = requests.request(
+            'POST', 
+            endpoint, 
+            headers=self.headers, 
+            data=appIds)
+
+        if response.status_code == 401:
+            return ApiResponse(
+                response.status_code,
+                message='Unauthorized request'
+            )
+
+        if response.status_code == 403:
+            return ApiResponse(
+                response.status_code,
+                message='Client does not have read access to the app'
+            )
+
+        responseJson = response.json()
+
+        apps = []
+
+        for item in responseJson['items']:
+            app = App(
+                item['href'], 
+                item['id'], 
+                item['name'])
+            
+            apps.append(app)
+
+        data = GetAppsByIdsResponse(
+            responseJson['count'],
+            apps
+        )
+
+        return ApiResponse(
+            response.status_code,
+            data
+        )
+
+    # field methods
+
+    def GetFieldById(self, fieldId: int):
+
+        endpoint = GetFieldByIdEndpoint(self.baseUrl, fieldId)
+
+        response = requests.request(
+            'GET', 
+            endpoint, 
+            headers=self.headers)
+
+        if response.status_code == 401:
+            return ApiResponse(
+                response.status_code,
+                message='Unauthorized request'
+            )
+
+        if response.status_code == 403:
+            return ApiResponse(
+                response.status_code,
+                message='Client does not have read access to the field'
+            )
+
+        if response.status_code == 404:
+            return ApiResponse(
+                response.status_code,
+                message='Field could not be found'
+            )
         
-        if(not isinstance(appIds, (list, tuple))):
+        jsonResponse = response.json()
-            return {'Message': 'App ids should be of type list or tuple.'}
-    
-        data = json.dumps(appIds)
 
-        response = requests.request("POST", endpoint, headers=self.headers, data=data)
+        field = Field(
+            jsonResponse['id'],
+            jsonResponse['appId'],
+            jsonResponse['name'],
+            jsonResponse['type'],
+            jsonResponse['status'],
+            jsonResponse['isRequired'],
+            jsonResponse['isUnique'],
+        )
 
-        if(response.status_code == 401):
+        data = GetFieldByIdResponse(field)
-            return {'Message': 'Unauthorized request.'}
-        
-        if(response.status_code == 403):
-            return {'Message': 'Client does not have read access to the app.'}
 
-        return response.json()
+        return ApiResponse(
+            response.status_code,
+            data
+        )
 
+    def GetFieldsByIds(self, fieldIds: list):
+
+        endpoint = GetFieldsByIdsEndpoint(self.baseUrl)
+
+        self.headers['Content-Type'] = 'application/json'
+
+        # make sure fieldIds can be serialized to json string
+        if not isinstance(fieldIds, (list, tuple)):
+            return ApiResponse(
+                400,
+                message='Field ids should be of type list or tuple')
+
+        fieldIds = json.dumps(fieldIds)
+
+        response = requests.request(
+            'POST', 
+            endpoint, 
+            headers=self.headers, 
+            data=fieldIds)
+
+        if response.status_code == 401:
+            return ApiResponse(
+                response.status_code,
+                message='Unauthorized request'
+            )
+
+        if response.status_code == 403:
+            return ApiResponse(
+                response.status_code,
+                message='Client does not have read access to the field(s)'
+            )
+
+        if response.status_code == 404:
+            return ApiResponse(
+                response.status_code,
+                message='Field(s) could not be found'
+            )
+
+        responseJson = response.json()
+
+        fields = []
+
+        for item in responseJson['items']:
+            field = Field(
+                item['id'], 
+                item['appId'], 
+                item['name'],
+                item['type'],
+                item['status'],
+                item['isRequired'],
+                item['isUnique'])
+            
+            fields.append(field)
+
+        data = GetFieldsByIdsResponse(
+            responseJson['count'],
+            fields
+        )
+
+        return ApiResponse(
+            response.status_code,
+            data
+        )
+
+    def GetFieldsByAppId(self, appId: int, pagingRequest=PagingRequest(1, 50)):
+
+        endpoint = GetFieldsByAppIdEndpoint(self.baseUrl, appId)
+
+        params = pagingRequest.__dict__
+
+        response = requests.request(
+            'GET', 
+            endpoint, 
+            headers=self.headers, 
+            params=params)
+
+        if response.status_code == 400:
+            return ApiResponse(
+                response.status_code,
+                message='Invalid paging information')
+
+        if response.status_code == 401:
+            return ApiResponse(
+                response.status_code, 
+                message='Unauthorized request')
+
+        responseJson = response.json()
+
+        fields = []
+
+        for item in responseJson['items']:
+            field = Field(
+                item['id'], 
+                item['appId'], 
+                item['name'],
+                item['type'],
+                item['status'],
+                item['isRequired'],
+                item['isUnique'])
+            
+            fields.append(field)
+
+        data = GetFieldsByAppIdResponse(
+            responseJson['pageNumber'], 
+            responseJson['pageSize'], 
+            responseJson['totalPages'], 
+            responseJson['totalRecords'], 
+            fields)
+
+        return ApiResponse(
+            response.status_code, 
+            data)
+
+    # file methods
+
+    # list methods
+
+    # record methods
+
+    # report methods
 
-        
 url = 'https://api.onspring.com'
 apiKey = '61642d8c686f9e8747e42af8/52cae9a9-4c49-48b6-a3fe-10a48d46ac69'
 
-onspringClient = OnspringClient(url,apiKey)
+onspringClient = OnspringClient(url, apiKey)
 
-data = (8,)
+response = onspringClient.GetFieldsByAppId(8)
 
-print(onspringClient.GetAppByIds(data))
+print()

UrlHelper.py

@@ -1,6 +1,10 @@
+# connectivity endpoints
+
 def GetPingEndpoint(baseUrl):
     return f'{baseUrl}/Ping'
 
+# app endpoints
+
 def GetAppsEndpoint(baseUrl):
     return f'{baseUrl}/Apps'
 
@@ -8,4 +12,23 @@ def GetAppByIdEndpoint(baseUrl, appId):
     return f'{baseUrl}/Apps/id/{appId}'
 
 def GetAppByIdsEndpoint(baseUrl):
-    return f'{baseUrl}/Apps/batch-get'
+    return f'{baseUrl}/Apps/batch-get'
+
+# field endpoints
+
+def GetFieldByIdEndpoint(baseUrl, fieldId):
+    return f'{baseUrl}/Fields/id/{fieldId}'
+
+def GetFieldsByIdsEndpoint(baseUrl):
+    return f'{baseUrl}/Fields/batch-get'
+
+def GetFieldsByAppIdEndpoint(baseUrl, appId):
+    return f'{baseUrl}/Fields/appId/{appId}'
+
+# file endpoints
+
+# list endpoints
+
+# record endpoints
+
+# report endpoints

python.gitignore

@@ -0,0 +1,160 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/