def _login(self): access_token, refresh_token = read_tokens() if access_token is None or refresh_token is None: oauth = bx.OAuth2( client_id=self.client_id, client_secret=self.client_secret, store_tokens=store_tokens, ) self.auth_url, csrf_token = oauth.get_authorization_url( self.redirect_url) webbrowser.open(self.auth_url) global _access_code while _access_code is None: log.debug(_access_code) time.sleep(1) if _access_code == "denied": raise PermissionError("Failed to authenticate to Box.") access_token, refresh_token = authenticate(oauth, _access_code) oauth = bx.OAuth2( client_id=self.client_id, client_secret=self.client_secret, access_token=access_token, refresh_token=refresh_token, ) self._client = bx.Client(oauth)
def _init_client(self): oauth = boxsdk.OAuth2(client_id=self.creds["client_id"], client_secret=self.creds["client_secret"], store_tokens=self._store_tokens, access_token=self.creds["user_access_token"], refresh_token=self.creds["user_refresh_token"]) client = boxsdk.Client(oauth) return client
def get_box_client(): oauth = boxsdk.OAuth2( client_id='f5qebb99vwnebdrdok3wv7ew4pk84nl3', client_secret='cLwt5hj96589T15SG6lAp11fZYBsqyel', access_token='rVSyiCPelJx3hPYPquM8Gy9ZRuLvoCHl', ) client = boxsdk.Client(oauth) return client
def __init__(self, client_id=None, client_secret=None, access_token=None): client_id = check_env('BOX_CLIENT_ID', client_id) client_secret = check_env('BOX_CLIENT_SECRET', client_secret) access_token = check_env('BOX_ACCESS_TOKEN', access_token) oauth = boxsdk.OAuth2(client_id=client_id, client_secret=client_secret, access_token=access_token) self.client = boxsdk.Client(oauth)
def get_box_client(): """ Sets up a Box Platform API client as a global variable. """ global box_client if not box_client: box_auth = get_box_auth() box_client = boxsdk.Client(box_auth) return box_client
def __init__(self, archive, settings): self.archive = archive self.client_id = settings.get('box.client_id') self.client_secret = settings.get('box.client_secret') self.oauth = boxsdk.OAuth2(client_id=self.client_id, client_secret=self.client_secret, access_token=archive.access_token, refresh_token=archive.refresh_token, store_tokens=archive.store) self.client = boxsdk.Client(self.oauth)
def get_users_box_access_token(username): """ Gets a user's Box Platform app user API access token """ box_client = get_box_client() box_user_id = get_users_box_app_user_id(username) box_user = box_client.user(box_user_id) auth = boxsdk.JWTAuth.from_settings_dictionary(box_jwt_keys, user=box_user) auth.authenticate_user() box_as_user_client = boxsdk.Client(auth) return box_as_user_client._oauth.access_token
def authenticate(identifier, secret, token): '''identifier: client_id, provided in config.py secret: client_secret, provided in config.py token: developer token, accessed from box developer console ''' oauth = boxsdk.OAuth2( client_id=identifier, client_secret=secret, access_token=token ) client = boxsdk.Client(oauth) return client
def get_box_client(as_user_email=None): """ Sets up a Box Platform API client as a global variable. """ global box_client if not box_client: box_auth = get_box_auth() box_client = boxsdk.Client(box_auth) if as_user_email: user = box_client.users(filter_term=as_user_email, limit=1).next() box_client = box_client.as_user(user) return box_client
def cds(): # Authenticate with Box web services and get web service client box_auth = boxsdk.JWTAuth.from_settings_file( os.path.join('box_auth', 'kaiser_permanente_california.json')) box_client = boxsdk.Client(box_auth) # ------------------------------------------------------------------------------------------------------------------ # This implementation for retrieving files from Box is not suitable for production. # In the production application, services sending CDS to Box will write Redis record with newly created Box file id # # Key = [patient id]-latest-cds-box-file-id # Value = [newly created box file id] # # Example in Redis # 443340029-latest-cds-box-file-id:1233321 # # This request handler's route will change to /cds/[patient_id] # Patient id will be used to retrieve Box file id from Redis, then the Box Download File API will be called with the # associated Box file id. # ------------------------------------------------------------------------------------------------------------------ # Demoware solution to get a file from Box # Get Box folder box_folder = box_client.folder(folder_id='0').get() # Determine last CDS uploaded to Box folder latest_entry = None latest_entry_created_at = None for entry in box_folder.item_collection['entries']: current_created_at = datetime.datetime.strptime( entry.get().created_at, '%Y-%m-%dT%H:%M:%S%z') if not latest_entry_created_at or current_created_at > latest_entry_created_at: latest_entry = entry latest_entry_created_at = current_created_at # Write CDS to file system with open(os.path.join(os.getcwd(), 'tmp', latest_entry.name), 'wb') as fh: latest_entry.download_to(fh) # Build response with CDS included response = flask.send_from_directory('tmp', filename=latest_entry.name) # Disable browser caching response.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate' response.headers['Pragma'] = 'no-cache' response.headers['Expires'] = '0' # Respond to client request return response
def connectJWTAuth(): auth = boxsdk.JWTAuth(client_id=BoxClientID, client_secret=BoxClientSecret, enterprise_id=BoxEnterpriseID, jwt_key_id=BoxPublicKeyID, rsa_private_key_file_sys_path=BoxRSAFile, rsa_private_key_passphrase=BoxPassPhrase, store_tokens=store_tokens) # https://github.com/box/box-python-sdk#authorization # access_token = auth.authenticate_instance() client = boxsdk.Client(auth) return client
def connectJWTAuth(): brk2 = BoxRSAKey.replace('\\n', '\n') auth = boxsdk.JWTAuth( client_id=BoxClientID, client_secret=BoxClientSecret, enterprise_id=BoxEnterpriseID, jwt_key_id=BoxPublicKeyID, # NB: BoxRSAKey needs to be byte string vs. unicode rsa_private_key_data=brk2.encode(), # BoxRSAKey.encode(), rsa_private_key_passphrase=BoxPassPhrase, store_tokens=store_tokens) # https://github.com/box/box-python-sdk#authorization # access_token = auth.authenticate_instance() client = boxsdk.Client(auth) return client
def __init__(self, stache_secret): # Authenticate the API client using the JWT authentication method. private_key_stream = BytesIO( stache_secret["boxAppSettings"]["appAuth"]["privateKey"].encode()) jwt_options = { "client_id": stache_secret["boxAppSettings"]["clientID"], "client_secret": stache_secret["boxAppSettings"]["clientSecret"], "enterprise_id": stache_secret["enterpriseID"], "jwt_key_id": stache_secret["boxAppSettings"]["appAuth"]["publicKeyID"], "rsa_private_key_passphrase": stache_secret["boxAppSettings"]["appAuth"]["passphrase"].encode(), "rsa_private_key_data": private_key_stream } auth = boxsdk.JWTAuth(**jwt_options) auth.authenticate_instance() self.client = boxsdk.Client(auth)
def start_session(): """Initialize a Box session using Box API. """ global access_token, refresh_token, server_thread, httpd # Try to retrieve tokens from keychain # If error during OAuth or no tokens, re-authenticate try: access_token, refresh_token = retrieve_tokens() oauth = boxsdk.OAuth2(client_id=BOX_CLIENT_ID, access_token=access_token, refresh_token=refresh_token, client_secret=BOX_CLIENT_SECRET, store_tokens=store_tokens) if None in (access_token, refresh_token): raise boxsdk.exception.BoxOAuthException('No Tokens') except boxsdk.exception.BoxOAuthException: # Authenticate with OAuth print("\nAuthenticating...".ljust(71), end="", flush=True) oauth = boxsdk.OAuth2(client_id=BOX_CLIENT_ID, client_secret=BOX_CLIENT_SECRET, store_tokens=store_tokens) # Start HTTP server to get auth token from Box.com redirect server_thread = threading.Thread(target=run_server) server_thread.start() auth_url, csrf = oauth.get_authorization_url('http://127.0.0.1:7777') # Open browser and wait for user authentification webbrowser.open(auth_url) while not auth_code: pass # Shutdown HTTP Server httpd.shutdown() server_thread.join() access_token, refresh_token = oauth.authenticate(auth_code) httpd.shutdown() print("Complete!") # Return authenticated client return boxsdk.Client(oauth)
def main(): configure_logging() # Load the Box Platform app's JWT keys into memory as a dicitons with open(BOX_AUTH_FILE_PATH) as fh: box_auth_dict = json.load(fh) # Get Box access tokens with the JWT keys from Box's authentication service auth = boxsdk.JWTAuth.from_settings_dictionary(box_auth_dict) auth.authenticate_instance() # Set up a Box HTTP client box_client = boxsdk.Client(auth) # Set up a rate limiter rate_limiter = RateLimiter() while True: # Call the rate limiter as content manager with rate_limiter: # Call Box folder = box_client.folder("0") log.info(f"got Box folder {folder}")
def get_refresh_token_from_file(): data = get_token() return data['refresh_token'] def get_access_token(): secret_token(get_refresh_token_from_file()) return get_access_token_from_file() oauth = boxsdk.OAuth2( client_id=box_client_id, client_secret=box_client_secret, access_token=get_access_token(), ) client = boxsdk.Client(oauth) # root_folder = client.folder(folder_id='0').get_items(limit=100, offset=0) list_to_create = [] def log(message): with open('log.txt', 'a') as f: f.write(message + '\n') def sync_create_file(dropbox_path, box_folder_id): file_name = dropbox_path[1:].split('/')[-1] sys.stdout.write('Downloading from Dropbox -') sys.stdout.flush() with open('temp-'+file_name, 'wb') as temp_f: metadata, res = dbx.files_download(dropbox_path) temp_f.write(res.content) sys.stdout.write(' Uploading to Box -')
def configure_box_client(config: dict) -> boxsdk.Client: box_auth = configure_box_auth(config) client = boxsdk.Client(box_auth) return client
def __init__(self, args, flags=[], client='microsoft'): parser = argparse.ArgumentParser() parser.add_argument( '-c', '--config', help='Config file location', default='/etc/odm.yaml', ) parser.add_argument( '-v', '--verbose', help='Enable verbose output', action='count', default=0, ) for arg in args: parser.add_argument(arg) for flag in flags: parser.add_argument(flag, action='store_true') self.args = parser.parse_args() with open(self.args.config, 'r') as configfile: self.config = yaml.safe_load(configfile) self.config['args'] = self.args # Configure root logger logger = logging.getLogger() handler = logging.StreamHandler(sys.stderr) handler.setFormatter( logging.Formatter('%(asctime)s %(name)s: %(message)s', '%Y-%m-%dT%H:%M:%S')) if self.args.verbose == 0: logger.setLevel(logging.WARNING) elif self.args.verbose == 1: logger.setLevel(logging.INFO) else: logger.setLevel(logging.DEBUG) if self.args.verbose < 3: handler.addFilter(lambda x: x.name.startswith('odm')) logger.addHandler(handler) self.logger = logging.getLogger(__name__) self.logger.debug('Using config file %s', self.args.config) if client == 'google': self.client = googledriveclient.GoogleDriveClient(self.config) elif client == 'microsoft': self.client = onedriveclient.OneDriveClient(self.config) elif client == 'box': auth = boxsdk.JWTAuth( client_id=self.config['box']['clientID'], client_secret=self.config['box']['clientSecret'], enterprise_id=self.config['box']['enterpriseID'], jwt_key_id=self.config['box']['appAuth']['publicKeyID'], rsa_private_key_data=self.config['box']['appAuth'] ['privateKey'], rsa_private_key_passphrase=self.config['box']['appAuth'] ['passphrase'], ) session = boxsdk.session.session.AuthorizedSession( auth, default_headers={ 'Box-Notifications': 'off', }, ) self.client = boxsdk.Client(auth, session)
#Box API configurations with open('box_config.json', 'r') as f: boxapi = json.load(f) box_auth = boxsdk.JWTAuth( client_id=boxapi["boxAppSettings"]["clientID"], client_secret=boxapi["boxAppSettings"]["clientSecret"], enterprise_id=boxapi["enterpriseID"], jwt_key_id=boxapi["boxAppSettings"]["appAuth"]["publicKeyID"], rsa_private_key_data=boxapi["boxAppSettings"]["appAuth"]["privateKey"], rsa_private_key_passphrase=boxapi["boxAppSettings"]["appAuth"] ["passphrase"], ) box_access_token = box_auth.authenticate_instance() box_client = boxsdk.Client(box_auth) #Roman numeral utility def toRoman(data): romans = ["I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"] romin = int(data) - 1 if romin >= 0 and romin < len(romans): romreg = romans[romin] else: romreg = data return romreg @app.route('/debug-sentry') def trigger_error():
def configure_box_client(config: dict) -> boxsdk.Client: box_auth = configure_jwt_auth(config) box_client = boxsdk.Client(box_auth) log.debug(f"set up Box client {box_client}") return box_client
def box_client_from_config(config: dict) -> boxsdk.Client: box_auth = box_auth_from_config(config) client = boxsdk.Client(box_auth) return client
def poll_cds(): # Create database connection to OpenEMR MySQL backend db_connection = pymysql.connect(host='localhost', user='******', password='******', db='openemr', cursorclass=pymysql.cursors.DictCursor) # Create Redis connection for cache cache_connection = redis.Redis(host='localhost', port=6379, db=0) # Get database cursor with db_connection.cursor() as cursor: try: # Query OpenEMR for one patient record cursor.execute("SELECT * FROM openemr.patient_data;") db_record = cursor.fetchone() if db_record: # ------------------------------------------------------------------------------------------------------ # This is where the clinical subject matter experts logic to determine care recommendations is # implemented. For the demo, the CDS logic is simply # # Create CDS if never done before or patient age changes # If we create CDS # Make no recommendations if the patient is under or 26 years old # Make one set of recommendations if the patient is over 26 years old # # ------------------------------------------------------------------------------------------------------ # Get patient age db_patient_dob = db_record['DOB'] today = datetime.date.today() db_patient_age = today.year - db_patient_dob.year - ( (today.month, today.day) < (db_patient_dob.month, db_patient_dob.day)) # Get patient age patient_id = db_record['id'] # Retrieve patient age from cache - cache records represented as {patient id: patient age} cached_patient_age = cache_connection.get(patient_id) # Generate CDS if first encounter of patient of patient age changed since last poll if not cached_patient_age or int( cached_patient_age) != db_patient_age: # Update cache with new patient id age mapping cache_connection.set(patient_id, db_patient_age) # Render CDS recommendations as HTML provide_recommendation = True if db_patient_age > 26 else False # ------------------------------------------------------------------------------------------------------ template_env_loader = jinja2.FileSystemLoader( os.path.join(os.getcwd(), 'static')) template_env = jinja2.Environment( loader=template_env_loader) cds_template = template_env.get_template( 'cds_template.html') rendered_cds = cds_template.render( provide_recommendation=provide_recommendation, age=db_patient_age, fname=db_record['fname'], lname=db_record['lname'], sex=db_record['sex'], patient_id=patient_id) tmp_cds_path = os.path.join( os.getcwd(), f'tmp/cds_{patient_id}_{db_patient_age}_{int(time.time())}.pdf' ) # Convert rendered HTML to PDF pdfkit.from_string(rendered_cds, tmp_cds_path) # Authenticate with Box web services and get web service client box_auth = boxsdk.JWTAuth.from_settings_file( os.path.join('box_auth', 'kaiser_permanente_california.json')) box_client = boxsdk.Client(box_auth) # Upload CDS to Box box_client.folder('0').upload(tmp_cds_path) # Remove CDS from file system os.remove(tmp_cds_path) finally: # Close database cursor cursor.close()
# import watchtower # print(desktop_uploader.get_file_created("test/iguana.jpg")) # Global SECONDS_DELAY = 10.0 last_reference = {} try: with open('persist.json') as f: last_reference = json.load(f) except: pass lock = threading.Lock() t = None auth = boxsdk.JWTAuth.from_settings_file('box_config.json') client = boxsdk.Client(auth) with open('config.json') as f: config = json.load(f) unprocessed_dir = config['unprocessed_dir'] error_dir = config['error_dir'] done_dir = config['done_dir'] postgres = config['postgres'] cloudwatch = config['cloudwatch'] # Fail on startup if something's wrong print("Checking the connections...") # None of the dirs should be the same as another assert (len([unprocessed_dir, error_dir, done_dir]) == len(set([unprocessed_dir, error_dir, done_dir]))) # Check Box connection client.user().get()
file_name = os.path.join(folder_name, item.name) with open(file_name, 'bw') as file: item.download_to(file) logging.info('Downloaded {}.'.format(file)) else: new_folder_name = os.path.join(folder_name, item.name) os.makedirs(new_folder_name) try: new_folder_content = item.get_items() download_items(new_folder_content, folder_name=new_folder_name) except: print('Error on {}'.format(item)) if __name__ == '__main__': # Authenticate sdk = box.JWTAuth.from_settings_file( '/home/tbiancal/.ssh/hubmap-downloader_box.json') client = box.Client(sdk) # Get root folder root_folder = client.folder(folder_id='0') root_items = root_folder.get_items() items = [item for item in root_items] folder = items[0] assert folder.name == 'HuBMAP_Satija_Kharchenko_CCF' items = folder.get_items() download_items(items)