}, "program_reader": { "display_name": "Reader", "type": AttributeInfo.Type.USER_ROLE, "filter_by": "_filter_by_program_reader", }, } @classmethod def _filter_by_program_owner(cls, predicate): return cls._filter_by_role("ProgramOwner", predicate) @classmethod def _filter_by_program_editor(cls, predicate): return cls._filter_by_role("ProgramEditor", predicate) @classmethod def _filter_by_program_reader(cls, predicate): return cls._filter_by_role("ProgramReader", predicate) @classmethod def eager_query(cls): from sqlalchemy import orm query = super(Program, cls).eager_query() return cls.eager_inclusions(query, Program._include_links).options( orm.subqueryload('audits')) track_state_for_class(Program)
'Final', 'Effective', 'Ineffective', 'Launched', 'Not Launched', 'In Scope', 'Not in Scope', 'Deprecated', ] __tablename__ = 'clauses' _table_plural = 'clauses' _aliases = { "url": "Clause URL", "description": "Text of Clause", "directive": None, } # pylint: disable=invalid-name na = deferred(db.Column(db.Boolean, default=False, nullable=False), 'Clause') notes = deferred(db.Column(db.Text), 'Clause') _publish_attrs = [ 'na', 'notes', ] _sanitize_html = ['notes'] _include_links = [] track_state_for_class(Clause)
return value if value in self.VALID_CONCLUSIONS else "" @validates("operationally") def validate_opperationally(self, key, value): # pylint: disable=unused-argument return self.validate_conclusion(value) @validates("design") def validate_design(self, key, value): # pylint: disable=unused-argument return self.validate_conclusion(value) @classmethod def _filter_by_related_creators(cls, predicate): return cls._get_relate_filter(predicate, "Creator") @classmethod def _filter_by_related_assessors(cls, predicate): return cls._get_relate_filter(predicate, "Assessor") @classmethod def _filter_by_related_verifiers(cls, predicate): return cls._get_relate_filter(predicate, "Verifier") @classmethod def _ignore_filter(cls, predicate): return None track_state_for_class(Assessment)
# Copyright (C) 2016 Google Inc. # Licensed under http://www.apache.org/licenses/LICENSE-2.0 <see LICENSE file> from ggrc import db from ggrc.models.mixins import BusinessObject, Timeboxed, CustomAttributable from ggrc.models.object_document import Documentable from ggrc.models.object_owner import Ownable from ggrc.models.object_person import Personable from ggrc.models.relationship import Relatable from ggrc.models.track_object_state import HasObjectState, track_state_for_class class AccessGroup(HasObjectState, CustomAttributable, Personable, Documentable, Relatable, Timeboxed, Ownable, BusinessObject, db.Model): __tablename__ = 'access_groups' _aliases = {"url": "Access Group URL"} track_state_for_class(AccessGroup)
@classmethod def _filter_by_secondary_assessor(cls, predicate): return Person.query.filter((Person.id == cls.secondary_assessor_id) & (predicate(Person.name) | predicate(Person.email))).exists() @classmethod def _filter_by_verify_frequency(cls, predicate): return Option.query.filter((Option.id == cls.verify_frequency_id) & predicate(Option.title)).exists() @classmethod def eager_query(cls): from sqlalchemy import orm query = super(Control, cls).eager_query() return cls.eager_inclusions(query, Control._include_links).options( orm.joinedload('directive'), orm.joinedload('principal_assessor'), orm.joinedload('secondary_assessor'), ) def log_json(self): out_json = super(Control, self).log_json() # so that event log can refer to deleted directive if self.directive: out_json["mapped_directive"] = self.directive.display_name return out_json track_state_for_class(Control)
& predicate(Option.title)).exists() @classmethod def eager_query(cls): from sqlalchemy import orm query = super(SystemOrProcess, cls).eager_query() return query.options(orm.joinedload('network_zone')) @staticmethod def _extra_table_args(cls): return (db.Index('ix_{}_is_biz_process'.format(cls.__tablename__), 'is_biz_process'), ) track_object_state.track_state_for_class(SystemOrProcess) class System(CustomAttributable, Documentable, Personable, Relatable, Ownable, SystemOrProcess): __mapper_args__ = {'polymorphic_identity': False} _table_plural = 'systems' _aliases = {"url": "System URL"} @validates('is_biz_process') def validates_is_biz_process(self, key, value): return False class Process(CustomAttributable, Documentable, Personable, Relatable, Ownable,
_publish_attrs = [ 'na', 'notes', ] _sanitize_html = ['notes'] _include_links = [] @classmethod def _filter_by_directive(cls, predicate): types = ["Policy", "Regulation", "Standard", "Contract"] dst = Relationship.query \ .filter( (Relationship.source_id == cls.id) & (Relationship.source_type == cls.__name__) & (Relationship.destination_type.in_(types))) \ .join(Directive, Directive.id == Relationship.destination_id) \ .filter(predicate(Directive.slug) | predicate(Directive.title)) \ .exists() src = Relationship.query \ .filter( (Relationship.destination_id == cls.id) & (Relationship.destination_type == cls.__name__) & (Relationship.source_type.in_(types))) \ .join(Directive, Directive.id == Relationship.source_id) \ .filter(predicate(Directive.slug) | predicate(Directive.title)) \ .exists() return dst | src track_state_for_class(Section)
'version', ] _sanitize_html = ['version', ] _aliases = { "url": "Product URL", "kind": { "display_name": "Kind/Type", "filter_by": "_filter_by_kind", }, } @validates('kind') def validate_product_options(self, key, option): return validate_option( self.__class__.__name__, key, option, 'product_type') @classmethod def _filter_by_kind(cls, predicate): return Option.query.filter( (Option.id == cls.kind_id) & predicate(Option.title) ).exists() @classmethod def eager_query(cls): from sqlalchemy import orm query = super(Product, cls).eager_query() return query.options(orm.joinedload('kind')) track_state_for_class(Product)