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")