def getProfile(self, id, user):
from girderformindlogger.models.applet import Applet as AppletModel
from girderformindlogger.models.ID_code import IDCode
from bson.errors import InvalidId
if not isinstance(id, ObjectId):
try:
id = ObjectId(id)
except InvalidId:
p = None
if isinstance(id, ObjectId):
p = self.findOne({'_id': id})
if p is None:
ps = IDCode().findProfile(id)
if ps is not None:
ps = [self.profileAsUser(p, user) for p in ps if p is not None]
return (ps[0] if len(ps) == 1 and ps[0] is not None else ps)
else:
from girderformindlogger.models.invitation import Invitation
from girderformindlogger.utility.jsonld_expander import \
oidIffHex
inv = Invitation().findOne(
{'$or': [{
'_id': {
'$in': oidIffHex(id)
}
}, {
'idCode': id
}]})
return (self.profileAsUser(inv, user)
if isinstance(inv, dict) else {})
return (self.profileAsUser(self.load(p['_id'], force=True), user))
def inferRelationships(person):
from girderformindlogger.models.invitation import Invitation
from girderformindlogger.models.profile import Profile
if "schema:knows" not in person:
return (person)
start = deepcopy(person)
for rel in list(person['schema:knows'].keys()):
if rel in DEFINED_RELATIONS.keys():
if "owl:equivalentProperty" in DEFINED_RELATIONS[rel]:
for ep in DEFINED_RELATIONS[rel]["owl:equivalentProperty"]:
if ep not in person['schema:knows']:
person['schema:knows'][ep] = []
for related in person['schema:knows'][rel]:
if related not in person['schema:knows'][ep]:
person['schema:knows'][ep].append(related)
if any([
bool(rp not in start.get('schema:knows', {}).get(rel, []))
for rp in person['schema:knows'][rel]
for rel in list(person['schema:knows'].keys())
]):
newPerson = Profile().load(person['_id'], force=True)
if 'schema:knows' in newPerson:
newPerson['schema:knows'].update(person['schema:knows'])
else:
newPerson['schema:knows'] = person['schema:knows']
Profile().save(
newPerson,
validate=False) if 'userId' in newPerson else Invitation().save(
newPerson, validate=False)
return (person)
def setUserRelationship(self, id, rel, otherId, otherName):
from girderformindlogger.models.invitation import Invitation
from girderformindlogger.utility.jsonld_expander import \
inferRelationships, oidIffHex
user = self.getCurrentUser()
grammaticalSubject = ProfileModel().getProfile(id, user)
gsp = ProfileModel().load(
grammaticalSubject['_id'],
force=True
)
grammaticalSubject = Invitation().load(
grammaticalSubject['_id'],
force=True
) if gsp is None else gsp
print(grammaticalSubject)
if grammaticalSubject is None or not AppletModel().isCoordinator(
grammaticalSubject['appletId'], user
):
raise AccessException(
'You do not have permission to update this user.'
)
appletId = grammaticalSubject['appletId']
grammaticalObject = ProfileModel().getSubjectProfile(
otherId,
otherName,
user
)
if grammaticalObject is None:
grammaticalObject = ProfileModel().getProfile(
ProfileModel().createPassiveProfile(
appletId,
otherId,
otherName,
user
)['_id'],
grammaticalSubject
)
if 'schema:knows' in grammaticalSubject:
if rel in grammaticalSubject['schema:knows'] and grammaticalObject[
'_id'
] not in grammaticalSubject['schema:knows'][rel]:
grammaticalSubject['schema:knows'][rel].append(
grammaticalObject['_id']
)
else:
grammaticalSubject['schema:knows'][rel] = [
grammaticalObject['_id']
]
else:
grammaticalSubject['schema:knows'] = {
rel: [grammaticalObject['_id']]
}
ProfileModel().save(grammaticalSubject, validate=False)
inferRelationships(grammaticalSubject)
return(ProfileModel().getProfile(id, user))
def invite(self, applet, role="user", idCode=None, profile=None):
from girderformindlogger.models.invitation import Invitation
from girderformindlogger.models.profile import Profile
user = self.getCurrentUser()
try:
if role not in USER_ROLE_KEYS:
raise ValidationException('Invalid role.', 'role')
invitation = Invitation().createInvitation(applet=applet,
coordinator=user,
role=role,
profile=profile,
idCode=idCode)
return (Profile().displayProfileFields(invitation, user))
except:
import sys, traceback
print(sys.exc_info())
def findProfile(self, idCode):
"""
Find a list of profiles for a given ID code.
"""
existing = list(self.find({'code': idCode}))
if len(existing):
from girderformindlogger.models.profile import Profile
ps = [
Profile().load(exist['profileId'], force=True)
for exist in existing
]
if len(ps):
return (ps)
else:
from girderformindlogger.models.invitation import Invitation
existing = list(self.find({'idCode': idCode}))
ps = [
Invitation().load(exist['_id'], force=True)
for exist in existing
]
if len(ps):
return (ps)
return (None)
def inviteUserToApplet(user, appletObject, userB):
"""
invite a user to an applet
inputs
------
user: a user object
appletObject:
userB: a user object of a user you want to invite. If they aren't
defined yet, it should be a dict(email="emailaddress")
"""
groupId = appletObject['roles']['user']['groups'][0]['id']
currentUser = authenticate(user)
group = Group().load(id=ObjectId(groupId), force=True)
invitation = Invitation().createInvitation(appletObject,
currentUser,
role="user",
profile=Profile().createProfile(
appletObject, userB),
idCode=None)
return Group().inviteUser(group, userB, level=AccessType.READ)
def inviteUser(self,
applet,
role="user",
email='',
firstName='',
lastName='',
MRN=''):
from girderformindlogger.models.invitation import Invitation
from girderformindlogger.models.profile import Profile
if not mail_utils.validateEmailAddress(email):
raise ValidationException('invalid email', 'email')
thisUser = self.getCurrentUser()
encryptedEmail = UserModel().hash(email)
invitedUser = UserModel().findOne({
'email': encryptedEmail,
'email_encrypted': True
})
if not invitedUser:
invitedUser = UserModel().findOne({
'email': email,
'email_encrypted': {
'$ne': True
}
})
if not AppletModel().isCoordinator(applet['_id'], thisUser):
raise AccessException(
"Only coordinators and managers can invite users.")
if role not in USER_ROLE_KEYS:
raise ValidationException('Invalid role.', 'role')
invitation = Invitation().createInvitationForSpecifiedUser(
applet=applet,
coordinator=thisUser,
role=role,
user=invitedUser,
firstName=firstName,
lastName=lastName,
MRN=MRN,
userEmail=encryptedEmail)
url = 'web.mindlogger.org/#/invitation/%s' % (str(invitation['_id'], ))
managers = mail_utils.htmlUserList(AppletModel().listUsers(applet,
'manager',
force=True))
coordinators = mail_utils.htmlUserList(AppletModel().listUsers(
applet, 'coordinator', force=True))
reviewers = mail_utils.htmlUserList(AppletModel().listUsers(
applet, 'reviewer', force=True))
html = mail_utils.renderTemplate(
'userInvite.mako'
if invitedUser else 'inviteUserWithoutAccount.mako', {
'url': url,
'userName': firstName,
'coordinatorName': thisUser['firstName'],
'appletName': applet['displayName'],
'MRN': MRN,
'managers': managers,
'coordinators': coordinators,
'reviewers': reviewers
})
mail_utils.sendMail('invitation for an applet', html, [email])
return 'sent invitation mail to {}'.format(email)
def getAppletUsers(self, applet, user=None, force=False):
"""
Function to return a list of Applet Users
:param applet: Applet to get users for.
:type applet: dict
:param user: User making request
:type user: dict
:returns: list of dicts
"""
from girderformindlogger.models.invitation import Invitation
from girderformindlogger.models.profile import Profile
profileFields = ["_id", "coordinatorDefined", "userDefined"]
try:
if not isinstance(user, dict):
user = UserModel().load(
id=user, level=AccessType.READ, force=True) if isinstance(
user, str) else {}
if not force:
if not self.isCoordinator(applet.get('_id', applet), user):
return ([])
profileModel = Profile()
userDict = {
'active': [{
**profileModel.displayProfileFields(p,
user,
forceManager=True), 'userId':
p['userId']
} for p in list(
profileModel.find(
query={
'appletId': applet['_id'],
'userId': {
'$exists': True
},
'profile': True
}))],
'pending': []
}
for p in list(
Invitation().find(query={'appletId': applet['_id']})):
profile = profileModel.findOne(query={'_id': p['_id']})
userDict['pending'].append(
profileModel.displayProfileFields(
profile, user, forceManager=True) if profile else {
'_id': p['_id'],
'invitedBy': p['invitedBy'],
})
missing = threading.Thread(target=profileModel.generateMissing,
args=(applet, ))
missing.start()
if len(userDict['active']):
return (userDict)
else:
return ({**userDict, "message": "cache updating"})
except:
import sys, traceback
print(sys.exc_info())
return ({traceback.print_tb(sys.exc_info()[2])})
