def mutate(self, _, email, ws_id, start_date=None):
check_role_or_error(ws_id=ws_id, role=WorkspaceUserRoles.ADMIN)
start_date = start_date if start_date else datetime.datetime.utcnow()
try:
user = _UserModel.find(email=email)
if user is None:
if WorkspaceInvitation.find(email=email, ws_id=ws_id) is None:
WorkspaceInvitation(
email=email,
ws_id=ws_id,
start_date=start_date,
status=WorkspaceInvitationStatus.PENDING).save()
elif WorkspaceUser.find(user_id=user.id, ws_id=ws_id) is None:
WorkspaceInvitation(
email=email,
ws_id=ws_id,
start_date=start_date,
status=WorkspaceInvitationStatus.ACCEPTED).save()
WorkspaceUser(user_id=user.id,
ws_id=ws_id,
start_date=start_date).save()
Persistent.commit()
return AddMember(ok=True)
except Exception as e:
LOG.error(f'Could not add member into workspace. Error: {e}')
Persistent.rollback()
return GraphQLError('Could not add member into workspace.')
def execute_day_off_validation_rule(day_off):
balance = execute_balance_calculation_rule(ws_id=day_off.workspace_id,
user_id=day_off.user_id)
ws_user = WorkspaceUser.find(user_id=day_off.user_id,
ws_id=day_off.workspace_id)
if not ws_user:
raise Exception('User is not added to the specified workspace')
ws_roles = WorkspaceUserRole.find_all(ws_id=day_off.workspace_id,
user_id=day_off.user_id)
rule_payload = DayOffValidationPayload(user_start_date=ws_user.start_date,
leave=day_off,
balance=balance,
user_roles=list(
map(lambda r: r.role,
ws_roles)))
intellect = Intellect()
intellect.policy.append_child(
_get_rule_node(ws_id=day_off.workspace_id,
type=WorkspaceRuleTypes.DAY_OFF_VALIDATION))
for leave_day in _leaves_to_leave_days([day_off]):
intellect.learn_fact(leave_day)
intellect.learn_fact(rule_payload)
intellect.reason()
return rule_payload
def execute_balance_calculation_rule(ws_id, user_id):
leaves = DayOff.query(). \
filter(DayOff.user_id == user_id). \
filter(DayOff.workspace_id == ws_id). \
all()
ws_user = WorkspaceUser.find(user_id=user_id, ws_id=ws_id)
rule_payload = BalanceCalculationRulePayload(start_date=ws_user.start_date)
node = _get_rule_node(ws_id=ws_id,
type=WorkspaceRuleTypes.BALANCE_CALCULATION)
intellect = Intellect()
intellect.policy.append_child(node)
for leave_day in _leaves_to_leave_days(leaves):
intellect.learn_fact(leave_day)
intellect.learn_fact(rule_payload)
intellect.reason()
return rule_payload
def mutate(self, _, email, password, user_data):
if _UserModel.find_by_email(email):
LOG.warning(f'Repeated registration for {email}')
raise GraphQLError(f'User {email} already exists')
access_token = create_access_token(identity=email)
refresh_token = create_refresh_token(identity=email)
try:
new_user = _UserModel(email=email.strip(),
password=_UserModel.generate_hash(password),
jti=decode_token(refresh_token)['jti'],
created_time=datetime.datetime.now())
new_user.save()
Persistent.flush()
new_user_profile = UserProfile(
user_id=new_user.id,
email=email.strip(),
first_name=user_data.first_name.strip(),
last_name=user_data.last_name.strip())
new_user_profile.save_and_persist()
except Exception as e:
LOG.error(f"User registration failed. Error: {e}")
Persistent.rollback()
raise GraphQLError("User registration failed.")
else:
# check ws invitatitons
try:
pending_invitations = WorkspaceInvitation.find_all(
email=email, status=WorkspaceInvitationStatus.PENDING)
processed_ws_ids = set()
for inv in pending_invitations:
if inv.ws_id not in processed_ws_ids:
processed_ws_ids.add(inv.ws_id)
WorkspaceUser(user_id=new_user.id,
ws_id=inv.ws_id,
start_date=inv.start_date).save()
WorkspaceUserRole(
ws_id=inv.ws_id,
user_id=new_user.id,
role=WorkspaceUserRoles.MEMBER).save()
inv.status = WorkspaceInvitationStatus.ACCEPTED
WorkspaceInvitation.query() \
.filter(WorkspaceInvitation.id == inv.id) \
.update({WorkspaceInvitation.status: inv.status})
Persistent.commit()
except Exception as e:
LOG.error(
f"Workspace invitations check failed for user {new_user.email}. Error: {e}"
)
db.session.rollback()
return Register(ok=True,
user_id=new_user.id,
access_token=access_token,
refresh_token=refresh_token)
def current_user_in_workspace_or_error(ws_id, message="Wrong association"):
user = current_user_or_error()
find_kwargs = {"user_id": user.id, "ws_id": ws_id}
assoc = WorkspaceUser.find(**find_kwargs)
if not assoc:
raise GraphQLError(message)
return user
def mutate(self, _, name, description, members):
now = datetime.datetime.now()
user = current_user_or_error()
try:
new_ws = WorkspaceModel(name=name, description=description)
new_ws.save()
Persistent.flush() # so we now have ID for new_ws
WorkspaceUser(ws_id=new_ws.id, user_id=user.id,
start_date=now).save()
for role in WorkspaceUserRoles.__members__:
WorkspaceUserRole(ws_id=new_ws.id, user_id=user.id,
role=role).save()
for email in members:
if email.strip() == user.email:
continue
wsi = WorkspaceInvitation(email=email, ws_id=new_ws.id)
# check if user with this email already exist
user_by_email = _UserModel.find_by_email(email=email)
if user_by_email:
WorkspaceUser(ws_id=new_ws.id,
user_id=user_by_email.id,
start_date=now).save()
WorkspaceUserRole(ws_id=new_ws.id,
user_id=user_by_email.id,
role=WorkspaceUserRoles.MEMBER).save()
wsi.status = WorkspaceInvitationStatus.ACCEPTED
wsi.save()
Persistent.commit()
return CreateWorkspace(ok=True, ws=new_ws)
except Exception as e:
LOG.error(f'Workspace creation failed. Error: {e}')
Persistent.rollback()
raise GraphQLError('Workspace creation failed.')
def mutate(self, _, ws_id, user_id, start_date):
check_role_or_error(ws_id=ws_id, role=WorkspaceUserRoles.ADMIN)
ws_user = WorkspaceUser.find(ws_id=ws_id, user_id=user_id)
if not ws_user:
raise GraphQLError("Could not find user in the workspace")
ws_user.start_date = start_date
try:
ws_user.save_and_persist()
return UpdateMember(ok=True, member=ws_user)
except Exception as e:
LOG.error(f'Could not update the workspace member. Error: {e}')
return GraphQLError('Could not update the workspace member.')
def mutate(self, _, email, ws_id):
check_role_or_error(ws_id=ws_id, role=WorkspaceUserRoles.ADMIN)
try:
invitation = WorkspaceInvitation.find(ws_id=ws_id, email=email)
if invitation:
invitation.delete()
ws_user = None
user = _UserModel.find(email=email)
if user:
ws_user = WorkspaceUser.find(ws_id=ws_id, user_id=user.id)
if ws_user:
ws_user.delete()
Persistent.commit()
return RemoveMember(ok=True)
except Exception as e:
LOG.error(f'Could not remove member from workspace.. Error: {e}')
Persistent.rollback()
return GraphQLError('Could not remove member from workspace.')
def workspace_member(_, info, workspace_id, user_id):
return WorkspaceUser.find(ws_id=workspace_id, user_id=user_id)
def workspace_members(_, info, workspace_id):
return WorkspaceUser.find_all(ws_id=workspace_id)