def get_wrapper(target: str) -> Tuple[BaseWrapper, str]: if target == "segmentation": wrapper = cache.get("segmentation_wrapper") if wrapper is None: wrapper = TorchvisionSegmentationWrapper() wrapper.load() cache.set("segmentation_wrapper", wrapper) target_name = "mask" elif target == "detection": wrapper = cache.get("detection_wrapper") if wrapper is None: wrapper = YOLOWrapper() wrapper.load() cache.set("detection_wrapper", wrapper) target_name = "boxes" elif target == "keypoints": wrapper = cache.get("keypoints_wrapper") if wrapper is None: wrapper = TorchvisionKeypointsWrapper() wrapper.load() cache.set("keypoints_wrapper", wrapper) target_name = "keypoints" else: wrapper = cache.get("helmet_det") if wrapper is None: wrapper = HelmetnetWrapper() wrapper.load() cache.set("helmet_det", wrapper) target_name = "boxes" return wrapper, target_name
def check_api_key(*args, **kwargs): FORBIDDEN = requests.codes.forbidden # enforce admin permission try: return jwt.has_one_of_roles([ADMIN])(func)(*args, **kwargs) except Exception as e: current_app.logger.error(str(e)) # TODO this checks for debug purpose, will be reworked in final pr otl_guid = request.headers.get(ONE_TIME_LINK) otp_guid = request.headers.get(ONE_TIME_PASSWORD) if not otl_guid and not otp_guid: current_app.logger.info("OTL and OTP is empty") abort(FORBIDDEN) elif otl_guid and otl_guid == cache.get(otl_guid): current_app.logger.info("OTL IS PRESENT NEED TO GENERATE OTP") abort(FORBIDDEN) elif not otl_guid and otp_guid: current_app.logger.info("OTL is not present but OTP is") otp_app_guid = cache.get(otp_guid) header_app_guid = request.headers.get("app_guid") if otp_app_guid and otp_app_guid == header_app_guid: current_app.logger.info("OTP is correct") return func(*args, **kwargs) else: current_app.logger.info("OTP is linked to a different application") abort(FORBIDDEN) else: current_app.logger.info("OTP is expired") abort(FORBIDDEN)
def patch(self, document_guid=None): if document_guid is None: return self.create_error_payload( 400, 'Must specify document GUID in PATCH'), 400 file_path = cache.get(FILE_UPLOAD_PATH(document_guid)) if file_path is None or not os.path.lexists(file_path): return self.create_error_payload( 404, 'PATCH sent for a upload that does not exist'), 404 request_offset = int(request.headers.get('Upload-Offset', 0)) file_offset = cache.get(FILE_UPLOAD_OFFSET(document_guid)) if request_offset != file_offset: return self.create_error_payload( 409, "Offset in request does not match uploaded file's offest"), 409 chunk_size = request.headers.get('Content-Length') if chunk_size is None: return self.create_error_payload( 400, 'No Content-Length header in request'), 400 chunk_size = int(chunk_size) new_offset = file_offset + chunk_size file_size = cache.get(FILE_UPLOAD_SIZE(document_guid)) if new_offset > file_size: return self.create_error_payload( 413, 'The uploaded chunk would put the file above its declared file size.' ), 413 try: with open(file_path, "r+b") as f: f.seek(file_offset) f.write(request.data) except IOError as e: return self.create_error_payload(500, 'Unable to write to file'), 500 if new_offset == file_size: # File transfer complete. doc = DocumentManager.find_by_document_manager_guid(document_guid) doc.upload_completed_date = datetime.now() doc.save() cache.delete(FILE_UPLOAD_SIZE(document_guid)) cache.delete(FILE_UPLOAD_OFFSET(document_guid)) cache.delete(FILE_UPLOAD_PATH(document_guid)) else: # File upload still in progress cache.set(FILE_UPLOAD_OFFSET(document_guid), new_offset, TIMEOUT_24_HOURS) response = make_response("", 204) response.headers['Tus-Resumable'] = TUS_API_VERSION response.headers['Tus-Version'] = TUS_API_SUPPORTED_VERSIONS response.headers['Upload-Offset'] = new_offset response.headers[ 'Access-Control-Expose-Headers'] = "Tus-Resumable,Tus-Version,Upload-Offset" return response
def get_currency_rates(config): if cache.get("currency_rates"): return cache.get("currency_rates") else: rates = fetch_currency_rates(config) cache.set("currency_rates", rates) return rates
def get_zone_estimator(): aruco_params = cache.get("aruco_params") if aruco_params is None: with open("robot_work_zone_estimation/aruco_config.json") as conf_file: aruco_params = json.load(conf_file) cache.set("aruco_params", aruco_params) marker_id = aruco_params["marker_idx"] wz_cx = aruco_params["wz_cx"] wz_cy = aruco_params["wz_cy"] wz_height = aruco_params["wz_height"] wz_width = aruco_params["wz_width"] marker_world_size = aruco_params["marker_world_size"] marker_size = aruco_params["marker_size"] camera_params = aruco_params["camera_params"] camera_params = CameraParams( np.array(camera_params['camera_mtx'], dtype=np.float), np.array(camera_params['distortion_vec'], dtype=np.float), np.array(camera_params['rotation_vec'], dtype=np.float), np.array(camera_params['translation_vec'], dtype=np.float)) zone = Workzone(wz_cx, wz_cy, wz_height, wz_width) estimator = cache.get("zone_estimator") if estimator is None: estimator = ArucoZoneEstimator(marker_world_size, ARUCO_MARKER_SIZE[marker_size], marker_id, camera_params, zone) cache.set("zone_estimator", estimator) return estimator
def getOGCdataframe(cls, cache_key, csv_url, process): serializer = pa.default_serialization_context() data = cache.get(cache_key) app = current_app._get_current_object() #if empty dataset refresh data synchronously, otherwise refresh in the background and continue if not data: df = refreshOGCdata(app, cache_key, csv_url, process) else: thread = Thread(target=refreshOGCdata, args=( app, cache_key, csv_url, process, )) thread.daemon = True thread.start() #update data and return data = cache.get(cache_key) if data: df = serializer.deserialize(data) return df
def get(self): # Below caches the mine map response object in redis with a timeout. # Generating and jsonifying the map data takes 4-7 seconds with 50,000 points, # so caching seems justified. # # TODO: Use some custom representation of this data vs JSON. The # json string is massive (with 50,000 points: 16mb uncompressed, 2.5mb compressed). # A quick test using delimented data brings this down to ~1mb compressed. map_result = cache.get(MINE_MAP_CACHE) last_modified = cache.get(MINE_MAP_CACHE + '_LAST_MODIFIED') if not map_result: map_result = MineMapResource.rebuild_and_return_map_cache() # It's more efficient to store the json to avoid re-initializing all of the objects # and jsonifying on every request, so a flask response is returned to prevent # flask_restplus from jsonifying the data again, which would mangle the json. response = make_response(map_result) response.headers['content-type'] = 'application/json' # While we're at it, let's set a last modified date and have flask return not modified # if it hasn't so the client doesn't download it again unless needed. response.last_modified = last_modified response.make_conditional(request) return response
def get(self, mine_no_or_guid=None): if mine_no_or_guid: mine = Mine.find_by_mine_no_or_guid(mine_no_or_guid) if mine: return mine.json() return self.create_error_payload(404, 'Mine not found'), 404 else: # Handle MapView request _map = request.args.get('map', None, type=str) if _map and _map.lower() == 'true': # Below caches the mine map response object in redis with a timeout. # Generating and jsonifying the map data takes 4-7 seconds with 50,000 points, # so caching seems justified. # # TODO: Use some custom representation of this data vs JSON. The # json string is massive (with 50,000 points: 16mb uncompressed, 2.5mb compressed). # A quick test using delimented data brings this down to ~1mb compressed. map_result = cache.get(MINE_MAP_CACHE) last_modified = cache.get(MINE_MAP_CACHE + '_LAST_MODIFIED') if not map_result: records = MineMapViewLocation.query.filter(MineMapViewLocation.latitude != None) last_modified = datetime.now() # jsonify then store in cache map_result = json.dumps( { 'mines': list((map(lambda x: x.json_for_map(), records))) }, separators=(',', ':')) cache.set(MINE_MAP_CACHE, map_result, timeout=TIMEOUT_12_HOURS) cache.set( MINE_MAP_CACHE + '_LAST_MODIFIED', last_modified, timeout=TIMEOUT_12_HOURS) # It's more efficient to store the json to avoid re-initializing all of the objects # and jsonifying on every request, so a flask response is returned to prevent # flask_restplus from jsonifying the data again, which would mangle the json. response = make_response(map_result) response.headers['content-type'] = 'application/json' # While we're at it, let's set a last modified date and have flask return not modified # if it hasn't so the client doesn't download it again unless needed. response.last_modified = last_modified response.make_conditional(request) return response paginated_mine_query, pagination_details = self.apply_filter_and_search(request.args) mines = paginated_mine_query.all() return { 'mines': list(map(lambda x: x.json_for_list(), mines)), 'current_page': pagination_details.page_number, 'total_pages': pagination_details.num_pages, 'items_per_page': pagination_details.page_size, 'total': pagination_details.total_results, }
def recent_terms(): """ Returns most recent submissions table; caches query results for half a minute. """ submissions_key = 'recent-submissions' if not cache.get(submissions_key): wiki_records = get_all_records() data = format_record(wiki_records['Items']) cache.set(submissions_key, data, timeout=30) else: data = cache.get(submissions_key) return jsonify(data), 200
def patch(self, document_guid): file_path = cache.get(FILE_UPLOAD_PATH(document_guid)) if file_path is None or not os.path.lexists(file_path): raise NotFound('PATCH sent for a upload that does not exist') request_offset = int(request.headers.get('Upload-Offset', 0)) file_offset = cache.get(FILE_UPLOAD_OFFSET(document_guid)) if request_offset != file_offset: raise Conflict( "Offset in request does not match uploaded file's offset") chunk_size = request.headers.get('Content-Length') if chunk_size is None: raise BadRequest('No Content-Length header in request') chunk_size = int(chunk_size) new_offset = file_offset + chunk_size file_size = cache.get(FILE_UPLOAD_SIZE(document_guid)) if new_offset > file_size: raise RequestEntityTooLarge( 'The uploaded chunk would put the file above its declared file size.' ) try: with open(file_path, "r+b") as f: f.seek(file_offset) f.write(request.data) except IOError as e: raise InternalServerError('Unable to write to file') if new_offset == file_size: # File transfer complete. doc = Document.find_by_document_guid(document_guid) doc.upload_completed_date = datetime.utcnow() doc.save() cache.delete(FILE_UPLOAD_SIZE(document_guid)) cache.delete(FILE_UPLOAD_OFFSET(document_guid)) cache.delete(FILE_UPLOAD_PATH(document_guid)) else: # File upload still in progress cache.set(FILE_UPLOAD_OFFSET(document_guid), new_offset, TIMEOUT_24_HOURS) response = make_response('', 204) response.headers['Tus-Resumable'] = TUS_API_VERSION response.headers['Tus-Version'] = TUS_API_SUPPORTED_VERSIONS response.headers['Upload-Offset'] = new_offset response.headers[ 'Access-Control-Expose-Headers'] = "Tus-Resumable,Tus-Version,Upload-Offset" return response
def inbox(): if request.method == 'GET': if current_user.subscription or current_user.trial: if current_user.active_mailbox: if cache.get(current_user.mailbox_id): emails = cache.get(current_user.mailbox_id) return render_template('user/inbox.html', emails=emails, mailbox_id=current_user.mailbox_id, route="inbox") else: return redirect(url_for('user.refresh')) else: flash('You don\'t have an inbox yet. Please create one below.', 'error') return redirect(url_for('user.settings'))
def get(self): if dict(request.args) == ALL_INSPECTORS_QUERY_PARAMS: result = cache.get(GET_ALL_INSPECTORS_KEY) if result: current_app.logger.debug( f'CACHE HIT - {GET_ALL_INSPECTORS_KEY}') return result else: current_app.logger.debug( f'CACHE MISS - {GET_ALL_INSPECTORS_KEY}') paginated_parties, pagination_details = self.apply_filter_and_search( request.args) if not paginated_parties: raise BadRequest('Unable to fetch parties') result = marshal( { 'records': paginated_parties.all(), 'current_page': pagination_details.page_number, 'total_pages': pagination_details.num_pages, 'items_per_page': pagination_details.page_size, 'total': pagination_details.total_results, }, PAGINATED_PARTY_LIST) if dict( request.args ) == ALL_INSPECTORS_QUERY_PARAMS and pagination_details.total_results > 0: current_app.logger.debug(f'SET CACHE - {GET_ALL_INSPECTORS_KEY}') cache.set(GET_ALL_INSPECTORS_KEY, result, timeout=TIMEOUT_12_HOURS) return result
def get(self): token_guid = request.args.get('token', '') as_attachment = request.args.get('as_attachment', None) document_guid = cache.get(DOWNLOAD_TOKEN(token_guid)) cache.delete(DOWNLOAD_TOKEN(token_guid)) if not document_guid: raise BadRequest('Valid token required for download') document = Document.query.filter_by( document_guid=document_guid).first() if not document: raise NotFound( 'Could not find the document corresponding to the token') if as_attachment is not None: as_attachment = True if as_attachment == 'true' else False else: as_attachment = '.pdf' not in document.file_display_name.lower() if document.object_store_path: return ObjectStoreStorageService().download_file( path=document.object_store_path, display_name=document.file_display_name, as_attachment=as_attachment) else: return send_file(filename_or_fp=document.full_storage_path, attachment_filename=document.file_display_name, as_attachment=as_attachment)
def download(file_url): _nros_token = cache.get(NROS_TOKEN) if _nros_token is None: _nros_client_id = current_app.config['NROS_CLIENT_ID'] _nros_client_secret = current_app.config['NROS_CLIENT_SECRET'] _nros_token_url = current_app.config['NROS_TOKEN_URL'] _nros_auth = HTTPBasicAuth(_nros_client_id, _nros_client_secret) _nros_resp = requests.get(_nros_token_url, auth=_nros_auth) _nros_resp_body = json.loads(_nros_resp.text) _nros_token = _nros_resp_body["access_token"] cache.set(NROS_TOKEN, _nros_token, timeout=TIMEOUT_60_MINUTES) file_info_req = requests.get( file_url, stream=True, headers={"Authorization": f"Bearer {_nros_token}"}) file_info_body = json.loads(file_info_req.text) file_download_req = requests.get( f'{file_url}/content', stream=True, headers={"Authorization": f"Bearer {_nros_token}"}) file_download_resp = Response( stream_with_context( file_download_req.iter_content(chunk_size=2048))) file_download_resp.headers['Content-Type'] = file_download_req.headers[ 'Content-Type'] file_download_resp.headers[ 'Content-Disposition'] = f'attachment; filename="{quote(file_info_body["filename"])}"' return file_download_resp
def _get_NRIS_token(): result = cache.get(NRIS_REMOTE_TOKEN) if result is None: _change_default_cipher() params = { 'disableDeveloperFilter': 'true', 'grant_type': 'client_credentials', 'scope': 'NRISWS.*' } url = current_app.config['NRIS_REMOTE_TOKEN_URL'] if url is None: raise TypeError('Could not load the NRIS URL.') else: resp = requests.get( url=url, params=params, auth=(current_app.config['NRIS_REMOTE_CLIENT_ID'], current_app.config['NRIS_REMOTE_CLIENT_SECRET'])) try: resp.raise_for_status() except: raise result = resp.json().get('access_token') cache.set(NRIS_REMOTE_TOKEN, result, timeout=TIMEOUT_60_MINUTES) return result
def head(self, document_guid): if document_guid is None: raise BadRequest('Must specify document GUID in HEAD') file_path = cache.get(FILE_UPLOAD_PATH(document_guid)) if file_path is None or not os.path.lexists(file_path): raise NotFound('File does not exist') response = make_response("", 200) response.headers['Tus-Resumable'] = TUS_API_VERSION response.headers['Tus-Version'] = TUS_API_SUPPORTED_VERSIONS response.headers['Upload-Offset'] = cache.get(FILE_UPLOAD_OFFSET(document_guid)) response.headers['Upload-Length'] = cache.get(FILE_UPLOAD_SIZE(document_guid)) response.headers['Cache-Control'] = 'no-store' response.headers['Access-Control-Expose-Headers'] = 'Tus-Resumable,Tus-Version,Upload-Offset,Upload-Length,Cache-Control' return response
def test_generate_document_returns_token(self, test_client, db_session, auth_headers): """Should return the a token for successful generation""" now_application = NOWApplicationFactory() now_application_identity = NOWApplicationIdentityFactory( now_application=now_application) changed_mine_no = str(now_application_identity.mine.mine_no + '1') data = { 'now_application_guid': now_application_identity.now_application_guid, 'template_data': { 'mine_no': changed_mine_no } } post_resp = test_client.post( f'/now-applications/application-document-types/RJL/generate', json=data, headers=auth_headers['full_auth_header']) assert post_resp.status_code == 200 post_data = json.loads(post_resp.data.decode()) token_data = cache.get(NOW_DOCUMENT_DOWNLOAD_TOKEN(post_data['token'])) assert token_data is not None assert token_data['template_data']['mine_no'] != changed_mine_no assert post_data['token']
def get(self, mine_no): result = cache.get(NRIS_COMPLIANCE_DATA(mine_no)) if result is None: mine = Mine.find_by_mine_no_or_guid(mine_no) if not mine: raise NotFound("No mine record in CORE.") try: raw_data = NRIS_API_service._get_NRIS_data_by_mine( request.headers.get('Authorization'), mine_no) except requests.exceptions.Timeout: current_app.logger.error( f'NRIS_API Connection Timeout <mine_no={mine_no}>') raise except requests.exceptions.HTTPError as e: current_app.logger.error( f'NRIS_API Connection HTTPError <mine_no={mine_no}>, {str(e)}' ) raise result = NRIS_API_service._process_NRIS_data(raw_data) if len(result['orders']) > 0: cache.set(NRIS_COMPLIANCE_DATA(mine_no), result, timeout=TIMEOUT_60_MINUTES) return result
def put(self): otp_guid = None issued_time_utc = None timeout = AuthorizationResource.ONE_TIME_PASSWORD_TIMEOUT_SECONDS data = AuthorizationResource.parser.parse_args() otl_guid = data.get('otl_guid') app_guid = cache.get(otl_guid) current_app.logger.info(f'this is app_guid: {app_guid}') if otl_guid and app_guid: cache.delete(otl_guid) current_app.logger.info(f"OTL_GUID_VALUE: {cache.get(otl_guid)}") otp_guid = uuid.uuid4() issued_time_utc = datetime.now(timezone.utc) cache.set(str(otp_guid), app_guid, timeout=timeout) else: abort(401) return jsonify({ "OTP": otp_guid, "issued_time_utc": issued_time_utc.strftime("%d %b %Y %H:%M:%S %z"), "timeout_seconds": AuthorizationResource.ONE_TIME_PASSWORD_TIMEOUT_SECONDS, "application_guid": app_guid })
def get_face_detection_drawer() -> DrawFaceDetection: config = {"model_type": "cnn", "number_of_times_to_upsample": 0} drawer = cache.get("face_det_drawer") if drawer is None: drawer = DrawFaceDetection(FaceRecognitionLibWrapper(config)) cache.set("face_det_drawer", drawer) return drawer
def get_segmentation_drawer() -> DrawSegmentation: drawer = cache.get("segmentation_drawer") if drawer is None: drawer = DrawSegmentation(TorchvisionSegmentationWrapper()) cache.set("segmentation_drawer", DrawSegmentation(TorchvisionSegmentationWrapper())) return drawer
def get(self): token_guid = request.args.get('token', '') attachment = request.args.get('as_attachment', None) token_data = cache.get(DOWNLOAD_TOKEN(token_guid)) cache.delete(DOWNLOAD_TOKEN(token_guid)) current_app.logger.debug('redis_data' + str(token_data)) if not token_data: raise BadRequest('Valid token required for download') document_guid = token_data['document_guid'] payment_doc = PaymentDocument.query.filter_by( document_guid=document_guid).one_or_none() if not payment_doc: raise NotFound( 'No document was found with the corresponding download token') if attachment is not None: attach_style = True if attachment == 'true' else False else: attach_style = '.pdf' not in payment_doc.document_name.lower() file_resp = ObjectStoreStorageService().download_file( path=payment_doc.object_store_path, display_name=quote(payment_doc.document_name), as_attachment=attach_style) return file_resp
def get_workzone_drawer() -> DrawArucoZone: config_path = "../robot_work_zone_estimation/aruco_config.json" drawer = cache.get("workzone_drawer") if drawer is None: drawer = DrawArucoZone(config_path) cache.set("workzone_drawer", drawer) return drawer
def _get_NRIS_token(): result = cache.get(NRIS_CACHE_PREFIX + 'token') if result is None: params = { 'disableDeveloperFilter': 'true', 'grant_type': 'client_credentials', 'scope': 'NRISWS.*' } url = current_app.config['NRIS_TOKEN_URL'] if url is None: raise TypeError('Could not load the NRIS URL.') else: resp = requests.get(url=url, params=params, auth=(current_app.config['NRIS_USER_NAME'], current_app.config['NRIS_PASS'])) try: resp.raise_for_status() except: raise result = resp.json().get('access_token') cache.set(NRIS_CACHE_PREFIX + 'token', result, timeout=TIMEOUT_12_HOURS) return result
def stats(cls): active_users = cache.get('active_users') if not active_users: active_users = cls.query.filter_by(active=True).count() cache.set('active_users', active_users) inactive_users = cache.get('inactive_users') if not inactive_users: inactive_users = cls.query.filter_by(active=False).count() cache.set('inactive_users', inactive_users) return { 'all': active_users + inactive_users, 'active': active_users, 'inactive': inactive_users }
def get(self, inspection_id, attachment_id): token_guid = request.args.get('token', '') document_info = cache.get(DOWNLOAD_TOKEN(token_guid)) cache.delete(DOWNLOAD_TOKEN(token_guid)) if not document_info: raise BadRequest('Valid token requred for download') return NRISDownloadService.download(document_info["documenturl"], document_info["filename"])
def wrapper(*args, **kwargs): key = 'evil_' + str(current_user._id) rv = cache.get(key) if not rv: # 15秒 cache.set(key, object(), timeout=15) else: abort(403) return f(*args, **kwargs)
def get(self): # Ensure that the token is valid token = request.args.get('token', '') token_data = cache.get(NOW_DOCUMENT_DOWNLOAD_TOKEN(token)) cache.delete(NOW_DOCUMENT_DOWNLOAD_TOKEN(token)) if not token_data: raise BadRequest('Valid token required for download') # Get the template associated with the token doc_type = NOWApplicationDocumentType.query.unbound_unsafe().get( token_data['document_type_code']) template_path = os.path.join(current_app.root_path, doc_type.document_template.template_file_path) # Generate the document using the template and template data docgen_resp = DocumentGeneratorService.generate_document_and_stream_response( template_path, data=token_data['template_data']) # Push the document to the Document Manager filename = docgen_resp.headers['X-Report-Name'] now_application_guid = token_data['now_application_guid'] now_application_identity = NOWApplicationIdentity.query.unbound_unsafe().get( now_application_guid) document_manager_guid = DocumentManagerService.pushFileToDocumentManager( file_content=docgen_resp.content, filename=filename, mine=now_application_identity.mine, document_category='noticeofwork', authorization_header=token_data['authorization_header']) # Add the document to the Notice of Work's documents username = token_data['username'] new_mine_doc = MineDocument( mine_guid=now_application_identity.now_application.mine_guid, document_manager_guid=document_manager_guid, document_name=filename, create_user=username, update_user=username) now_doc = NOWApplicationDocumentXref( mine_document=new_mine_doc, now_application_document_type=doc_type, now_application_id=now_application_identity.now_application_id, create_user=username, update_user=username) now_application_identity.now_application.documents.append(now_doc) now_application_identity.save() # Return the generated document file_gen_resp = Response( stream_with_context(docgen_resp.iter_content(chunk_size=2048)), headers=dict(docgen_resp.headers)) return file_gen_resp
def login(): form = LoginForm(next=request.args.get('next')) if form.validate_on_submit(): u = User.find_by_identity(request.form.get('identity')) if u and u.authenticated(password=request.form.get('password')): # As you can see remember me is always enabled, this was a design # decision I made because more often than not users want this # enabled. This allows for a less complicated login form. # # If however you want them to be able to select whether or not they # should remain logged in then perform the following 3 steps: # 1) Replace 'True' below with: request.form.get('remember', False) # 2) Uncomment the 'remember' field in user/forms.py#LoginForm # 3) Add a checkbox to the login form with the id/name 'remember' if login_user(u, remember=True) and u.is_active(): u.update_activity_tracking(request.remote_addr) # Handle optionally redirecting to the next URL safely. next_url = request.form.get('next') if next_url: return redirect(safe_next_url(next_url)) if current_user.role == 'admin': return redirect(url_for('admin.dashboard')) if current_user.role == 'member': if not cache.get(current_user.mailbox_id): from app.blueprints.user.tasks import get_emails, get_rules, set_cache emails = get_emails.delay(current_user.mailbox_id) set_cache.delay(current_user.mailbox_id, emails.id) if current_user.trial: trial_days_left = 14 - ( datetime.datetime.now() - current_user.created_on.replace(tzinfo=None)).days if trial_days_left < 0: current_user.trial = False current_user.save() return redirect(url_for('user.settings')) else: flash('This account has been disabled.', 'error') else: flash('Your username/email or password is incorrect.', 'error') return render_template('user/login.html', form=form)
def _cache_all_NRIS_major_mines_data(): with sched.app.app_context(): major_mine_list = cache.get(NRIS_JOB_PREFIX + NRIS_MAJOR_MINE_LIST) if major_mine_list is None: return for mine in major_mine_list: if cache.get(NRIS_JOB_PREFIX + mine) == 'False': cache.set(NRIS_JOB_PREFIX + mine, 'True', timeout=TIMEOUT_60_MINUTES) try: data = NRIS_service._get_EMPR_data_from_NRIS(mine) except requests.exceptions.Timeout: pass except requests.exceptions.HTTPError as errhttp: #log error pass except TypeError as e: #log error pass if data is not None and len(data) > 0: NRIS_service._process_NRIS_data(data, mine)
def wrapper(*args, **kwargs): if len(args) > 1: cache_key = key % args[1:] else: cache_key = key rv = cache.get(cache_key) if rv is not None: return rv rv = f(*args, **kwargs) if rv: cache.set(cache_key, rv, timeout=timeout) return rv
def get(self, application_guid, id): token_guid = request.args.get('token', '') document_info = cache.get(DOWNLOAD_TOKEN(token_guid)) cache.delete(DOWNLOAD_TOKEN(token_guid)) if not document_info: raise BadRequest('Valid token requred for download') if document_info["originating_system"] == "VFCBC": return VFCBCDownloadService.download(document_info["documenturl"], document_info["filename"]) if document_info["originating_system"] == "NROS": return NROSDownloadService.download(document_info["documenturl"]) raise InternalServerError('Unknown application document server')