def update_document_permissions(api_client,
exchange_id,
document_id,
add_permissions=None,
revoke_permissions=None):
xml_data = ['<permissionsUpdateRequest><permissionUpdate>']
xml_data.append(to_xml({
'id': document_id,
'type': 'DOCUMENT'
}, 'entityId'))
if add_permissions:
for p in add_permissions:
xml_data.append(to_xml(p, 'permissionInfo'))
if revoke_permissions:
for p in revoke_permissions:
p = p.copy()
p['permission'] = 'REVOKED'
p['drm'] = 'NONE'
xml_data.append(to_xml(p, 'permissionInfo'))
xml_data.append('</permissionUpdate></permissionsUpdateRequest>')
response = api_client.update('/services/workspaces/permissions',
params={'workspaceId': exchange_id},
data={'xml': ''.join(xml_data)},
api_version=1)
response.check(200, 'text/xml')
data = response.data()
return data
def update_group(api_client, exchange_id, group, remove_group_members=None, add_group_members=None):
data = [
'<workspaceGroupUpdateRequest>',
to_xml(group, ['workspaceGroup'])
]
if remove_group_members is not None and len(remove_group_members) > 0:
data.append(to_xml(remove_group_members, ['workspaceUser', 'removeWorkspaceUsers']))
if add_group_members is not None and len(add_group_members) > 0:
data.append(to_xml(add_group_members, ['workspaceUser', 'addWorkspaceUsers']))
data.append('</workspaceGroupUpdateRequest>')
response = api_client.update(
'/v1/services/workspaces/workspaceGroups',
params={
'workspaceId':exchange_id,
'workspaceGroupId':group['id']
},
data={'xml':''.join(data)},
api_version=1
)
response.check(200, 'text/xml')
data = response.data()
return get_node_as_item(data, ('workspaceGroups', 'workspaceGroupPartial'))
def login(api_client, email, password):
"""
How to allow concurrent login?
"""
timestamp = time.time()
response = api_client.create(
'/v1/ILCGLServices/session',
data={
'xml':
to_xml(
{
'email': email,
'password': password,
'apiKey': api_client.config.api_key
}, 'createSession')
},
authenticated=False,
api_version=1)
response.assert_status_code(200)
response.assert_content_type('text/xml')
data = response.data()
if api_client.session is None:
api_client.session = intralinks.api.v1.Session()
try:
response.assert_no_errors(200)
api_client.session.session_id = data['ssoSessionId']
api_client.session.timestamp = timestamp
api_client.session.email = email
api_client.password = None
api_client.session.is_secureid_required = False
api_client.session.is_already_logged_in = False
except Exception as e:
status = data['status']
if 'subcode' in status:
if status['subcode'] == '011': # secure id required
api_client.session.email = email
api_client.session.password = password
api_client.session.is_secureid_required = True
raise SecureIdRequiredException()
elif status['subcode'] == '018': # concurrent login
api_client.session.email = email
api_client.session.password = password
api_client.session.is_already_logged_in = True
raise AlreadyLoggedInException()
raise e
return data
def update_exchange(api_client, exchange, is_phase_updated=False):
if is_phase_updated:
data = {
k: v
for k, v in exchange.items() if k in
{'workspaceName', 'phase', 'host', 'version', 'id', 'description'}
}
else:
# if phase has not been updated and phase is posted to server, then error: <message>Phase updation failed</message><subcode>6-22</subcode>
data = {
k: v
for k, v in exchange.items()
if k in {'workspaceName', 'host', 'version', 'id', 'description'}
}
response = api_client.update(
'/services/workspaces',
params={'workspaceId': exchange['id']},
data={'xml': to_xml(data, ['workspace', 'workspaceUpdateRequest'])},
api_version=1)
response.check(200, 'text/xml')
data = response.data()
return data
def special_login(api_client,
email,
password,
secure_id=None,
end_other_sessions=False):
timestamp = time.time()
response = api_client.create(
'/services/logon',
data={
'xml':
to_xml(
{
'username': email,
'password': password,
'securID': secure_id,
'continueMultiLogon': end_other_sessions
}, 'logonRequest')
},
authenticated=False,
api_version=1)
response.check(200, 'text/xml')
data = response.data()
if api_client.session is None:
api_client.session = intralinks.api.v1.Session()
api_client.session.session_id = data['sessionId']
api_client.session.timestamp = timestamp
return data
def create_exchange_member(api_client,
exchange_id,
exchange_member=None,
groups=None):
exchange_member_data = entity_to_dict(exchange_member)
user_data = entity_to_dict(exchange_member_data.pop('user', dict()))
exchange_member_data.update(user_data)
data = {'workspaceUsers': {'workspaceUser': exchange_member_data}}
if groups is not None and len(groups) > 0:
data['workspaceGroups'] = {'workspaceUserGroup': []}
for g in groups:
data['workspaceGroups']['workspaceUserGroup'] = {
'emailIds': {
'emailId': exchange_member_data['user']
},
'workspaceGroupId': g['id']
}
response = api_client.create(
'/v1/services/workspaces/workspaceUsers',
params={'workspaceId': exchange_id},
data={'xml': to_xml(data, ['workspaceUserCreateRequest'])},
api_version=1)
response.check(200, 'text/xml')
data = response.data()
return get_node_as_item(data,
('workspaceUserPartials', 'workspaceUserPartial'))
def create_documents(api_client, exchange_id, documents, batch_id=None):
#keys = {'name', 'parentId', 'note', 'effectiveDate'}
created_documents = [entity_to_dict(d) for d in documents]
xml_data = ['<documentCreateRequest>']
for f in created_documents:
xml_data.append(to_xml(f, ['document', 'documentCreate']))
xml_data.append('</documentCreateRequest>')
response = api_client.create('/services/workspaces/documents',
params={
'workspaceId': exchange_id,
'batchId': batch_id,
},
data={'xml': ''.join(xml_data)},
api_version=1)
response.check(200, 'text/xml')
data = response.data()
return get_node_as_list(data, 'documentPartial')
def create_user_account(api_client, user):
user_data = entity_to_dict(user)
response = api_client.create(
'/services/users',
data={'xml': to_xml(user_data, ['user', 'userRequest'])},
api_version=1)
response.check(200, 'text/xml')
data = response.data()
return data
def enter_exchange(api_client, exchange_id, accept_splash=None):
response = api_client.create('/services/workspaces/entry',
params={'workspaceId': exchange_id},
data={
'xml':
to_xml({'acceptSplash': accept_splash},
'workspaceEntryRequest')
},
api_version=1)
data = response.data()
return get_node_as_item(data, 'state')
def update_folder(api_client, exchange_id, folder):
folder_data = entity_to_dict(folder)
response = api_client.update(
'/v1/services/workspaces/folders',
params={'workspaceId': exchange_id},
data={'xml': to_xml(folder_data, ['folder', 'folderUpdateRequest'])},
api_version=1)
response.check(200, 'text/xml')
data = response.data()
return get_node_as_item(data, 'folderPartial')
def set_custom_alerts(api_client, custom_alert):
response = api_client.create(
'/services/customAlerts',
data={
'xml':
to_xml({'customAlerts': {
'customAlert': custom_alert
}}, 'customAlertCreateRequest')
},
api_version=1)
response.check(200, 'text/xml')
data = response.data()
return data
def create_document(api_client,
exchange_id,
document,
file=None,
permissions=None,
batch_id=None):
document_data = entity_to_dict(document)
data = {'document': document_data}
if permissions:
if isinstance(permissions, list):
data['permissions'] = {
'permissioned': [{
'permissionInfo': p
} for p in permissions]
}
else:
data['permissions'] = {
'permissioned': {
'permissionInfo': permissions
}
}
files = {
'documentFile':
(os.path.basename(file.name), file, 'application/octet-stream')
} if file is not None else None
response = api_client.create(
'/services/workspaces/documents',
params={
'workspaceId': exchange_id,
'batchId': batch_id,
},
data={
'xml':
''.join(to_xml(data, ['documentCreate', 'documentCreateRequest']))
},
files=files,
api_version=1)
response.check(200, 'text/xml')
data = response.data()
return get_node_as_item(data, 'documentPartial')
def create_group(api_client, exchange_id, group):
group_data = entity_to_dict(group)
response = api_client.create(
'/v1/services/workspaces/workspaceGroups',
params={
'workspaceId':exchange_id
},
data={'xml':to_xml(group_data, ['workspaceGroup', 'workspaceGroups', 'workspaceGroupCreateRequest'])},
api_version=1
)
response.check(200, 'text/xml')
data = response.data()
return get_node_as_item(data, ('workspaceGroups', 'workspaceGroupPartial'))
def update_exchange_settings(api_client, exchange_id, settings):
response = api_client.update(
'/v1/services/workspaces/workspaceSettings',
params={'workspaceId': exchange_id},
data={
'xml':
to_xml(settings, [
'workspaceSetting', 'workspaceSettings',
'workspaceSettingsUpdateRequest'
])
},
api_version=1)
response.check(200, 'text/xml')
data = response.data()
return data
def update_document(api_client,
exchange_id,
document,
file=None,
permissions=None):
document_data = entity_to_dict(document)
data = {'document': document_data}
if permissions:
if isinstance(permissions, list):
data['permissions'] = {
'permissioned': [{
'permissionInfo': p
} for p in permissions]
}
else:
data['permissions'] = {
'permissioned': {
'permissionInfo': permissions
}
}
files = {
'documentFile':
(os.path.basename(file.name), file, 'application/octet-stream')
} if file is not None else None
response = api_client.update(
'/services/workspaces/documents',
params={'workspaceId': exchange_id},
data={'xml': ''.join(to_xml(data, 'documentUpdateRequest'))},
files=files,
api_version=1)
response.assert_status_code(200)
response.assert_content_type('text/xml')
response.assert_no_errors()
data = response.data()
return get_node_as_item(data, 'documentPartial')
def create_folders(api_client, exchange_id, folders):
created_folders = [entity_to_dict(f) for f in folders]
xml_data = ['<folderCreateRequest>']
for f in created_folders:
xml_data.append(to_xml(f, ['folder', 'folderCreate']))
xml_data.append('</folderCreateRequest>')
response = api_client.create('/v1/services/workspaces/folders',
params={'workspaceId': exchange_id},
data={'xml': ''.join(xml_data)},
api_version=1)
response.check(200, 'text/xml')
data = response.data()
return get_node_as_list(data, 'folderPartial')
def create_exchange(api_client, exchange, suppress_welcome_alert=True):
exchange_data = {
'name' if k == 'workspaceName' else k: v
for k, v in entity_to_dict(exchange).items()
}
exchange_data['suppressWelcomeAlert'] = suppress_welcome_alert
response = api_client.create(
'/services/workspaces',
data={
'xml':
to_xml(exchange_data,
['workspacesToCreate', 'workspaceCreateRequest'])
},
api_version=1)
response.check(200, 'text/xml')
data = response.data()
return get_node_as_item(data, 'workspacePartial')
def update_exchange_member(api_client,
exchange_id,
exchange_member,
add_groups=None,
remove_groups=None):
keys = [
'userId', 'id', 'firstName', 'lastName', 'organization', 'version',
'roleType', 'keyContact', 'qnaCoordinator', 'qnaAttributes'
]
data = {k: exchange_member[k] for k in keys if k in exchange_member}
for k in keys:
if k not in data:
data[k] = ''
xml_data = {'workspaceUsers': {'workspaceUser': data}}
if add_groups is not None and len(add_groups) > 0:
xml_data['addWorkspaceGroups'] = [{
'workspaceGroupId': g['id']
} for g in add_groups]
if remove_groups is not None and len(remove_groups) > 0:
xml_data['removeWorkspaceGroups'] = [{
'workspaceGroupId': g['id']
} for g in remove_groups]
response = api_client.update(
'/v1/services/workspaces/workspaceUsers',
params={
'workspaceId': exchange_id,
'workspaceUserId': exchange_member['id']
},
data={'xml': to_xml(xml_data, 'workspaceUserUpdateRequest')},
api_version=1)
data = response.data()
return data
def delete_exchange_members(api_client, exchange_id, exchange_members):
deleted_exchange_members = [{
'id': m['id'],
'version': m['version'],
'type': 'WORKSPACEUSER'
} for m in exchange_members]
response = api_client.delete(
'/v1/services/workspaces/workspaceUsers',
params={'workspaceId': exchange_id},
data={
'xml':
to_xml(deleted_exchange_members,
['entityId', 'workspaceUserDeleteRequest'])
},
api_version=1)
response.check(200, 'text/xml')
data = response.data()
return data
def delete_groups(api_client, exchange_id, groups, remove_users=False):
deleted_groups = [
{
'id':g['id'],
'version':g['version'],
'type':'WORKSPACEGROUP'
} for g in groups
]
response = api_client.delete(
'/v1/services/workspaces/workspaceGroups',
params={
'workspaceId':exchange_id,
'removeUsers':remove_users
},
data={'xml':to_xml(deleted_groups, ['entityId', 'workspaceGroupDeleteRequest'])},
api_version=1
)
response.check(200, 'text/xml')
data = response.data()
return data
def delete_documents(api_client, exchange_id, documents):
deleted_documents = [{
'id': g['id'],
'version': g['version'],
'type': 'DOCUMENT'
} for g in documents]
response = api_client.delete(
'/v1/services/workspaces/folders/items',
params={
'workspaceId': exchange_id,
'deleteFolderContents': True
},
data={
'xml':
to_xml(deleted_documents, ['entityId', 'folderItemsDeleteRequest'])
},
api_version=1)
response.check(200, 'text/xml')
data = response.data()
return data
