def get_box_client(self, parsed_url):
try:
config_path = os.path.expanduser(
parsed_url.query_args[u'config'][0])
return Client(JWTAuth.from_settings_file(config_path))
except Exception as e:
config_path = os.environ.get(u'BOX_CONFIG_PATH')
if config_path is not None:
try:
return Client(JWTAuth.from_settings_file(config_path))
except Exception as e:
raise BackendException(u'box config file is not found.')
raise BackendException(
u'box config file is not specified or not found.')
def authenticate(self):
'''
JWT authentication
'''
auth = JWTAuth.from_settings_file(self.config_filename)
access_token = auth.authenticate_instance()
self.client = Client(auth)
def __init__(self):
config = JWTAuth.from_settings_file('800515977_eqwyjy8m_config.json')
self.client = Client(config)
self.user_to_impersonate = self.client.user(user_id='226100449')
self.user_client = self.client.as_user(self.user_to_impersonate)
self.music_folder = self.user_client.root_folder().get()
self.update_thread = UpdateThread(self.user_client, self.music_folder)
def set_connection():
auth = JWTAuth.from_settings_file(
'C:\\Users\\gwilliams\\Desktop\\Python Experiments\\work projects\\Working_with_Box\\Working_with_Box\\config_info\\keys_config.json'
)
client = Client(auth)
return client
def __init__(self):
#p=Proxy()
#p.URL='https://bcpxy.nycnet:8080'
#p.AUTH={'user': '******', 'password':'******'}
#self.session=Session(proxy_config=p)
self.session=Session()
self.sdk = JWTAuth.from_settings_file('/code/mocj_porter/config/box_config.json')
self.client=Client(self.sdk,self.session)
def __init__(self, path_to_config):
print("box_config", path_to_config)
if os.path.isfile(path_to_config) == False:
raise ValueError(
"configPath must be a path to the JSON config file for your Box JWT app"
)
auth = JWTAuth.from_settings_file(path_to_config)
logger.info("Authenticating BoxAdaptor...")
auth.authenticate_instance()
self.client = Client(auth)
def upload_files(file_paths, dir_name):
""" TODO """
config = JWTAuth.from_settings_file('static/secrets/config.json')
try:
client = Client(config)
content = Folder(client.folder('0'))
user = client.user().get()
print(content)
print(content.get_items())
print('The current user ID is {0}'.format(user.id))
except (BoxOAuthException, BoxException) as e:
# logging.warn()
raise e
def get_box_authenticated_client(box_json_config_path):
"""
Get an authenticated Box client for a JWT service account
:param box_json_config_path:
:return:
"""
if not os.path.isfile(box_json_config_path):
raise ValueError(
"`box_json_config_path` must be a path to the JSON config file for your Box JWT app"
)
auth = JWTAuth.from_settings_file(box_json_config_path)
auth.authenticate_instance()
return Client(auth)
def get_conn(self):
"""
:return:
"""
if self._box_client:
return self._box_client
key_path = os.environ.get('BOX_AUTH_LOCATION', False)
if key_path:
self.log.info('Getting connection using a JSON key file.')
self._box_client = Client(JWTAuth.from_settings_file(key_path))
return self._box_client
else:
raise AirflowException("BOX JSON key file is missing")
def get_client(self):
auth = JWTAuth.from_settings_file(self.config_file)
admin_client = Client(auth)
lifespan_user = None
# lifespan_user = client.create_user('Lifespan Automation')
for user in admin_client.users():
if user.name == self.user:
lifespan_user = user
if not lifespan_user:
print(self.user + ' user was not found. Exiting...')
sys.exit(-1)
return admin_client.as_user(lifespan_user)
def update_file(file_id, file_path):
"""
Updates a file (that must exist in Box folder) given its identifier.
:param file_id: File identifier.
:param file_path: File path.
:return: File identifier if the update was successful, None otherwise.
"""
box_client = Client(JWTAuth.from_settings_file(BOX_CONFIG_FILE_PATH))
for i in range(0, BOX_RETRIES):
try:
return box_client.file(file_id).update_contents(file_path).id
except Exception as e:
time.sleep(BOX_RTM)
if i == BOX_RETRIES - 1:
print(f'Error calling Box API updating the file [{file_id}] with file [{file_path}]: {e}')
return None
def create_folder(folder_name):
"""
Creates a folder in the root folder given its name.
:param folder_name: Folder name to create.
:return: Folder identifier if the creation was successful, None otherwise.
"""
box_client = Client(JWTAuth.from_settings_file(BOX_CONFIG_FILE_PATH))
for i in range(0, BOX_RETRIES):
try:
sub_folder = box_client.folder(BOX_FOLDER_ROOT_ID).create_subfolder(folder_name)
return sub_folder.id
except Exception as e:
time.sleep(BOX_RTM)
if i == BOX_RETRIES - 1:
print(f'Error calling Box API creating the folder [{folder_name}] into folder root: {e}')
return None
def upload_file(folder_id, file_path):
"""
Uploads a file (that must not exist in Box folder) into a folder given its path.
:param folder_id: Folder identifier.
:param file_path: File path.
:return: File identifier if the upload was successful, None otherwise.
"""
box_client = Client(JWTAuth.from_settings_file(BOX_CONFIG_FILE_PATH))
for i in range(0, BOX_RETRIES):
try:
file_name = file_path.split('/')[-1]
return box_client.folder(folder_id).upload(file_path, file_name).id
except Exception as e:
time.sleep(BOX_RTM)
if i == BOX_RETRIES - 1:
print(f'Error calling Box API uploading the file [{file_path}] to folder with id [{folder_id}]: {e}')
return None
def download_file(file_id, file_path):
"""
Downloads a Box file given its identifier to a specific path.
:param file_id: File identifier.
:param file_path: File path.
:return: True if the download was successful, False otherwise.
"""
box_client = Client(JWTAuth.from_settings_file(BOX_CONFIG_FILE_PATH))
for i in range(0, BOX_RETRIES):
try:
with open(file_path, 'wb') as file:
box_client.file(file_id).download_to(file)
return True
except Exception as e:
time.sleep(BOX_RTM)
if i == BOX_RETRIES - 1:
print(f'Error calling Box API downloading the file [{file_id}] to file [{file_path}]: {e}')
return False
def __init__(self):
# Local
self.CONFIG_PATH = "/home/pi/Activity_Monitor_Base_Station/box/config.json"
self.FILE_READ_PATH = "/home/pi/Activity_Monitor_Base_Station/box/read.txt"
self.FILE_WRITE_PATH = "/home/pi/Activity_Monitor_Base_Station/box/write.txt"
self.FILE_ERROR_PATH = "/home/pi/Activity_Monitor_Base_Station/box/error.txt"
# Remote
self.DATA_FOLDER = "75253867312" # CHANGE THIS
self.ERROR_FOLDER = "78605578754" # CHANGE THIS
self.client = ""
# Retrieve authentication information from config file
auth = JWTAuth.from_settings_file(self.CONFIG_PATH)
# Authenticate applications token
access_token = auth.authenticate_instance()
# Authorize application client
self.client = Client(auth)
def get_authenticated_client(config_path):
"""Get an authenticated Box client for a JWT service account
Arguments:
configPath {str} -- Path to the JSON config file for your Box JWT app
Returns:
Client -- A Box client for the JWT service account
Raises:
ValueError -- if the configPath is empty or cannot be found.
"""
if not os.path.isfile(config_path):
raise ValueError(f"configPath must be a path to the JSON config file for your Box JWT app")
auth = JWTAuth.from_settings_file(config_path)
print("Authenticating...")
auth.authenticate_instance()
return Client(auth)
def get_client(service_account):
"""
Attempts to create the Box Client with the associated with the credentials.
"""
try:
if os.path.isfile(service_account):
auth = JWTAuth.from_settings_file(service_account)
else:
service_dict = json.loads(service_account)
auth = JWTAuth.from_settings_dictionary(service_dict)
client = Client(auth)
client.user().get()
return client
except BoxOAuthException as e:
print(f'Error accessing Box account with pervice account ' \
f'developer_token={developer_token}; client_id={client_id}; ' \
f'client_secret={client_secret}')
raise (e)
def search_file(folder_id, file_name):
"""
Finds a file into a folder given its identifier and a query string.
:param folder_id: Folder identifier.
:param file_name: File name.
:return: File identifier if the file exists, None otherwise.
"""
box_client = Client(JWTAuth.from_settings_file(BOX_CONFIG_FILE_PATH))
for i in range(0, BOX_RETRIES):
try:
for result in box_client.folder(folder_id).get_items():
if result.name == file_name:
return result.id
return None
except Exception as e:
time.sleep(BOX_RTM)
if i == BOX_RETRIES - 1:
print(f'Error calling Box API searching files into folder [{folder_id}] with name [{file_name}]: {e}')
return None
def load_mentors_spreadsheet(self, auth):
''' Load the feline foster spreadsheet
'''
try:
Log.success(
f'Loading mentors spreadsheet from Box (id = {auth["box_file_id"]})...'
)
jwt_path = os.path.join(
os.path.dirname(os.path.realpath(__file__)), auth['box_jwt'])
client = Client(JWTAuth.from_settings_file(jwt_path))
box_file = client.as_user(
client.user(user_id=auth['box_user_id'])).file(
file_id=auth['box_file_id']).get()
xlxs_workbook = xlrd.open_workbook(
file_contents=box_file.content())
config_yaml = xlxs_workbook.sheet_by_name(
self._CONFIG_SHEET_NAME).row_values(1)[0]
for sheet_name in xlxs_workbook.sheet_names():
if not self._is_reserved_sheet(sheet_name):
sheet = xlxs_workbook.sheet_by_name(sheet_name)
self._mentor_sheets.append(sheet)
all_values = [
sheet.row_values(i) for i in range(1, sheet.nrows)
]
self._mentor_match_values[Utils.utf8(sheet_name)] = [
Utils.utf8(str(item)).lower() for sublist in all_values
for item in sublist
]
except Exception as e:
Log.error(
f'ERROR: Unable to load Feline Foster spreadsheet!\r\n{str(e)}, {repr(e)}'
)
return None
print(
f'Loaded {len(self._mentor_sheets)} mentors from \"{box_file["name"]}\"'
)
return config_yaml
def main(box_config, parent_folder_id, day_lookback, start_date_str,
end_date_str):
# Get the Box service account client
auth = JWTAuth.from_settings_file(box_config)
client = Client(auth)
current_enterprise = client.get_current_enterprise()
global current_enterprise_id
current_enterprise_id = current_enterprise.id
service_account = client.user().get()
print(
'Found Service Account with name: {0}, id: {1}, and login: {2}'.format(
service_account.name, service_account.id, service_account.login))
start_date = None
end_date = None
if day_lookback is not None:
# Get the current date and the date for one month ago
start_date = end_date - relativedelta.relativedelta(days=day_lookback)
end_date = datetime.utcnow()
elif (start_date_str is not None) and (end_date_str is not None):
date_format = '%Y-%m-%d'
start_date = datetime.strptime(start_date_str, date_format)
end_date = datetime.strptime(end_date_str, date_format)
else:
raise Exception(
'--day_lookback OR --start_date AND --end_date are required parameters!'
)
print('Using date range for events - start date: {0} and end date: {1}'.
format(start_date, end_date))
# Create a collaboration dictionary
traverse_folder_tree(client, parent_folder_id)
print('Found collab count: {0}'.format(len(folder_collaborations_dict)))
# Get Box events
get_box_events(client, limit, 0, start_date, end_date)
print('Found event count: {0}'.format(len(events_dict)))
# Generate Excel report
create_excel_report()
print('Finished!')
def create_shared_link(folder_id):
"""
Creates an Internet accessible shared link of folder given its identifier.
:param folder_id: Folder identifier.
:return: Shared link if the creation was successful, None otherwise.
"""
box_client = Client(JWTAuth.from_settings_file(BOX_CONFIG_FILE_PATH))
for i in range(0, BOX_RETRIES):
try:
shared_link = box_client.folder(folder_id).get_shared_link(
access=BOX_LINK_OPEN_ACCESS,
allow_download=BOX_LINK_ALLOW_DOWNLOAD,
allow_preview=BOX_LINK_ALLOW_PREVIEW
)
return shared_link
except Exception as e:
time.sleep(BOX_RTM)
if i == BOX_RETRIES - 1:
print(f'Error calling Box API creating a shared link for folder [{folder_id}]: {e}')
return None
def __init__(self, path_to_config=DEFAULT_CONFIG_FP, user_agent="Luigi"):
"""
:param str path_to_config: path to Box JWT config.json file
"""
if not path_to_config:
raise ValueError(
"The path_to_config parameter must contain a valid Box JWT config.json file"
)
self.path_to_config = path_to_config
try:
config = JWTAuth.from_settings_file(path_to_config)
self.client = Client(config)
self.conn = self.client
except Exception as e:
raise Exception(
"Cannot connect to Box. Check your Internet connection and the token. \n"
+ repr(e))
self.token = path_to_config
def box_auth():
uid = g.user.id
# Instantiate Box Client instance
auth = JWTAuth.from_settings_file('../config.json')
box_client = Client(auth)
# Validate is user exists
url = f'https://api.box.com/2.0/users?external_app_user_id={uid}'
response = box_client.make_request('GET', url)
user_info = response.json()
# If user not found, create user, otherwise fetch user token
if (user_info['total_count'] == 0):
user_name = f'{g.user.profile.firstName} {g.user.profile.lastName}'
space = 1073741824
# Create app user
user = box_client.create_user(user_name,
None,
space_amount=space,
external_app_user_id=uid)
print('user {name} created')
else:
# Create user client based on discovered user
user = user_info['entries'][0]
user_to_impersonate = box_client.user(user_id=user['id'])
user_client = box_client.as_user(user_to_impersonate)
# Get current user
current_user = box_client.user().get()
print(current_user.id)
# Get all items in a folder
items = user_client.folder(folder_id='0').get_items()
for item in items:
print('{0} {1} is named "{2}"'.format(item.type.capitalize(),
item.id, item.name))
return 'Test complete'
def downloadcsv(
self, authPath: "path to your box config file, a json file",
folderID:
"the id of the folder on box drive containing the csv files",
date: "the date taht the csv file was created"):
"""Download the csv file from box."""
from boxsdk import JWTAuth
from boxsdk import Client
import os
sdk = JWTAuth.from_settings_file(authPath)
client = Client(sdk)
items = client.folder(folder_id=folderID).get_items()
dir = os.getcwd()
for item in items:
if date in item.name:
item_id = item.id
box_file = client.file(file_id=item_id).get()
output_file = open(f'{os.getcwd()}/raw_csv/{box_file.name}',
'wb')
box_file.download_to(output_file)
output_file.close()
def get_box_authenticated_client(box_json_config_path, is_verbose=False):
"""Get an authenticated Box client for a JWT service account
:param box_json_config_path: A path to the JSON config file for your Box JWT app
:type box_json_config_path: str
:param is_verbose: A flag for turning print statements on/off, optional
:type is_verbose: bool, optional
:raises ValueError: if the box_json_config_path is empty or cannot be found
:return: A Box client for the JWT service account
:rtype: Client
"""
if not os.path.isfile(box_json_config_path):
raise ValueError(
f"`box_json_config_path` must be a path to the JSON config file for your Box JWT app"
)
auth = JWTAuth.from_settings_file(box_json_config_path)
if is_verbose:
print(f"Authenticating...")
auth.authenticate_instance()
return Client(auth)
def createBoxUserClient(userId):
user = client.user(user_id=userId)
configJson = os.getenv('BoxConfigJson')
auth = JWTAuth.from_settings_file(configJson)
auth.authenticate_user()
user_client = Client(auth)
def createBoxClient():
configJson = os.getenv('BoxConfigJson')
auth = JWTAuth.from_settings_file(configJson)
return Client(auth)
from boxsdk import JWTAuth, Client
from box_api import get_child_items, get_folder_information
if __name__ == '__main__':
# see: https://developer.box.com/guides/authentication/jwt/with-sdk/
config = JWTAuth.from_settings_file('./config.json')
client = Client(config)
root_folder_id = '123456789'
root_folder = get_folder_information(client, root_folder_id)
root_folder = get_child_items(client, root_folder)
from boxsdk import JWTAuth, Client
auth = JWTAuth.from_settings_file('box_config.json')
client = Client(auth)
service_account = client.user().get()
print(
'Service Account user email is {0}\nShare your root folder with this address for the script to be able to access the subfolders.'
.format(service_account.login))
def __init__(self, service=None, config="~/.cloudmesh/cloudmesh4.yaml"):
super().__init__(service=service, config=config)
self.sdk = JWTAuth.from_settings_file(self.credentials['config_path'])
self.client = Client(self.sdk)
