def user_detail(user_id):
print '### Sending detail view ###'
client = Client(g.auth, network_layer=customLogger)
user = client.user(user_id=user_id).get()
# As an admin, we can act on behalf of other users by creating new auth and client objects.
# We should also be caching this token. For the purposes of this quickstart
# we only cache access for one user (the admin).
print "AUTHENTICATING USER: "******" (" + user.name + ")"
user_auth = JWTAuth(client_id=app.config['CLIENT_ID'],
client_secret=app.config['CLIENT_SECRET'],
enterprise_id=app.config['EID'],
jwt_key_id=app.config['KEY_ID'],
rsa_private_key_file_sys_path=os.path.join(os.path.dirname(__file__),'rsakey.pem'))
user_auth.authenticate_app_user(user) # <--- Authenticate as the user
user_client = Client(user_auth)
# Make API calls as the user by using the user_client object
files = user_client.folder(folder_id='0').get_items(limit=100)
# Build the preview link into any files sent to the client
for f in files:
if f._item_type=="file":
f.preview_url = f.get(fields=['expiring_embed_link']).expiring_embed_link['url']
token = user_auth.access_token
return render_template("user_detail.html",
user=user,
files_list=files,
token=token)
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')
#file_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'file.txt')
#print(os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'media'))
me = ned_client.user(user_id='me').get()
print 'user_login: '******'login']
print 'uname: ' + me['name']
loan_folder = ned_client.folder(folder_id='0').create_subfolder(
str(me['name'] + ' - Loan Application'))
upload_path = os.path.join(
os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'media')
print "AppUsers:"
print appusers
print '-' * 80
user_auth = JWTAuth(
client_id=client_id,
client_secret=client_secret,
enterprise_id=enterprise_id,
jwt_key_id=jwt_key_id,
rsa_private_key_file_sys_path=rsakey_filename,
rsa_private_key_passphrase=rsakey_passphrase,
network_layer=logger,
)
print '-' * 80
for u in appusers:
user = client.user(user_id=u.id).get()
print "AUTHENTICATING USER: "******" (" + user['name'] + ")"
user_auth.authenticate_app_user(user) # <--- Authenticate as the user
print '-' * 80
user_client = Client(user_auth)
print user_auth.access_token
print '-' * 80
print '-' * 80
print 'SCRIPT EXECUTION COMPLETE'
print "--- Completed execution in %s seconds ---" % (time.time() - start_time)
print '-' * 80
result = float(value) / float(100)
return result
auth = JWTAuth(
client_id='dc100pf8a6yorgujddbdi56twd1a6r4k',
client_secret='XMIooxaNZwXFevSUbU94luaeQ9VwkPVv',
enterprise_id='37228416',
jwt_key_id='ir6fahr5',
rsa_private_key_file_sys_path='c:/temp/BOXPrivatekey/private.pem')
client = Client(auth)
dexafituser = client.user('3164793504')
auth.authenticate_app_user(dexafituser)
'''
file_id='270819570112'
url = client.file(file_id).content()
#url = client.file(file_id='270819570112').content()
#print(url)
with BytesIO(url) as dcmbox:
dcm_file = pydicom.dcmread(dcmbox)
#print (dcm_file)
file_destination="c:/temp/"+file_id+".dcm"
#pydicom.dcmwrite("c:/temp/altered_file.dcm", dcm_file)
pydicom.dcmwrite(file_destination, dcm_file)
client_id=config.client_id,
client_secret=config.client_secret,
enterprise_id=config.enterprise_id,
jwt_key_id=config.jwt_key_id,
rsa_private_key_file_sys_path=config.rsa_private_key_file_sys_path
)
# Create an authenticated client that can interact with the Box Content API
client = Client(oauth)
user_id = config.user_id
base_folder_id = config.base_folder_id
owner = client.user(user_id=user_id)
oauth.authenticate_app_user(owner)
folder_prefix = config.folder_prefix
folder_prefix_len = len(folder_prefix)
folder_suffix = config.folder_suffix
folder_suffix_len = len(folder_suffix)
folder_prefix2 = folder_prefix.replace("(", "[") # to test for Brackets instead of paren's
folder_prefix2 = folder_prefix2.replace(")", "]")
def pretty_print(folder_name, nest_level):
string = ''
for i in xrange(0, nest_level):
string += ' '
return string + "/" + folder_name
from boxsdk import JWTAuth
from boxsdk import Client
# Configure JWT auth object
sdk = JWTAuth(
client_id="xx",
client_secret="xx",
enterprise_id="xx",
jwt_key_id="xx",
rsa_private_key_file_sys_path="/xx/private_key_product.cfg",
rsa_private_key_passphrase="xx",
)
# Get auth client
client = Client(sdk)
ev_user=client.user(user_id='xx')
sdk.authenticate_app_user(ev_user)
ev_client = Client(sdk)
# PERFORM API ACTIONS WITH CLIENT
root_folder = ev_client.folder(folder_id='xx')
#shared_folder = root_folder.create_subfolder('shared_folder_xx')
uploaded_file = root_folder.upload('LocalTestUrl.html')
#shared_link = shared_folder.get_shared_link()
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)
