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)