def collaboration_invites_preview():
data = current_request.get_json()
message = data.get("message", None)
intended_role = data.get("intended_role", "member")
collaboration = Collaboration.query.get(int(data["collaboration_id"]))
confirm_collaboration_admin(collaboration.id)
user = User.query.get(current_user_id())
invitation = munchify({
"user": user,
"collaboration": collaboration,
"intended_role": intended_role,
"message": message,
"hash": generate_token(),
"expiry_date": default_expiry_date(data)
})
html = mail_collaboration_invitation({
"salutation": "Dear",
"invitation": invitation,
"base_url": current_app.app_config.base_url,
"wiki_link": current_app.app_config.wiki_link,
}, collaboration, [], preview=True)
return {"html": html}, 201
def approve_join_request():
join_request_hash = current_request.get_json()["hash"]
join_request = _get_join_request(join_request_hash)
collaboration = join_request.collaboration
confirm_collaboration_admin(collaboration.id)
user_id = join_request.user.id
if collaboration.is_member(user_id):
raise Conflict(f"User {join_request.user.name} is already a member of {collaboration.name}")
mail_accepted_declined_join_request({
"salutation": f"Dear {join_request.user.name}",
"base_url": current_app.app_config.base_url,
"administrator": current_user_name(),
"join_request": join_request,
"user": join_request.user},
join_request,
True,
[join_request.user.email])
collaboration_membership = CollaborationMembership(user_id=user_id,
collaboration_id=collaboration.id,
role="member",
created_by=current_user_uid(),
updated_by=current_user_uid())
join_request.status = STATUS_APPROVED
db.session.merge(collaboration_membership)
db.session.merge(join_request)
res = {'collaboration_id': collaboration.id, 'user_id': user_id}
return res, 201
def collaboration_access_allowed(collaboration_id):
try:
confirm_collaboration_admin(collaboration_id)
return {"access": "full"}, 200
except Forbidden:
confirm_collaboration_member(collaboration_id)
return {"access": "lite"}, 200
def delete_group_members(group_id, collaboration_membership_id, collaboration_id):
confirm_collaboration_admin(collaboration_id)
group = Group.query.get(group_id)
group.collaboration_memberships.remove(CollaborationMembership.query.get(collaboration_membership_id))
db.session.merge(group)
return group, 204
def save_group():
data = current_request.get_json()
collaboration_id = data["collaboration_id"]
confirm_collaboration_admin(collaboration_id)
res = create_group(collaboration_id, data)
return res
def resend_service_connection_request(service_connection_request_id):
service_connection_request = ServiceConnectionRequest.query.get(service_connection_request_id)
service = service_connection_request.service
collaboration = service_connection_request.collaboration
confirm_collaboration_admin(collaboration.id)
user = User.query.get(current_user_id())
_do_mail_request(collaboration, service, service_connection_request, True, user)
return {}, 200
def delete_all_group_members(group_id, collaboration_id):
confirm_collaboration_admin(collaboration_id)
group = Group.query.get(group_id)
group.collaboration_memberships = []
db.session.merge(group)
group = Group.query.get(group_id)
return group, 204
def delete_all_services(collaboration_id):
confirm_collaboration_admin(collaboration_id)
collaboration = Collaboration.query.get(collaboration_id)
if collaboration.organisation.services_restricted:
confirm_write_access()
collaboration.services = []
db.session.merge(collaboration)
return None, 204
def unsuspend():
data = current_request.get_json()
collaboration_id = data["collaboration_id"]
confirm_collaboration_admin(collaboration_id)
collaboration = Collaboration.query.get(collaboration_id)
collaboration.last_activity_date = datetime.now()
collaboration.status = STATUS_ACTIVE
db.session.merge(collaboration)
db.session.commit()
return {}, 201
def delete_collaborations_services(collaboration_id, service_id):
confirm_collaboration_admin(collaboration_id)
collaboration = Collaboration.query.get(collaboration_id)
if collaboration.organisation.services_restricted:
confirm_write_access()
collaboration.services.remove(Service.query.get(service_id))
db.session.merge(collaboration)
return {'collaboration_id': collaboration_id, 'service_id': service_id}, 204
def add_collaborations_services():
data = current_request.get_json()
collaboration_id = int(data["collaboration_id"])
confirm_collaboration_admin(collaboration_id)
service_id = int(data["service_id"])
count = connect_service_collaboration(service_id, collaboration_id)
res = {'collaboration_id': collaboration_id, 'service_id': service_id}
return (res, 201) if count > 0 else (None, 404)
def do_add_group_members(data, assert_collaboration_admin):
group_id = data["group_id"]
collaboration_id = data["collaboration_id"]
if assert_collaboration_admin:
confirm_collaboration_admin(collaboration_id)
group = Group.query.get(group_id)
members_ids = data["members_ids"]
for members_id in members_ids:
group.collaboration_memberships.append(CollaborationMembership.query.get(members_id))
db.session.merge(group)
return len(members_ids)
def test_collaboration_admin(self):
admin_collaboration_membership = CollaborationMembership.query \
.join(CollaborationMembership.collaboration) \
.join(CollaborationMembership.user) \
.filter(Collaboration.name == ai_computing_name) \
.filter(User.name == the_boss_name) \
.one()
self.assertEqual("admin", admin_collaboration_membership.role)
with self.app.app_context():
session["user"] = {"uid": "urn:john", "admin": False, "id": admin_collaboration_membership.user_id}
request_context.is_authorized_api_call = False
confirm_collaboration_admin(admin_collaboration_membership.collaboration_id)
def do_add_group_invitations(data):
group_id = data["group_id"]
collaboration_id = data["collaboration_id"]
confirm_collaboration_admin(collaboration_id)
group = Group.query.get(group_id)
invitations_ids = data["invitations_ids"]
for invitation_id in invitations_ids:
group.invitations.append(Invitation.query.get(invitation_id))
db.session.merge(group)
return len(invitations_ids)
def update_group():
data = current_request.get_json()
collaboration_id = int(data["collaboration_id"])
confirm_collaboration_admin(collaboration_id)
collaboration = Collaboration.query.get(collaboration_id)
_assign_global_urn(collaboration, data)
cleanse_short_name(data)
res = update(Group, custom_json=data, allow_child_cascades=False)
auto_provision_all_members_and_invites(res[0])
return res
def do_resend(invitation_id):
invitation = _invitation_query() \
.filter(Invitation.id == invitation_id) \
.one()
confirm_collaboration_admin(invitation.collaboration_id)
invitation.expiry_date = default_expiry_date()
invitation.created_at = datetime.date.today(),
db.session.merge(invitation)
mail_collaboration_invitation({
"salutation": "Dear",
"invitation": invitation,
"base_url": current_app.app_config.base_url,
"wiki_link": current_app.app_config.wiki_link,
"recipient": invitation.invitee_email
}, invitation.collaboration, [invitation.invitee_email])
def update_collaboration():
data = current_request.get_json()
confirm_collaboration_admin(data["id"])
organisation = Organisation.query.get(data["organisation_id"])
_validate_collaboration(data, organisation, new_collaboration=False)
collaboration = Collaboration.query.get(data["id"])
if collaboration.short_name != data["short_name"]:
for group in collaboration.groups:
group.global_urn = f"{organisation.short_name}:{data['short_name']}:{group.short_name}"
db.session.merge(group)
# For updating references like services, groups, memberships there are more fine-grained API methods
return update(Collaboration, custom_json=data, allow_child_cascades=False)
def update_collaboration_membership_role():
client_data = current_request.get_json()
collaboration_id = client_data["collaborationId"]
user_id = client_data["userId"]
role = client_data["role"]
confirm_collaboration_admin(collaboration_id)
collaboration_membership = CollaborationMembership.query \
.filter(CollaborationMembership.collaboration_id == collaboration_id) \
.filter(CollaborationMembership.user_id == user_id) \
.one()
collaboration_membership.role = role
db.session.merge(collaboration_membership)
return collaboration_membership, 201
def delete_collaboration_membership(collaboration_id, user_id):
if current_user_id() != int(user_id):
confirm_collaboration_admin(collaboration_id)
logger = ctx_logger("collaboration_membership_api")
memberships = CollaborationMembership.query \
.filter(CollaborationMembership.collaboration_id == collaboration_id) \
.filter(CollaborationMembership.user_id == user_id) \
.all()
for membership in memberships:
db.session.delete(membership)
logger.info(f"Deleted {len(memberships)} collaboration memberships of {user_id}")
res = {'collaboration_id': collaboration_id, 'user_id': user_id}
return (res, 204) if len(memberships) > 0 else (None, 404)
def update_collaboration_membership_expiry_date():
client_data = current_request.get_json()
collaboration_id = client_data["collaboration_id"]
membership_id = client_data["membership_id"]
membership_expiry_date = client_data.get("expiry_date")
if membership_expiry_date:
membership_expiry_date = datetime.fromtimestamp(client_data["expiry_date"])
confirm_collaboration_admin(collaboration_id)
collaboration_membership = CollaborationMembership.query \
.filter(CollaborationMembership.collaboration_id == collaboration_id) \
.filter(CollaborationMembership.id == membership_id) \
.one()
collaboration_membership.expiry_date = membership_expiry_date
collaboration_membership.status = STATUS_ACTIVE
db.session.merge(collaboration_membership)
return collaboration_membership, 201
def activate():
body = current_request.get_json()
if "collaboration_id" in body:
confirm_collaboration_admin(body["collaboration_id"], org_manager_allowed=False)
elif "organisation_id" in body:
confirm_organisation_admin(body["organisation_id"])
else:
confirm_write_access()
user = User.query.get(body["user_id"])
user.suspended = False
retention = current_app.app_config.retention
user.last_login_date = datetime.datetime.now() - datetime.timedelta(days=retention.allowed_inactive_period_days)
user.suspend_notifications = []
db.session.merge(user)
create_suspend_notification(user, retention, current_app, True)
return {}, 201
def deny_join_request():
join_request_hash = current_request.get_json()["hash"]
rejection_reason = current_request.get_json()["rejection_reason"]
join_request = _get_join_request(join_request_hash)
confirm_collaboration_admin(join_request.collaboration.id)
mail_accepted_declined_join_request({"salutation": f"Dear {join_request.user.name}",
"base_url": current_app.app_config.base_url,
"rejection_reason": rejection_reason,
"administrator": current_user_name(),
"join_request": join_request,
"user": join_request.user},
join_request,
False,
[join_request.user.email])
join_request.status = STATUS_DENIED
join_request.rejection_reason = rejection_reason
db.session.merge(join_request)
return None, 201
def collaboration_invites():
data = current_request.get_json()
collaboration_id = data["collaboration_id"]
confirm_collaboration_admin(collaboration_id)
administrators = data.get("administrators", [])
message = data.get("message", None)
intended_role = data.get("intended_role")
intended_role = "member" if intended_role not in ["admin", "member"] else intended_role
group_ids = data.get("groups", [])
groups = Group.query \
.filter(Group.collaboration_id == collaboration_id) \
.filter(Group.id.in_(group_ids)) \
.all()
collaboration = Collaboration.query.get(collaboration_id)
user = User.query.get(current_user_id())
membership_expiry_date = data.get("membership_expiry_date")
if membership_expiry_date:
membership_expiry_date = datetime.fromtimestamp(data.get("membership_expiry_date"))
for administrator in administrators:
invitation = Invitation(hash=generate_token(), message=message, invitee_email=administrator,
collaboration=collaboration, user=user, status="open",
intended_role=intended_role, expiry_date=default_expiry_date(json_dict=data),
membership_expiry_date=membership_expiry_date, created_by=user.uid)
invitation = db.session.merge(invitation)
invitation.groups.extend(groups)
db.session.commit()
mail_collaboration_invitation({
"salutation": "Dear",
"invitation": invitation,
"base_url": current_app.app_config.base_url,
"wiki_link": current_app.app_config.wiki_link,
"recipient": administrator
}, collaboration, [administrator])
return None, 201
def collaboration_by_id(collaboration_id):
confirm_collaboration_admin(collaboration_id)
collaboration = Collaboration.query \
.options(selectinload(Collaboration.organisation).selectinload(Organisation.services)) \
.options(selectinload(Collaboration.collaboration_memberships).selectinload(CollaborationMembership.user)) \
.options(selectinload(Collaboration.groups).selectinload(Group.collaboration_memberships)
.selectinload(CollaborationMembership.user)) \
.options(selectinload(Collaboration.groups).selectinload(Group.invitations)) \
.options(selectinload(Collaboration.invitations).selectinload(Invitation.user)) \
.options(selectinload(Collaboration.join_requests).selectinload(JoinRequest.user)) \
.options(selectinload(Collaboration.services)) \
.options(selectinload(Collaboration.service_connection_requests)
.selectinload(ServiceConnectionRequest.service)) \
.options(selectinload(Collaboration.service_connection_requests)
.selectinload(ServiceConnectionRequest.requester)) \
.filter(Collaboration.id == collaboration_id).one()
collaboration_json = jsonify(collaboration).json
collaboration_json["invitations"] = [invitation for invitation in collaboration_json["invitations"] if
invitation["status"] == "open"]
return collaboration_json, 200
def delete_join_request(join_request_id):
join_request = JoinRequest.query.get(join_request_id)
confirm_collaboration_admin(join_request.collaboration_id)
if join_request.status == STATUS_OPEN:
raise BadRequest("Join request with status 'open' can not be deleted")
return delete(JoinRequest, join_request_id)
def delete_collaboration(id):
confirm_collaboration_admin(id)
return delete(Collaboration, id)
def delete_service_request_connection(service_connection_request_id):
service_connection_request = ServiceConnectionRequest.query.get(service_connection_request_id)
confirm_collaboration_admin(service_connection_request.collaboration_id)
return delete(ServiceConnectionRequest, service_connection_request_id)
def delete_invitation(invitation_id):
invitation = Invitation.query.filter(Invitation.id == invitation_id).one()
confirm_collaboration_admin(invitation.collaboration_id)
return delete(Invitation, invitation_id)
def delete_group(group_id):
group = Group.query.filter(Group.id == group_id).one()
confirm_collaboration_admin(group.collaboration_id)
return delete(Group, group_id)
