def __init__(self, *args, **kwargs): """Initialize profile relationship while creating Person instance""" super(Person, self).__init__(*args, **kwargs) self.profile = PersonProfile() self.build_object_context(context=1, name='Personal Context', description='') self.profile.add_person_with_role_name(self, "Admin")
def _get_or_create_profile(person_id): """Returns profile if it exists, otherwise returns created one Returns: A tuple (created, profile). Created is set True for created profile, False otherwise. Profile is profile for Person with id=person_id. """ try: profile = PersonProfile.query.filter_by(person_id=person_id).one() except NoResultFound: person = Person.query.filter_by(id=person_id).one() person.profile = PersonProfile() return (True, person.profile) return (False, profile)
class Person(CustomAttributable, CustomAttributeMapable, HasOwnContext, Relatable, base.ContextRBAC, Base, Indexed, db.Model): """Person model definition.""" def __init__(self, *args, **kwargs): """Initialize profile relationship while creating Person instance""" super(Person, self).__init__(*args, **kwargs) self.profile = PersonProfile() self.build_object_context(context=1, name='Personal Context', description='') self.profile.add_person_with_role_name(self, "Admin") __tablename__ = 'people' email = db.Column(db.String, nullable=False) name = db.Column(db.String, nullable=False) language_id = db.Column(db.Integer) company = db.Column(db.String) object_people = db.relationship('ObjectPerson', backref='person', cascade='all, delete-orphan') language = db.relationship( 'Option', primaryjoin='and_(foreign(Person.language_id) == Option.id, ' 'Option.role == "person_language")', uselist=False, ) saved_searches = db.relationship( "SavedSearch", lazy="dynamic", cascade="all, delete-orphan", ) profile = db.relationship( "PersonProfile", foreign_keys='PersonProfile.person_id', uselist=False, backref="person", cascade='all, delete-orphan', ) access_control_people = db.relationship( 'AccessControlPerson', foreign_keys='AccessControlPerson.person_id', backref="person", ) @staticmethod def _extra_table_args(_): return ( db.Index('ix_people_name_email', 'name', 'email'), db.Index('uq_people_email', 'email', unique=True), ) _fulltext_attrs = [ 'company', 'email', 'name', attributes.FullTextAttr("Authorizations", "system_wide_role"), ] _api_attrs = reflection.ApiAttributes( 'company', 'email', 'language', 'name', reflection.Attribute('profile', create=False, update=False), reflection.Attribute('object_people', create=False, update=False), reflection.Attribute('system_wide_role', create=False, update=False), ) _sanitize_html = [ 'company', 'name', ] _include_links = [] ROLE_OPTIONS = ("No Access", "Creator", "Reader", "Editor", "Administrator") _aliases = { "name": "Name", "email": { "display_name": "Email", "unique": True, }, "company": "Company", "user_role": { "display_name": "Role", "type": "user_role", "filter_by": "_filter_by_user_role", "description": "Allowed values are\n{}".format("\n".join(ROLE_OPTIONS)) }, } @classmethod def _filter_by_user_role(cls, predicate): """Custom filter by user roles.""" from ggrc_basic_permissions.models import Role, UserRole return UserRole.query.join( Role).filter((UserRole.person_id == cls.id) & (UserRole.context_id.is_(None)) & # noqa predicate(Role.name)).exists() # Methods required by Flask-Login # pylint: disable=no-self-use def is_authenticated(self): return self.system_wide_role != 'No Access' @property def user_name(self): return self.email.split("@")[0] @property def title(self): return self.name or self.email def is_active(self): # pylint: disable=no-self-use return True # self.active def is_anonymous(self): # pylint: disable=no-self-use return False def get_id(self): return unicode(self.id) # noqa @validates('language') def validate_person_options(self, key, option): return validate_option(self.__class__.__name__, key, option, 'person_language') @validates('email') def validate_email(self, _, email): """Email property validator.""" if not Person.is_valid_email(email): message = "Email address '{}' is invalid. Valid email must be provided" raise ValidationError(message.format(email)) return email @validates('name') def validate_name(self, _, name): """Name property validator.""" if not name: raise ValidationError("Name is empty") return name @staticmethod def is_valid_email(val): """Check for valid email. Borrowed from Django. Literal form, ipv4 address (SMTP 4.1.3). """ email_re = re.compile( r'^[-!#$%&\'*+\\.\/0-9=?A-Z^_`{|}~]+@([-0-9A-Z]+\.)+([0-9A-Z]){2,4}$', re.IGNORECASE) return email_re.match(val) if val else False @classmethod def eager_query(cls, **kwargs): from sqlalchemy import orm # query = super(Person, cls).eager_query(**kwargs) # Completely overriding eager_query to avoid eager loading of the # modified_by relationship return super(Person, cls).eager_query(**kwargs).options( orm.joinedload('language'), orm.joinedload('profile'), orm.subqueryload('object_people'), ) @classmethod def indexed_query(cls): from sqlalchemy import orm return super(Person, cls).indexed_query().options( orm.Load(cls).undefer_group("Person_complete", ), orm.Load(cls).joinedload('user_roles'), ) def _display_name(self): return self.email @builder.simple_property def system_wide_role(self): """For choosing the role string to show to the user; of all the roles in the system-wide context, it shows the highest ranked one (if there are multiple) or "No Access" if there are none. """ if self.email in getattr(settings, "BOOTSTRAP_ADMIN_USERS", []): return SystemWideRoles.SUPERUSER from ggrc.utils.user_generator import is_app_2_app_user_email if is_app_2_app_user_email(self.email): return SystemWideRoles.SUPERUSER role_hierarchy = { SystemWideRoles.ADMINISTRATOR: 0, SystemWideRoles.EDITOR: 1, SystemWideRoles.READER: 2, SystemWideRoles.CREATOR: 3, } unique_roles = set([ user_role.role.name for user_role in self.user_roles if user_role.role.name in role_hierarchy ]) if not unique_roles: return u"No Access" # -1 as default to make items not in this list appear on top # and thus shown to the user sorted_roles = sorted(unique_roles, key=lambda x: role_hierarchy.get(x, -1)) return sorted_roles[0]
def __init__(self, *args, **kwargs): """Initialize profile relationship while creating Person instance""" super(Person, self).__init__(*args, **kwargs) self.profile = PersonProfile()