def updatePersonal(request):
Helper.permissions(request)
try:
modelSpec = request.params["model_spec"]
except:
raise exc.HTTPBadRequest("Information missing")
user = db.executeOne("User_Info", [request.session["username"]])
if True: # TODO
# Change all the models currently implemented and re train
expertsModels = db.execute_literal(
"SELECT * FROM expertModels WHERE username = ?",
[user["username"]])
# Update users Model Specification
db.execute_literal("UPDATE users SET modelSpec = ? WHERE username = ?",
[modelSpec, user["username"]])
for model in expertsModels:
# Replace the old model with the new model in the database
identifier = ExpertModelAPI().create_model(model_type=modelSpec)
db.execute_literal(
"UPDATE expertModels SET identifier = ? WHERE identifier = ?",
[identifier, model["identifier"]])
trainingData = db.execute("collectModelLabels",
[user["username"], model["qid"]])
CMOs, scores = [], []
for datapoint in trainingData:
CMOs.append(
ClimateModelOutput.load(
os.path.join(CMOSTORAGE, str(datapoint["cmoid"]))))
scores.append(datapoint["score"])
ProcessRunner().add_process(identifier, user["username"], CMOs,
scores)
# Delete old model
ExpertModelAPI().delete_model(model_id=model["identifier"])
def get_article(request):
code = request.GET.get('code', None)
collection = request.GET.get('collection', None)
fmt = request.GET.get('format', 'json')
body = request.GET.get('body', 'false')
if not body in ['true', 'false']:
raise exc.HTTPBadRequest("parameter 'metaonly' must be 'true' or 'false'")
body = asbool(body)
article = request.databroker.get_article(
code, collection=collection, replace_journal_metadata=True, body=body
)
if article:
if fmt == 'xmlwos':
return Response(
Export(article).pipeline_sci(), content_type="application/xml")
if fmt == 'xmldoaj':
return Response(
Export(article).pipeline_doaj(), content_type="application/xml")
if fmt == 'xmlrsps':
return Response(
Export(article).pipeline_rsps(), content_type="application/xml")
if fmt == 'xmlpubmed':
return Response(
Export(article).pipeline_pubmed(), content_type="application/xml")
if fmt == 'xmlcrossref':
return Response(
Export(article).pipeline_crossref(), content_type="application/xml")
return article
def post_moderation(request):
settings = request.registry.settings
db_conn_str = settings[config.CONNECTION_STRING]
publication_id = request.matchdict['id']
posted = request.json
if 'is_accepted' not in posted \
or not isinstance(posted.get('is_accepted'), bool):
raise httpexceptions.HTTPBadRequest(
"Missing or invalid 'is_accepted' value.")
is_accepted = posted['is_accepted']
with psycopg2.connect(db_conn_str) as db_conn:
with db_conn.cursor() as cursor:
if is_accepted:
# Give the publisher moderation approval.
cursor.execute(
"""\
UPDATE users SET (is_moderated) = ('t')
WHERE username = (SELECT publisher FROM publications
WHERE id = %s and state = 'Waiting for moderation')""",
(publication_id, ))
# Poke the publication into a state change.
poke_publication_state(publication_id, cursor)
else:
# Reject! And Vacuum properties of the publication
# record to /dev/null.
cursor.execute(
"""\
UPDATE users SET (is_moderated) = ('f')
WHERE username = (SELECT publisher FROM publications
WHERE id = %sand state = 'Waiting for moderation')""",
(publication_id, ))
cursor.execute(
"""\
UPDATE publications SET (epub, state) = (null, 'Rejected')
WHERE id = %s""", (publication_id, ))
return httpexceptions.HTTPAccepted()
def api_crm_organizations_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 parameter',
explanation='Client Id or filter is required')
services = request.services()
orgStore = services['store.crm.organizations']
organizations = []
try:
result = orgStore.filter(client_id, filter)
organizations = [{'id': r[0], 'name': r[1]} 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(organizations)} organizations found',
body={'organizations': organizations})
def view_accounting_accounts_add(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
type_id = params['typeId'] if 'typeId' 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 account_id is None or type_id is None or name is None:
raise exception.HTTPBadRequest(
detail='Missing required parameters',
explanation='Client Id, Account Id, Type Id and Name is required')
services = request.services()
try:
accountStore = services['store.accounting.accounts']
accountStore.add(client_id, account_id, type_id, name, description)
except Exception as e:
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail='Account added',
body={'message': 'Account added'})
def api_common_uom_get(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
dimension = params['dimension'] if 'dimension' in params else None
uom_id = params['uomId'] if 'uomId' in params else None
if client_id is None or dimension is None or uom_id is None:
raise exception.HTTPBadRequest(
detail='Missing required parameter',
explanation='Client Id, dimension and UOM Id is required')
services = request.services()
store = services['store.common.uom']
uom = {}
try:
r = store.get(client_id, dimension, uom_id)
uom = {'id': r[0], 'name': r[1], 'symbol': r[2]}
except Exception as e:
log.error(e)
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail='unit found', body={'uom': uom})
def api_accounting_groups_update(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
group_id = params['groupId'] if 'groupId' in params else None
type_id = params['typeId'] if 'typeId' 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 group_id is None or type_id is None or name is None:
raise exception.HTTPBadRequest(
detail='Missing required parameters',
explanation='Client Id, Group Id, Type Id and Name is required')
services = request.services()
try:
store = services['store.accounting.groups']
store.update(client_id, group_id, type_id, name, description)
except Exception as e:
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail='Account Group added',
body={'message': 'Account Group added'})
def api_purchasing_vendors_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 parameter',
explanation='Client Id and filter is required')
services = request.services()
vendorStore = services['store.purchasing.vendors']
vendors = []
try:
result = vendorStore.filter(client_id, filter)
vendors = [{'id': r[0], 'name': r[1]} 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(vendors)} vendors found',
body={'vendors': vendors})
def api_purchasing_vendor_update(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
organization_id = params[
'organizationId'] if 'organizationId' in params else None
if client_id is None or vendor_id is None or organization_id is None:
raise exception.HTTPBadRequest(
detail='Missing required parameter',
explanation='Client Id, Vendor Id and Organization Id is required')
services = request.services()
vendorStore = services['store.purchasing.vendors']
try:
vendorStore.assignOrganization(client_id, vendor_id, organization_id)
except Exception as e:
log.error(e)
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail='vendor record created',
body={'message': 'vendor record created'})
def api_accounting_transactions_post(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
transaction_id = params[
'transactionId'] if 'transactionId' in params else None
if client_id is None or transaction_id is None:
raise exception.HTTPBadRequest(
detail='Missing required parameters',
explanation='Client Id and Transaction Id is required')
services = request.services()
store = services['store.accounting.transactions']
try:
store.post(client_id, transaction_id)
except StoreException as e:
log.error(e)
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail='transaction posted',
body={'message': 'transaction posted'})
def shortener(request):
url = check_url(request.params.get('url'))
if len(url) >= 2046:
# we only accept URL shorter or equal to 2046 characters
# Index restriction in DynamoDB
url_short = 'toolong'
else:
# DynamoDB v2 high-level abstraction
try:
table = Table('shorturl',
connection=connect_to_region('eu-west-1'))
except Exception as e:
raise exc.HTTPBadRequest('Error during connection %s' % e)
url_short = _add_item(table, url)
# Use env specific URLs
if request.host not in ('api.geo.admin.ch', 'api3.geo.admin.ch'):
host_url = make_api_url(request) + '/shorten/'
else:
host_url = ''.join((request.scheme, '://s.geo.admin.ch/'))
return {'shorturl': host_url + url_short}
def view_clients_roles_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()
roles = []
try:
rolesStore = services['store.admin.roles']
result = rolesStore.filter(client_id, filter)
roles = [
{
'id': r[0],
'active': r[1],
'name': 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} roles found'.format(len(roles)),
body={
'roles': roles
}
)
def view_inventory_items_filter(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
filter = params['filter'] if 'filter' in params else ''
num_items = params['numItems'] if 'numItems' in params else 20
page_num = params['pageNum'] if 'pageNum' in params else 1
if client_id is None:
raise exception.HTTPBadRequest(detail='Missing required parameter',
explanation='Client Id is required')
services = request.services()
items = []
try:
itemsStore = services['store.inventory.items']
result = itemsStore.filterItems(client_id, filter, num_items, page_num)
items = [{
'id': r[0],
'active': r[1],
'name': r[2],
'description': r[3],
'make': r[4],
'brand': r[5],
'model': r[6],
'version': r[7],
'sku': r[8],
'upc': r[9]
} for r in result]
except Exception as e:
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail='{0} items found'.format(len(items)),
body={
'items': items,
'filter': filter
})
def view_clients_update(request):
params = request.json_body
client_id = params['clientId'] if 'clientId' in params else None
name = params['name'] if 'name' in params else None
address = params['address'] if 'address' in params else None
country_id = params['countryId'] if 'countryId' in params else None
currency_id = params['currencyId'] if 'currencyId' in params else None
if not all([client_id, name, address, country_id, currency_id]):
raise exception.HTTPBadRequest(
detail='Missing required parameters',
explanation=
'Client Id, name, address, country id and currency id is required')
services = request.services()
try:
clientsStore = services['store.admin.clients']
clientsStore.update(client_id, name, address, country_id, currency_id)
except Exception as e:
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail='Client updated',
body={'message': 'Client update'})
def badge(request):
"""Return the number of public annotations on a given page.
This is for the number that's displayed on the Chrome extension's badge.
Certain pages are blocklisted so that the badge never shows a number on
those pages. The Chrome extension is oblivious to this, we just tell it
that there are 0 annotations.
"""
uri = request.params.get('uri')
if not uri:
raise httpexceptions.HTTPBadRequest()
if models.Blocklist.is_blocked(request.db, uri):
newrelic.agent.record_custom_metric('Custom/Badge/badgeCountIsZero', 1)
return {'total': 0}
query = {'uri': uri, 'limit': 0}
result = search.Search(request, stats=request.stats).run(query)
newrelic.agent.record_custom_metric('Custom/Badge/badgeCountIsZero', int(result.total == 0))
return {'total': result.total}
def _get_features_for_extent(params, models, maxFeatures=None):
''' Returns a generator function that yields
a feature. '''
for vectorLayer in models:
for model in vectorLayer:
geomFilter = model.geom_filter(params.geometry,
params.geometryType,
params.imageDisplay,
params.mapExtent, params.tolerance)
# Can be None because of max and min scale
if geomFilter is not None:
query = params.request.db.query(model).filter(geomFilter)
if params.timeInstant is not None:
try:
timeInstantColumn = model.time_instant_column()
except AttributeError:
raise exc.HTTPBadRequest('%s is not time enabled' %
model.__bodId__)
query = query.filter(
timeInstantColumn == params.timeInstant)
query = query.limit(
maxFeatures) if maxFeatures is not None else query
for feature in query:
yield feature
def view_accounting_accounts_set_parent(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
parent_account_id = params[
'parentAccountId'] if 'parentAccountId' in params else None
if client_id is None or account_id is None or parent_account_id is None:
raise exception.HTTPBadRequest(
detail='Missing required parameters',
explanation=
'Client Id, Account Id and Parent Account Id is required')
services = request.services()
try:
accountStore = services['store.accounting.accounts']
accountStore.assign_account_parent(client_id, account_id,
parent_account_id)
except Exception as e:
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail='Account updated',
body={'message': 'account updated'})
def api_purchasing_vendor_update(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
name = params['name'] if 'name' in params else None
address = params['address'] if 'address' in params else None
country_id = params['countryId'] if 'countryId' in params else None
if client_id is None or vendor_id is None or name is None:
raise exception.HTTPBadRequest(
detail='Missing required parameter',
explanation='Client Id, Vendor Id and Name is required')
services = request.services()
vendorStore = services['store.purchasing.vendors']
try:
vendorStore.update(client_id, vendor_id, name, address, country_id)
except Exception as e:
log.error(e)
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail='vendor record updated',
body={'message': 'vendor record updated'})
def api_accounting_groups_tree(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()
groups = []
try:
store = services['store.accounting.groups']
result = store.tree(client_id)
groups = [{
'group_id': r[0],
'name': r[1],
'level': r[2]
} for r in result]
except Exception as e:
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail=f'{len(groups)} account groups found',
body={'groups': groups})
def view_client_user_roles_all(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 parameters',
explanation='Client Id and User Id is required'
)
roles = []
services = request.services()
try:
usersStore = services['store.admin.users']
result = usersStore.clientRoles(client_id, user_id)
roles = [
{
'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(roles)),
body={
'roles': roles
}
)
def _identify_db(params, layerBodIds):
maxFeatures = MAX_FEATURES
features = []
if len(layerBodIds) == 0:
return features
feature_gen = _get_features_for_filters(params,
layerBodIds,
maxFeatures=maxFeatures,
where=params.where)
while len(features) <= maxFeatures:
try:
feature = next(feature_gen)
except InternalError as e:
# Note: in order not to expose too much details about internal
# db structure, we only return the title of the error and not details
# about table names and the like
raise exc.HTTPBadRequest(
'Your request generated the following database error: %s' %
e.message.replace('\n', ''))
except StopIteration:
break
else:
features.append(_process_feature(feature, params))
return features
def view_permissions_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')
permissions = []
services = request.services()
try:
permissionsStore = services['store.admin.permissions']
result = permissionsStore.filter(filter)
permissions = [{
'id': c[0],
'active': c[1],
'name': c[2]
} for c in result]
except Exception as e:
log.error(e)
raise exception.HTTPInternalServerError(detail=str(e),
explanation=str(e))
raise exception.HTTPOk(detail='{0} permissions'.format(len(permissions)),
body={'permissions': permissions})
def badge(request):
"""Return the number of public annotations on a given page.
This is for the number that's displayed on the Chrome extension's badge.
Certain pages are blocklisted so that the badge never shows a number on
those pages. The Chrome extension is oblivious to this, we just tell it
that there are 0 annotations.
"""
uri = request.params.get('uri')
if not uri:
raise httpexceptions.HTTPBadRequest()
if models.Blocklist.is_blocked(uri):
return {'total': 0}
return {
'total': search_lib.search(request, {
'uri': uri,
'limit': 0
})['total']
}
def view_users_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()
users = []
try:
usersStore = services['store.admin.users']
result = usersStore.filter(filter)
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} users found'.format(len(users)),
body={
'users': users
}
)
def _collection_post_tus(request):
request.env.core.check_storage_limit()
comp = request.env.file_upload
try:
upload_length = int(request.headers['Upload-Length'])
except (KeyError, ValueError):
raise exc.HTTPBadRequest()
if upload_length > comp.max_size:
raise UploadedFileTooLarge()
upload_metadata = _tus_decode_upload_metadata(
request.headers.get('Upload-Metadata'))
fid = comp.fileid()
fnd, fnm = comp.get_filename(fid, makedirs=True)
# Just touch the data file
with open(fnd, 'wb') as fd:
pass
meta = dict(id=fid, size=upload_length, incomplete=True)
# Copy name and mime_type from upload metadata
for k in ('name', 'mime_type'):
v = upload_metadata.get(k)
if v is not None:
meta[k] = v
with open(fnm, 'wb') as fd:
fd.write(pickle.dumps(meta))
return _tus_response(201,
location=request.route_url('file_upload.item',
id=fid))
def _identify_oereb(request):
def insertTimestamps(header, comments):
pos = re.search(r'\?>', header).end()
return ''.join((header[:pos], comments, header[pos:]))
params = _get_features_params(request)
# At the moment only one layer at a time and no support of all
if params.layers == 'all' or len(params.layers) > 1:
raise exc.HTTPBadRequest(
'Please specify the id of the layer you want to query')
layerBodId = params.layers[0]
query = params.request.db.query(OerebMetadata)
layerMetadata = get_layer(query, OerebMetadata, layerBodId)
header = layerMetadata.header
footer = layerMetadata.footer
data_created = layerMetadata.data_created
data_imported = layerMetadata.data_imported
comments = render('chsdi:templates/oereb_timestamps.mako', {
'data_imported': data_imported,
'data_created': data_created
})
header = insertTimestamps(header, comments)
# Only relation 1 to 1 is needed at the moment
layerVectorModel = [[oereb_models_from_bodid(layerBodId)[0]]]
features = []
for feature in _get_features_for_filters(params, layerVectorModel):
temp = feature.xmlData.split('##')
for fragment in temp:
if fragment not in features:
features.append(fragment)
results = ''.join((header, ''.join(features), footer))
response = Response(results)
response.content_type = 'text/xml'
return response
def _item_patch_tus(request):
comp = request.env.file_upload
if request.content_type != 'application/offset+octet-stream':
raise exc.HTTPUnsupportedMediaType()
try:
upload_offset = int(request.headers['Upload-Offset'])
except (KeyError, ValueError):
raise exc.HTTPBadRequest()
fnd, fnm = comp.get_filename(request.matchdict['id'])
if not isfile(fnm):
raise exc.HTTPNotFound()
with open(fnm, 'rb') as fd:
meta = pickle.loads(fd.read())
size = meta['size']
# Don't upload more than declared file size.
if upload_offset + request.content_length > size:
raise UploadedFileTooLarge()
# Check minimum chunk size to prevent misconfiguration
remain = size - upload_offset
if request.content_length < min(remain, comp.tus_chunk_size_minimum):
raise exc.HTTPBadRequest()
with open(fnd, 'ab') as fd:
# Check for upload conflict
if upload_offset != fd.tell():
raise exc.HTTPConflict()
# Copy request body to data file. Input streaming is also supported
# here is some conditions: uwsgi - does, pserve - doesn't.
src_fd = request.body_file
while True:
buf = src_fd.read(BUF_SIZE)
if buf is None:
break
read = len(buf)
if len(buf) == 0:
break
if upload_offset + read > size:
raise UploadedFileTooLarge()
fd.write(buf)
upload_offset += read
if size == upload_offset:
# File upload completed
del meta['incomplete']
# Detect MIME-type
if 'mime_type' not in meta:
meta['mime_type'] = magic.from_file(fnd, mime=True)
# Save changes to metadata
with open(fnm, 'wb') as fd:
fd.write(pickle.dumps(meta))
return _tus_response(204, upload_offset=upload_offset)
def _check_timeparameters(self):
if self.timeInstant is not None and self.timeStamps is not None:
raise exc.HTTPBadRequest(
'You are not allowed to mix timeStamps and timeInstant parameters'
)
def api_view(request):
print(f"Post: {request.json}")
pvars = request.json
if not pvars:
log.warning(f"API: Empty request from {request.client_addr}")
raise exc.HTTPBadRequest(detail='Invalid API request.')
if 'user' not in pvars or 'key' not in pvars:
log.warning(
f"API: Missing user information from {request.client_addr}")
raise exc.HTTPBadRequest(detail='Invalid API request.')
user = request.dbsession.query(User).filter(
User.username == pvars['user']).one_or_none()
if not user:
log.error(
f"API: Invalid username from {request.client_addr}: {pvars['user']}"
)
raise exc.HTTPBadRequest(detail='Invalid API key.')
if pvars['key'] != user.apiKey:
log.error(
f"API: Invalid API key from {request.client_addr} for user {pvars['user']}"
)
raise exc.HTTPBadRequest(detail='Invalid API key.')
if pvars['cmdr'].lower() != user.cmdr_name.lower():
log.error(
f"API: CMDR name does not match for user {user.cmdr_name}: Got {pvars['user']}"
)
raise exc.HTTPBadRequest(detail='Data not for correct CMDR.')
else:
data = pvars['data']
mycarrier = request.dbsession.query(Carrier).filter(
Carrier.owner == user.id).one_or_none()
if data['event'] == 'CarrierJumpRequest':
hooks = webhooks.get_webhooks(request, mycarrier.id)
if hooks:
for hook in hooks:
log.debug(f"Process hook {hook['webhook_url']}")
if mycarrier.lastUpdated:
if mycarrier.lastUpdated < datetime.now() - timedelta(
minutes=15):
log.debug(
"Refreshing carrier data before sending webhook. (Temp. disabled)"
)
# update_carrier(request, mycarrier.id, request.user)
request.dbsession.flush()
request.dbsession.refresh(mycarrier)
rc = request.dbsession.query(RouteCalendar).filter(
RouteCalendar.carrier_id == mycarrier.id)
if rc:
for row in rc:
if row.isActive:
route = request.dbsession.query(Route).filter(
Route.id == row.route_id).one_or_none()
waypoints = json.loads(route.waypoints)
for wp in waypoints:
print(wp)
if wp['system'] == data['SystemName']:
row.currentWaypoint = data[
'SystemName']
request.dbsession.flush()
request.dbsession.refresh(row)
# Jump is to a route waypoint, fire route jumps instead and update CWP.
if hook['webhook_type'] == 'discord' and hook[
'jumpEvents']:
res = webhooks.announce_route_jump(
request, mycarrier.id, row.id,
hook['webhook_url'])
log.debug(
f"Route jump result: {res}")
return {'status': 'OK'}
if hook['webhook_type'] == 'discord' and hook['jumpEvents']:
if 'Body' in data:
res = webhooks.announce_jump(
request,
mycarrier.id,
data['SystemName'],
hook['webhook_url'],
body=data['Body'],
source=pvars['system'])
else:
res = webhooks.announce_jump(
request,
mycarrier.id,
data['SystemName'],
hook['webhook_url'],
source=pvars['system'])
log.debug(f"Hook result: {res}")
elif data['event'] == 'CarrierJumpCancelled':
hooks = webhooks.get_webhooks(request, mycarrier.id)
if hooks:
for hook in hooks:
log.debug(f"Process hook {hook['webhook_url']}")
if hook['webhook_type'] == 'discord' and hook['jumpEvents']:
res = webhooks.cancel_jump(request, mycarrier.id,
hook['webhook_url'], False)
log.debug(f"Hook result: {res}")
elif data['event'] == 'MarketUpdate':
hooks = webhooks.get_webhooks(request, mycarrier.id)
if hooks:
for hook in hooks:
log.debug(f"Process hook {hook['webhook_url']}")
if hook['webhook_type'] == 'discord' and hook[
'marketEvents']:
res = webhooks.market_update(request, mycarrier.id,
None, hook['webhook_url'])
log.debug(f"Hook result: {res}")
return {'Status': 'Maybe OK?'}
def view_find_esrijson(self):
raise exc.HTTPBadRequest(
"Param 'geometryFormat=esrijson' is not supported")
