def view_clients_get(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
if client_id is None:
raise exception.HTTPBadRequest(detail='Missing required parameters',
explanation='Client Id is required')
services = request.services()
client = None
try:
clientsStore = services['store.admin.clients']
client = clientsStore.get(client_id)
except Exception as e:
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
if client is None:
raise exception.HTTPInternalServerError(detail='Client not found',
explanation='Client not found')
else:
raise exception.HTTPOk(detail='client',
body={
'client': {
'id': client[0],
'active': client[1],
'name': client[2],
'address': client[3],
'countryId': client[4],
'currencyId': client[5]
}
})
def api_common_countries_get(request):
params = request.json_body
country_id = params['countryId'] if 'countryId' in params else None
if country_id is None:
raise exception.HTTPBadRequest(
detail='Missing required parameters',
explanation='Country Id is required'
)
services = request.services()
store = services['store.common.countries']
country = {}
try:
r = store.get(country_id)
country = {
'name': r[0],
'alpha_2': r[1],
'alpha_3': r[2],
'id': r[3]
}
except Exception as e:
log.error(e)
raise exception.HTTPInternalServerError(
detail=str(e),
explanation=str(e)
)
raise exception.HTTPOk(
detail='country found',
body={
'country': country
}
)
def view_clients_user_remove(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
user_id = params['userId'] if 'userId' in params else None
if client_id is None or user_id is None:
raise exception.HTTPBadRequest(
detail='Missing required parameter',
explanation='Client Id and User Id is required'
)
services = request.services()
try:
usersStore = services['store.admin.users']
usersStore.removeClientUser(client_id, user_id)
except Exception as e:
log.error(e)
raise exception.HTTPInternalServerError(
detail=str(e),
explanation=str(e)
)
raise exception.HTTPOk(
detail='Client User removed',
body={'message': 'Client User removed'}
)
def api_purchasing_vendor_get(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
vendor_id = params['vendorId'] if 'vendorId' in params else None
if client_id is None or filter is None:
raise exception.HTTPBadRequest(
detail='Missing required parameter',
explanation='Client Id and filter is required')
services = request.services()
vendorStore = services['store.purchasing.vendors']
vendor = {}
try:
r = vendorStore.get(client_id, vendor_id)
vendor = {
'id': r[0],
'name': r[1],
'address': r[2],
'country_id': r[3]
}
except Exception as e:
log.error(e)
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail='vendor found', body={'vendor': vendor})
def api_hr_shifts_filter(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
filter = params['filter'] if 'filter' in params else None
if client_id is None or filter is None:
raise exception.HTTPBadRequest(
detail='Missing required parameters',
explanation='Client Id and filter is required')
services = request.services()
store = services['store.hr.shifts']
shifts = []
try:
result = store.filter(client_id, filter)
shifts = [{
'id': r[0],
'active': r[1],
'created': r[2],
'name': r[3],
'start': r[4],
'end': r[5]
} for r in result]
except Exception as e:
log.error(e)
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail=f'{len(result)} shifts found',
body={'shifts': shifts})
def api_accounting_account_get(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
account_id = params['accountId'] if 'accountId' in params else None
if client_id is None:
raise exception.HTTPBadRequest(
detail='Missing required parameter',
explanation='Client Id and Account Id is required')
services = request.services()
account = {}
try:
accountStore = services['store.accounting.accounts']
r = accountStore.get(client_id, account_id)
account = {
'id': r[0],
'active': r[1],
'created_ts': r[2],
'type_id': r[3],
'name': r[4],
'description': r[5]
}
except StoreException as e:
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail='account found', body={'account': account})
def api_members_filter(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
filter = params['filter'] if 'filter' in params else None
if client_id is None or filter is None:
raise exception.HTTPBadRequest(
detail='Missing required parameters',
explanation='Client Id and filter is required')
services = request.services()
membersStore = services['store.hr.members']
members = []
try:
result = membersStore.filter(client_id, filter)
members = [{
'id': r[0],
'firstName': r[1],
'middleName': r[2],
'lastName': r[3],
'prefix': r[4],
'suffix': r[5]
} for r in result]
except Exception as e:
log.error(e)
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail=f'{len(members)} members found',
body={'members': members})
def view_inventory_item_substitutes_add(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
item_id = params['itemId'] if 'itemId' in params else None
substitute_item_id = params[
'substituteItemId'] if 'substituteItemId' in params else None
if client_id is None or item_id is None or substitute_item_id is None:
raise exception.HTTPBadRequest(
detail='Missing required parameters',
explanation='Client Id, Item Id and Substitute Item Id is required'
)
services = request.services()
itemStore = services['store.inventory.items']
try:
itemStore.addSubstitute(client_id, item_id, substitute_item_id)
except ValidationError as e:
log.error(e)
raise exception.HTTPBadRequest(detail=e.message,
explanation='Incorrect parameters')
except Exception as e:
log.error(e)
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(
detail='Inventory Item Substitute record created',
body={'message': 'Inventory Item Substitute record created'})
def serve_websocket(request, port):
"""Start UWSGI websocket loop and proxy."""
env = request.environ
# Send HTTP response 101 Switch Protocol downstream
uwsgi.websocket_handshake(env['HTTP_SEC_WEBSOCKET_KEY'],
env.get('HTTP_ORIGIN', ''))
# Map the websocket URL to the upstream localhost:4000x Notebook instance
parts = urlparse(request.url)
parts = parts._replace(scheme="ws", netloc="localhost:{}".format(port))
url = urlunparse(parts)
# Proxy initial connection headers
headers = [(header, value) for header, value in request.headers.items()
if header.lower() in CAPTURE_CONNECT_HEADERS]
logger.info("Connecting to upstream websockets: %s, headers: %s", url,
headers)
ws = ProxyClient(url, headers=headers)
ws.connect()
# TODO: Will complain loudly about already send headers - how to abort?
return httpexceptions.HTTPOk()
def view_inventory_items_uom(request):
params = request.json_body
dimension = params['dimension'] if 'dimension' in params else ''
services = request.services()
uoms = []
try:
uomStore = services['store.common.uom']
result = []
if dimension == 'length':
result = uomStore.length()
elif dimension == 'area':
result = uomStore.area()
elif dimension == 'volume':
result = uomStore.volume()
elif dimension == 'weight':
result = uomStore.weight()
elif dimension == 'quantity':
result = uomStore.quantity()
elif dimension == '':
result = uomStore.all()
uoms = [{'id': r[0], 'name': r[1], 'symbol': r[2]} for r in result]
except Exception as e:
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail='{0} uom found'.format(len(uoms)),
body={'uoms': uoms})
def view_inventory_item_update(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
if client_id is None:
raise exception.HTTPBadRequest(detail='Missing required parameter',
explanation='Client Id is required')
services = request.services()
itemStore = services['store.inventory.items']
validator = services['validator.json']
try:
# validate( instance = params, schema = schema)
validator.validate(instance=params, schema_file='/inventory/item.json')
itemStore.update(params)
except ValidationError as e:
log.error(e)
raise exception.HTTPBadRequest(detail=e.message,
explanation='Incorrect parameters')
except Exception as e:
log.error(e)
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail='Inventory Item record updated',
body={'message': 'Inventory Item record updated'})
def api_inventory_locations_get(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
location_id = params['locationId'] if 'locationId' in params else None
if client_id is None or filter is None:
raise exception.HTTPBadRequest(
detail='Missing required parameters',
explanation='Client Id and Location Id is required')
services = request.services()
store = services['store.inventory.locations']
location = {}
try:
r = store.get(client_id, location_id)
location = {
'id': r[0],
'facilityId': r[1],
'name': r[2],
'floorId': r[3],
'aisleId': r[4],
'areaId': r[5],
'sectionId': r[6],
'shelfId': r[7],
'rackId': r[8],
'levelId': r[9],
'binId': r[10]
}
except Exception as e:
log.error(e)
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail='location found',
body={'location': location})
def api_inventory_locations_update(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
location_id = params['locationId'] if 'locationId' in params else None
facility_id = params['facilityId'] if 'facilityId' in params else None
name = params['name'] if 'name' in params else None
floor_id = params['floorId'] if 'floorId' in params else None
aisle_id = params['aisleId'] if 'aisleId' in params else None
area_id = params['areaId'] if 'areaId' in params else None
section_id = params['sectionId'] if 'sectionId' in params else None
shelf_id = params['shelfId'] if 'shelfId' in params else None
rack_id = params['rackId'] if 'rackId' in params else None
level_id = params['levelId'] if 'levelId' in params else None
bin_id = params['binId'] if 'binId' in params else None
if client_id is None or location_id is None or facility_id is None or name is None:
raise exception.HTTPBadRequest(
detail='Missing required parameters',
explanation='Client Id, Warehouse Id and name is required')
services = request.services()
store = services['store.inventory.locations']
try:
store.update(client_id, location_id, facility_id, name, floor_id,
aisle_id, area_id, section_id, shelf_id, rack_id,
level_id, bin_id)
except Exception as e:
log.error(e)
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail='Inventory Location update',
body={'message': 'Inventory Location update'})
def api_inventory_locations_filter(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
filter = params['filter'] if 'filter' in params else None
if client_id is None or filter is None:
raise exception.HTTPBadRequest(
detail='Missing required parameters',
explanation='Client Id and filter is required')
services = request.services()
store = services['store.inventory.locations']
locations = []
try:
result = store.filter(client_id, filter)
locations = [{
'id': r[0],
'facilityId': r[1],
'name': r[2],
'floorId': r[3],
'aisleId': r[4],
'areaId': r[5],
'sectionId': r[6],
'shelfId': r[7],
'rackId': r[8],
'levelId': r[9],
'binId': r[10]
} for r in result]
except Exception as e:
log.error(e)
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail=f'{len(locations)} locations found',
body={'locations': locations})
def view_clients_organizations_update(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
org_id = params['organizationId'] if 'organizationId' in params else None
name = params['name'] if 'name' in params else None
description = params['description'] if 'description' in params else None
if client_id is None or org_id is None or name is None or description is None:
raise exception.HTTPBadRequest(
detail='Missing required parameters',
explanation=
'Client Id, Organization Id, name and description is required')
session = request.session
client_id = session['client']
services = request.services()
try:
orgStore = services['store.clients.organizations']
result = orgStore.update(client_id, org_id, name, description)
except Exception as e:
log.error(e)
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail='Client Organization updated',
body={'message': 'Client Organization updated'})
def view_clients_role_active(request):
params = request.json_body
role_id = params['roleId'] if 'roleId' in params else None
active = params['active'] if 'active' in params else None
if role_id is None or active is None:
raise exception.HTTPBadRequest(
detail='Missing required parameters',
explanation='Role Id and Active status is required'
)
services = request.services()
try:
rolesStore = services['store.admin.roles']
rolesStore.setActive(role_id, active)
except Exception as e:
log.error(e)
raise exception.HTTPInternalServerError(
detail=str(e),
explanation=str(e)
)
raise exception.HTTPOk(
detail='Client Role active status updated',
body={'message': 'Client Role active status updated'}
)
def view_accounting_accounts_filter(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
filter = params['filter'] if 'filter' in params else None
if client_id is None:
raise exception.HTTPBadRequest(
detail='Missing required parameter',
explanation='Client Id and filter is required')
services = request.services()
accounts = []
try:
accountStore = services['store.accounting.accounts']
result = accountStore.filter(client_id, filter)
accounts = [{
'id': r[0],
'active': r[1],
'type_id': r[2],
'name': r[3],
'description': r[4]
} for r in result]
except Exception as e:
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail='{0} accounts found'.format(len(accounts)),
body={'accounts': accounts})
def view_clients_roles_permissions(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
role_id = params['roleId'] if 'roleId' in params else None
if client_id is None or role_id is None:
raise exception.HTTPBadRequest(
detail='Missing required parameters',
explanation='Client Id and Role Id is required'
)
permissions = []
services = request.services()
try:
rolesStore = services['store.admin.roles']
result = rolesStore.permissions(client_id, role_id)
permissions = [{
'id': r[0],
'active': r[1],
'name': r[2]
} for r in result]
except Exception as e:
raise exception.HTTPInternalServerError(
detail=str(e),
explanation=str(e)
)
raise exception.HTTPOk(
detail='{0} client roles found'.format(len(permissions)),
body={
'permissions': permissions
}
)
def api_accounting_transactions_filter(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
filter = params['filter'] if 'filter' in params else None
if client_id is None or filter is None:
raise exception.HTTPBadRequest(
detail='Missing required parameters',
explanation='Client Id and filter is required')
services = request.services()
store = services['store.accounting.transactions']
transactions = []
try:
result = store.filter(client_id, filter)
transactions = [{
'transaction_id': r[0],
'created': r[1],
'posted': r[2],
'currency_id': r[3],
'description': r[4]
} for r in result]
except StoreException as e:
log.error(e)
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail=f'{len(transactions)} transaction found',
body={'transactions': transactions})
def view_client_roles_permission_remove(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
role_id = params['roleId'] if 'roleId' in params else None
permission_id = params['permissionId'] if 'permissionId' in params else None
if client_id is None or role_id is None or permission_id is None:
raise exception.HTTPBadRequest(
detail='Missing required parameters',
explanation='Client Id, Role Id and Permission Id is required'
)
services = request.services()
try:
rolesStore = services['store.admin.roles']
rolesStore.removePermission(client_id, role_id, permission_id)
except Exception as e:
raise exception.HTTPInternalServerError(
detail=str(e),
explanation=str(e)
)
raise exception.HTTPOk(
detail='client role permission removed',
body={ 'message': 'Client Role permission removed' }
)
def api_hr_members_get(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
member_id = params['memberId'] if 'memberId' in params else None
if client_id is None or member_id is None:
raise exception.HTTPBadRequest(
detail='Missing required parameters',
explanation='Client Id and Member Id is required')
services = request.services()
membersStore = services['store.hr.members']
member = {}
try:
r = membersStore.get(client_id, member_id)
result_ids = membersStore.get_ids(member_id)
identifiers = [{'idType': r[0], 'value': r[1]} for r in result_ids]
member = {
'id': r[0],
'firstName': r[1],
'middleName': r[2],
'lastName': r[3],
'prefix': r[4],
'suffix': r[5],
'identifiers': identifiers
}
except Exception as e:
log.error(e)
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail='member found', body={'member': member})
def view_clients_roles_add(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
role_id = params['roleId'] if 'roleId' in params else None
name = params['name'] if 'name' in params else None
if not all([client_id, role_id, name]):
raise exception.HTTPBadRequest(
detail='Missing required parameters',
explanation='Client Id and Role Name is required'
)
services = request.services()
try:
rolesStore = services['store.admin.roles']
rolesStore.add(
client_id,
role_id,
name
)
except Exception as e:
log.error(e)
raise exception.HTTPInternalServerError(
detail=str(e),
explanation=str(e)
)
raise exception.HTTPOk(
detail='Client Role added',
body={'message': 'Client Role added'}
)
def api_hr_shifts_save(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
shift_id = params['shiftId'] if 'shiftId' in params else None
name = params['name'] if 'name' in params else None
start = params['start'] if 'start' in params else None
end = params['end'] if 'end' in params else None
if client_id is None or shift_id is None or name is None or start is None or end is None:
raise exception.HTTPBadRequest(
detail='Missing required parameters',
explanation=
'Client Id, shift id, name, start and end times are required')
services = request.services()
store = services['store.hr.shifts']
try:
store.save(client_id, shift_id, name, start, end)
except Exception as e:
log.error(e)
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail='shift record saved',
body={'message': 'shift record saved'})
def delete_swatch(self):
try:
deleted = swatchservice.delete_swatch(
self.user_id, self.request.matchdict['swatch_name'])
return exp.HTTPOk() if deleted else exp.HTTPNotFound()
except:
return exp.HTTPInternalServerError()
def api_common_uom_filter(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
dimension = params['dimension'] if 'dimension' in params else None
filter = params['filter'] if 'filter' in params else None
if client_id is None or dimension is None or filter is None:
raise exception.HTTPBadRequest(
detail='Missing required parameter',
explanation='Client Id, dimension and filter is required')
services = request.services()
uoms = []
try:
store = services['store.common.uom']
result = []
if filter is None:
result = store.all()
else:
result = store.filter(client_id, dimension, filter)
uoms = [{'id': r[0], 'name': r[1], 'symbol': r[2]} for r in result]
except Exception as e:
log.error(e)
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail=f'{len(uoms)} units found',
body={'uoms': uoms})
def api_purchasing_po_filter(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
filter = params['filter'] if 'filter' in params else None
if client_id is None or filter is None:
raise exception.HTTPBadRequest(
detail='Missing required parameters',
explanation='Client Id and filter is required')
services = request.services()
poStore = services['store.purchasing.po']
pos = []
try:
result = poStore.filter(client_id, filter)
pos = [{
'id': r[0],
'created': r[1],
'description': r[2]
} for r in result]
except Exception as e:
log.error(e)
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail='{0} purchase orders found'.format(len(pos)),
body={'purchaseOrders': pos})
def view_client_user_roles_add(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
user_id = params['userId'] if 'userId' in params else None
role_ids = params['roleIds'] if 'roleIds' in params else None
if client_id is None or user_id is None or role_ids is None:
raise exception.HTTPBadRequest(
detail='Missing required parameters',
explanation='Client Id, User Id and Role Ids are required'
)
services = request.services()
try:
usersStore = services['store.admin.users']
usersStore.addClientUserRoles(client_id, user_id, role_ids)
except Exception as e:
raise exception.HTTPInternalServerError(
detail=str(e),
explanation=str(e)
)
raise exception.HTTPOk(
detail='Client User Roles added',
body={
'message': 'Client User Roles added'
}
)
def view_clients_organizations_set_parent(request):
params = request.json_body
org_id = params['organizationId'] if 'organizationId' in params else None
parent_org_id = params[
'parentOrganizationId'] if 'parentOrganizationId' in params else None
if org_id is None or parent_org_id is None:
raise exception.HTTPBadRequest(
detail='Missing required parameters',
explanation='Organization Id and Parent Organization Id is required'
)
session = request.session
client_id = session['client']
services = request.services()
try:
orgStore = services['store.clients.organizations']
result = orgStore.setParentOrg(client_id, org_id, parent_org_id)
except Exception as e:
log.error(e)
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(
detail='Client Organization assigned',
body={'message': 'Client Organization assigned parent'})
def view_clients_users_all(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
if client_id is None:
raise exception.HTTPBadRequest(
detail='Missing required parameter',
explanation='Client Id is required'
)
users = []
services = request.services()
try:
usersStore = services['store.admin.users']
result = usersStore.getAllClientUsers(client_id)
users = [{
'id': r[0],
'active': r[1],
'email': r[2],
'name': r[3]
}
for r in result]
except Exception as e:
raise exception.HTTPInternalServerError(
detail=str(e),
explanation=str(e)
)
raise exception.HTTPOk(
detail='{0} client users found'.format(len(users)),
body={
'users': users
}
)
def view_clients_filter(request):
params = request.json_body
filter = params['filter'] if 'filter' in params else None
if filter is None:
raise exception.HTTPBadRequest(detail='Missing required parameters',
explanation='Filter is required')
services = request.services()
clients = []
try:
clientsStore = services['store.admin.clients']
result = clientsStore.filter(filter)
clients = [{
'id': c[0],
'active': c[1],
'name': c[2],
'address': c[3],
'country_id': c[4],
'currency_id': c[5]
} for c in result]
except Exception as e:
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail='{0} clients found'.format(len(clients)),
body={'clients': clients})
