def create_user():
if not request.form['name']:
flash("Name required for user creation.", "error")
return redirect(url_for('index'))
client = Client(g.auth, network_layer=customLogger)
new_user = client.create_user(request.form['name'],
job_title=request.form['job'],
phone=request.form['phone'],
address=request.form['address'])
if request.form.get('initialize'):
# User init scripts go here
add_user_to_group(client, new_user, "SuchGroup")
flash("Initialized user: {0}".format(request.form['name']))
else:
flash("Created new user: {0} ".format(request.form['name']))
return redirect(url_for('index'))
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'
from boxsdk.exception import BoxAPIException
import os
auth = JWTAuth(
client_id='00000000',
client_secret='00000000',
enterprise_id='00000000',
jwt_key_id='00000000',
rsa_private_key_file_sys_path='loans/private_key.pem',
rsa_private_key_passphrase='00000000',
)
access_token = auth.authenticate_instance()
client = Client(auth)
ned_stark_user = client.create_user('Phillip Fry')
ned_auth = JWTAuth(
client_id='00000000',
client_secret='00000000',
enterprise_id='00000000',
jwt_key_id='00000000',
rsa_private_key_file_sys_path='loans/private_key.pem',
rsa_private_key_passphrase='00000000',
)
ned_auth.authenticate_app_user(ned_stark_user)
ned_client = Client(ned_auth)
#phil_fry_user = client.create_user('Phil Fry',user_id='10000')
from boxsdk import JWTAuth
from boxsdk import Client
auth = JWTAuth(
client_id='2xld7m3w2j9hvjy60aq951lc68u2ocfv',
client_secret='gFZg7dhe4Rr2eSIW1D7aZJs6WjXSGI2J',
enterprise_id='15270599',
jwt_key_id='qtm1mgfu',
rsa_private_key_file_sys_path='loans/private_key.pem',
rsa_private_key_passphrase='nb062795',
)
access_token = auth.authenticate_instance()
client = Client(auth)
ned_stark_user = client.create_user('Ned Stark')
class BoxClient():
def __init__(self):
self.client = Client(auth)
self.client_creator = self.client.user()
self.client_created_time = datetime.datetime.now()
self.as_users = as_users
self.logger = logging.getLogger(__name__)
# Common User Methods
def get_users(self):
"""
Return a dictionary with users and their ids
:return:
"""
users_dict = dict()
users = self.client.users(user_type='all')
for user in users:
users_dict[user.id] = user.name
return users_dict
def get_user_by_email(self, login):
"""
Searches for a user by email and returns a Box User Object
:param login:
:return:
"""
user = None
users = self.client.users(filter_term=login)
for user in users:
if user.login == login:
return user
return user
def create_users(self, upload_method, file, group_name, query):
"""
Create users at scale
:param upload_method:
:param file:
:param group_name:
:return: a dictionary containing on how many users were created and how many failed to be created
"""
success_count = 0
fail_count = 0
group_id = self.get_group_id(group_name)
# If the group doesn't exist, create it.
if not group_id:
user_input = input(
"The group %s doesn't exist. Would you like to create it (yes/no)? "
% group_name)
if user_input == "yes":
group_response = self.create_groups(logger, group_name)
msg = "Group '%s' successfully created" % group_name
logger.info(msg)
elif user_input == "no":
msg = "No users were added because user opted to not create a new group"
logger.warning(msg)
return {
'success_count': success_count,
'fail_count': fail_count
}
# Excel Handler
if upload_method == 'excel':
# create a Pandas Dataframe to store Excel Data
df = pd.read_excel(file)
row_count = len(df)
user_input = input(
"You are about to create %s new user accounts. Are you sure you'd like to continue? (yes/no): "
% row_count)
if user_input == "yes":
if row_count > 10:
payload = list()
# generate payload
for row in df.itertuples():
payload_tuple = (row._1 + ' ' + row._2, row.Email,
group_name)
payload.append(payload_tuple)
self.create_users_with_thread(payload)
else:
# Todo: is there a better way to iterate through DataFrame rows?
for row in df.itertuples():
create_user_response = self.create_user(
row._1 + row._2, row.Email, group_name)
if create_user_response:
success_count += 1
else:
fail_count += 1
else:
logger.info("User chose not to create accounts")
# JSON Handler
elif upload_method == 'json':
with open(file) as json_file:
data = json.load(json_file)
row_count = len(data)
user_input = input(
"You are about to create %s new user accounts. Are you sure you'd like to continue? (yes/no): "
% row_count)
if user_input == "yes":
if row_count > 10:
payload = list()
for current_user in data:
payload_tuple = (current_user['first_name'] + ' ' +
current_user['last_name'],
current_user['email'], group_name)
payload.append(payload_tuple)
self.create_users_with_thread(payload)
else:
for current_user in data:
create_user_response = self.create_user(
(current_user['first_name'] + ' ' +
current_user['last_name'],
current_user['email'], group_name))
if create_user_response:
success_count += 1
else:
fail_count += 1
else:
logger.info("User chose not to create accounts")
# PostgreSQL Handler
elif upload_method == 'db':
db = DB()
with db.conn.cursor() as cursor:
cursor.execute(query)
records = cursor.fetchall()
num_rows = cursor.rowcount
user_input = input(
"You are about to create %s new user accounts. Are you sure you'd like to continue? (yes/no): "
% num_rows)
if user_input == "yes":
if num_rows > 10:
payload = list()
for row in records:
payload_tuple = (row[1] + row[2], row[3],
group_name)
payload.append(payload_tuple)
self.create_users_with_thread(payload)
else:
for row in records:
login = row[3]
create_user_response = self.create_user(
row[1] + row[2], login, group_name)
if create_user_response:
success_count += 1
else:
fail_count += 1
else:
logger.info("User chose not to create accounts")
return {'success_count': success_count, 'fail_count': fail_count}
def create_user(self, payload):
"""
Creates a single user
:param name: Name of the user
:param login: what's the login for the user you are creating
:param group_name: which group do you want the user to be assigned to
:return:
"""
# Payload Unpacking
name = payload[0]
login = payload[1]
group_name = payload[2]
success = False
group_id = None
if name == None or login == None: return success
if group_name == None:
group_id = self.get_group_id(group_name)
try:
user = self.client.create_user(name, login)
# TODO: Deal with this later
if group_id != None:
membership_response = self.client.group(
group_id=group_id).add_member(user)
# if an error is throw by the API, handle it by sending to failed_array
# the most common error is that user already exists
except exception.BoxAPIException as e:
msg = "Status Code: %s. %s: <%s>" % (e.status, e.message, login)
logger.error(msg)
return success
else:
msg = "User was successfully created: %s " % user
logger.info(msg)
success = True
return success
def delete_all_users(self, force):
"""
Delete all users at scale. Can not be undone.
:param force:
:return:
"""
success_count = 0
fail_count = 0
users = self.client.users(user_type='all')
for user in users:
# if the current user is accessed, which is also the admin, don't delete it.
if user == self.client.user().get() or user.id in admins: continue
delete_response = self.client.user(user.id).delete(force=force)
if delete_response == True:
msg = 'Deleted: {0} (User ID: {1})'.format(user.name, user.id)
logger.info(msg)
success_count += 1
else:
msg = 'Unable to delete user. %s : %s' % (user.id, user.login)
logger.error(msg)
fail_count += 1
return {'success_count': success_count, 'fail_count': fail_count}
def delete_user(self, email, force):
"""
Delete a single user
:param email:
:param force:
:return:
"""
success = False
user = self.get_user_by_email(email)
if user == None: return success
success = self.client.user(user.id).delete(force=force)
if success:
msg = 'Deleted: {0} (User ID: {1})'.format(user.name, user.id)
logger.info(msg)
else:
msg = 'Unable to delete user. %s : %s' % (user.id, user.login)
logger.error(msg)
return success
def generate_payload(self, upload_method, file, group_name, query):
# Excel Handler
if upload_method == 'excel':
# create a Pandas Dataframe to store Excel Data
df = pd.read_excel(file)
row_count = len(df)
if row_count > 10:
payload = list()
# generate payload
for row in df.itertuples():
payload_tuple = (row._1 + ' ' + row._2, row.Email,
group_name)
payload.append(payload_tuple)
# self.create_users_with_thread(payload)
# JSON Handler
elif upload_method == 'json':
with open(file) as json_file:
data = json.load(json_file)
row_count = len(data)
if row_count > 10:
payload = list()
for current_user in data:
payload_tuple = (current_user['first_name'] + ' ' +
current_user['last_name'],
current_user['email'], group_name)
payload.append(payload_tuple)
# self.create_users_with_thread(payload)
# PostgreSQL Handler
elif upload_method == 'db':
db = DB()
with db.conn.cursor() as cursor:
cursor.execute(query)
records = cursor.fetchall()
num_rows = cursor.rowcount
if num_rows > 10:
payload = list()
for row in records:
payload_tuple = (row[1] + row[2], row[3], group_name)
payload.append(payload_tuple)
# self.create_users_with_thread(payload)
return payload
def create_users_with_thread(self, payload):
print("Begin Threading Operation")
with ThreadPoolExecutor(max_workers=3) as executors:
for _ in executors.map(self.create_user, payload):
print("Thread Executor")
# Common Group Methods
def create_groups(self, logger, group_name):
if self.is_a_group(self.client, group_name):
logger.warning('Group already exists.')
else:
response = self.client.create_group(group_name)
def is_a_group(self, group_to_check):
"""
returns whether a group is a present in the enterprise
:param group_to_check:
:return:
"""
groups = self.client.get_groups(group_to_check)
list_of_groups = []
for group in groups:
list_of_groups.append(group.name)
if group_to_check in list_of_groups:
return True
else:
return False
def get_group_id(self, group_name):
"""
Returns the group id as an int by searching for the group name
:param group_name:
:return: int
"""
group_id = None
groups = self.client.get_groups(group_name)
for group in groups:
if group.name == group_name:
group_id = group.id
return group_id
return group_id
# Common Upload Methods
def upload_single_file(self, source, destination_folder_id):
response = self.client.folder(
folder_id=destination_folder_id).upload(source)
return response
def upload_all_files_from_directory(self, source, destination_folder_id):
# 1. Check if the path exists
if not (os.path.exists(source)):
print("Path doesn't exist.")
return 0
content = []
# 2. Get all files in directory
for path, subdirs, files in os.walk(source):
for name in files:
content.append(os.path.join(path, name))
for file in content:
print(file)
self.upload_single_file(
source=file, destination_folder_id=destination_folder_id)
# Common Folder Methods
def get_items_in_folder(self, folder_id):
items_dict = dict()
items = self.client.folder(folder_id).get_items()
for item in items:
items_dict[item.id] = item.name
return items_dict
from flask import Flask
import config_jwt
import requests
import logging
app = Flask(__name__)
# Configure JWT auth and fetch access token
auth = JWTAuth(
client_id=config_jwt.client_id,
client_secret=config_jwt.client_secret,
enterprise_id=config_jwt.enterprise_id,
jwt_key_id=config_jwt.jwt_key_id,
rsa_private_key_file_sys_path=config_jwt.private_key_path,
rsa_private_key_passphrase=config_jwt.private_key_passphrase
)
access_token = auth.authenticate_instance()
BOX_USER_NAME = config_jwt.user_name
FOLDER_ID = config_jwt.folder_id
client = Client(auth)
users = client.users(filter_term=BOX_USER_NAME)
box_user = users[0] if users else client.create_user(BOX_USER_NAME)
root_folder = client.as_user(box_user).folder(folder_id=FOLDER_ID).get()
print 'folder owner: ' + root_folder.owned_by['login']
print 'folder name: ' + root_folder['name']
client.as_user(box_user).folder(folder_id=FOLDER_ID).rename('Tax Rename')
rsa_private_key_passphrase = app_auth['passphrase']
)
client = Client(sdk)
print("Client: " + str(client) + "\n")
current_user = client.user().get()
######################################################################
######################################################################
######## Enter a name for the app user. This should match the
######## name of the app in the script is using from the
######## Box dev console
new_app_user = client.create_user('<name of app user>', login=None)
print(str(new_app_user) +"\n\n")
print("Current user login: "******"\n\n")
print("Current user id:" + str(new_app_user.id) + "\n\n")
output_file = open("New App user login info.txt", "w+")
output_file.write("User credentials for accessing Box folders. Add this user by email as a collaborator in the Box folder you want your app to have access to\n")
output_file.write("App user login: "******"\n")
class Box(object):
_CLIENT_ID = Configuration.CLIENT_ID
_CLIENT_SECRET = Configuration.CLIENT_SECRET
_ENTERPRISE_ID = Configuration.ENTERPRISE_ID
_PASSPHRASE = Configuration.PASSPHRASE
def __init__(self):
self._db_engine = sqlalchemy.create_engine('sqlite+pysqlite:///photobooth.db')
self._session_maker = sessionmaker(bind=self._db_engine, autoflush=True)
self._session = self._session_maker()
DeclarativeBase.metadata.create_all(self._db_engine)
self._auth = JWTAuth(
client_id=self._CLIENT_ID,
client_secret=self._CLIENT_SECRET,
enterprise_id=self._ENTERPRISE_ID,
rsa_private_key_file_sys_path='private_key.pem',
rsa_private_key_passphrase=self._PASSPHRASE,
)
self._client = Client(self._auth)
try:
user_id = self._session.query(PhotoBoothInfo).filter_by(key='user_id').one().value
from boxsdk.object.user import User
self._upload_user = User(None, user_id)
except NoResultFound:
self._upload_user = self._client.create_user('Photobooth Uploader')
self._session.add(PhotoBoothInfo(key='user_id', value=self._upload_user.object_id))
self._session.commit()
self._uploader_auth = JWTAuth(
client_id=self._CLIENT_ID,
client_secret=self._CLIENT_SECRET,
enterprise_id=self._ENTERPRISE_ID,
rsa_private_key_file_sys_path='private_key.pem',
rsa_private_key_passphrase=self._PASSPHRASE,
)
self._uploader_auth.authenticate_app_user(self._upload_user)
self._uploader = Client(self._uploader_auth)
try:
folder_id = self._session.query(PhotoBoothInfo).filter_by(key='folder_id').one().value
self._folder = self._uploader.folder(folder_id)
except NoResultFound:
self._folder = self._uploader.folder('0').create_subfolder('Photobooth Images')
self._session.add(PhotoBoothInfo(key='folder_id', value=self._folder.object_id))
self._session.commit()
def upload_photo(self, name, message, photo_sys_path):
print 'uploading photo ', photo_sys_path, ' to box'
photo = self._folder.upload(photo_sys_path)
photo.metadata().create({
'name': name,
'message': message,
})
def download_photo(self, file_id, photo_sys_path):
print 'downloading photo ', photo_sys_path, ' from box'
with open(photo_sys_path, 'wb') as file_handle:
self._client.file(file_id).download_to(file_handle)
def list_files(self):
return self._folder.get_items(1000)