def update_exchange_member(api_client, exchange_id, exchange_member):
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)
exchange_member_data = filter_dict(exchange_member_data,
remove_fields={
'userId', 'emailId', 'firstName',
'lastName', 'title', 'organization',
'officePhone', 'languagePref'
})
# Fix because the V2 API does not return 'unauthenticatedDocumentAccess' as a boolean
if 'unauthenticatedDocumentAccess' in exchange_member_data and exchange_member_data[
'unauthenticatedDocumentAccess'] in {'T', 'F'}:
exchange_member_data[
'unauthenticatedDocumentAccess'] = exchange_member_data[
'unauthenticatedDocumentAccess'] == 'T'
response = api_client.update('/v2/workspaces/{}/users'.format(exchange_id),
data=json.dumps(
{'users': [exchange_member_data]}),
headers={'Content-Type': 'application/json'},
api_version=2)
response.check(202, 'application/json')
data = response.data()
return get_node_as_item(data, ['userPartials'])
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_exchange_member(self,
exchange,
exchange_member,
alert=None,
update_param=True):
exchange_id = self._get_id(exchange)
if self.api_client.is_v1() or self.use_v1:
result = intralinks.functions.v1.exchange_members.create_exchange_member(
self.api_client, exchange_id, exchange_member)
else:
result = intralinks.functions.v2.exchange_members.create_exchange_member(
self.api_client, exchange_id, exchange_member, alert)
if update_param:
if isinstance(exchange_member, tuple):
exchange_member = entity_to_dict(exchange_member)
user = exchange_member.pop('user')
if isinstance(user, tuple):
user = entity_to_dict(user)
exchange_member.update(user)
exchange_member['emailId'] = result.pop('email')
exchange_member.update(result)
return exchange_member
else:
return result
def update_exchange(api_client, exchange, is_phase_updated=False):
data = entity_to_dict(exchange)
exchange_id = data['id']
if is_phase_updated:
data = filter_dict(data,
remove_fields=[
'id', 'parentTemplateId', 'actions',
'securityLevel', 'type', 'pvpEnabled',
'htmlViewEnabled', 'location'
])
else:
data = filter_dict(data,
remove_fields=[
'id', 'parentTemplateId', 'phase', 'actions',
'securityLevel', 'type', 'pvpEnabled',
'htmlViewEnabled', 'location'
])
data['name'] = data.pop('workspaceName')
response = api_client.update('/v2/workspaces/{}'.format(exchange_id),
data=json.dumps(data),
headers={'Content-Type': 'application/json'},
api_version=2)
response.check(202, 'application/json')
data = response.data()
return data
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 update_group(api_client,
exchange_id,
group,
remove_group_members=None,
add_group_members=None):
group_data = entity_to_dict(group)
group_id = group_data['id']
group_data = filter_dict(group_data,
remove_fields={
'id', 'groupMemberCount', 'lastModifiedOn',
'lastModifiedBy', 'createdOn', 'createdBy'
})
response = api_client.update('/v2/workspaces/{}/groups/{}'.format(
exchange_id, group_id),
data=json.dumps(group_data),
headers={'Content-Type': 'application/json'},
api_version=2)
response.check(202, 'application/json')
data = response.data()
return get_node_as_item(data, 'groupPartials')
def _update_param(self, entity, result, update_param=True):
if update_param:
if isinstance(entity, tuple):
entity = entity_to_dict(entity)
entity.update(result)
return entity
else:
return result
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 _update_param_as_list(self, entities, result, update_param=True):
if update_param:
new_entities = []
for e, r in zip(entities, result):
if isinstance(e, tuple):
e = entity_to_dict(e)
new_entities.append(e)
e.update(r)
return new_entities
else:
return result
def update_document(api_client, exchange_id, document):
document_data = entity_to_dict(document)
response = api_client.update(
'/v2/workspaces/{}/documents'.format(exchange_id),
data=json.dumps({'documents': [document_data]}),
headers={'Content-Type': 'application/json'},
api_version=2)
response.check(202, 'application/json')
data = response.data()
return get_node_as_item(data, 'documentPartial')
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 create_group(api_client, exchange_id, group):
group_data = entity_to_dict(group)
response = api_client.create(
'/v2/workspaces/{}/groups'.format(exchange_id),
data=json.dumps(group_data),
headers={'Content-Type': 'application/json'},
api_version=2)
response.check(201, 'application/json')
data = response.data()
return get_node_as_item(data, 'groupPartials')
def create_exchange_member(api_client,
exchange_id,
exchange_member=None,
alert=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)
exchange_member_data = filter_dict(
exchange_member_data,
remove_fields={'languagePref', 'unauthenticatedDocumentAccess'})
exchange_member_data['sendAlert'] = alert is not None
if alert is None:
exchange_member_data['sendAlert'] = False
else:
exchange_member_data['sendAlert'] = True
alert_data = entity_to_dict(alert)
alert_data['saveAlertSettings'] = True
exchange_member_data['welcomeAlertDetails'] = alert_data
response = api_client.create('/v2/workspaces/{}/users'.format(exchange_id),
data=json.dumps(
{'users': [exchange_member_data]}),
headers={'Content-Type': 'application/json'},
api_version=2)
response.check(201, 'application/json')
data = response.data()
return get_node_as_item(data, ['userPartials'])
def create_documents(api_client, exchange_id, documents, batch_id=None):
document_data = [{'document': entity_to_dict(d)} for d in documents]
response = api_client.create(
'/v2/workspaces/{}/documents'.format(exchange_id),
params={'batch_id': batch_id},
data=json.dumps({'documents': document_data}),
headers={'Content-Type': 'application/json'},
api_version=2)
response.check(201, 'application/json')
data = response.data()
return get_node_as_list(data, 'documentPartial')
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 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('/v2/workspaces',
data=json.dumps(
{'workspaces': [exchange_data]}),
headers={'Content-Type': 'application/json'},
api_version=2)
response.check(201, 'application/json')
data = response.data()
return get_node_as_item(data, 'workspacePartial')
def create_folders(api_client, exchange_id, folders):
folders_data = [{'folder':entity_to_dict(f)} for f in folders]
response = api_client.create(
'/v2/workspaces/{}/folders'.format(exchange_id),
data=json.dumps({'folders':folders_data}),
headers={'Content-Type':'application/json'},
api_version=2
)
response.check(201, 'application/json')
data = response.data()
l = get_node_as_list(data, 'folderPartial')
convert_to_bool(l, 'hasNote')
return l
def create_exchange(self,
exchange,
suppress_welcome_alert=True,
update_param=True):
if self.api_client.is_v1() or self.use_v1:
result = intralinks.functions.v1.exchanges.create_exchange(
self.api_client, exchange, suppress_welcome_alert)
else:
result = intralinks.functions.v2.exchanges.create_exchange(
self.api_client, exchange, suppress_welcome_alert)
if update_param:
exchange = entity_to_dict(exchange)
exchange.update(result)
exchange['id'] = exchange.pop('workspaceId')
return exchange
else:
return result
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 update_folder(api_client, exchange_id, folder):
folder_data = entity_to_dict(folder)
folder_data = filter_dict(folder_data, remove_fields={'isEmailin', 'versionNumber', 'isFavorite', 'lastModifiedBy', 'lastModifiedOn', 'createdBy', 'createdOn', 'hasChildFolders', 'orderNumber', 'indexNumber'})
response = api_client.update(
'/v2/workspaces/{}/folders'.format(exchange_id),
data=json.dumps({'folders':[folder_data]}),
headers={'Content-Type':'application/json'},
api_version=2
)
response.check(202, 'application/json')
data = response.data()
result = get_node_as_item(data, 'folderPartial')
if 'hasNote' in result and result['hasNote'] in {'T', 'F'}:
result['hasNote'] = result['hasNote'] == 'T'
return result
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 copy_memberships(self, from_user, to_user):
from_email = from_user if isinstance(from_user,
str) else from_user['emailId']
if isinstance(to_user, str):
to_user = self.il.get_user_account(to_user, exchange_id=None)
elif isinstance(to_user, tuple):
to_user = entity_to_dict(to_user)
df = self.dataframe[self.dataframe['intralinks_user.emailId'].astype(
str).str.lower() == from_email.lower()]
df = df.fillna('')
df = df.sort_values(['exchange.workspaceName', 'group.groupName'])
df = df.reset_index()
df = df[[
'exchange.id', 'exchange.workspaceName',
'exchange_member.roleType', 'group.groupName'
]]
df = df.drop_duplicates()
df.columns = ['Exchange ID', 'Exchange Name', 'Role', 'Group']
df['First Name'] = to_user['firstName']
df['Last Name'] = to_user['lastName']
df['Email'] = to_user['emailId']
df['Organization'] = to_user['organization']
df['Phone'] = '0000'
df = df[[
'First Name', 'Last Name', 'Email', 'Phone', 'Organization',
'Exchange ID', 'Exchange Name', 'Role', 'Group'
]]
file_name = 'data/{}_{}.xlsx'.format(
to_user['emailId'],
datetime.datetime.today().strftime('%Y%m%d_%H%M%S'))
df.to_excel(file_name, index=False)
print('Saved to {}'.format(file_name))
return df
