def resolve_landing_page_modules(self, args, context, info): model = models.LandingPageModule query = get_query(model, context) discussion_id = context.matchdict['discussion_id'] # we want to return a LandingPageModule for each module type (even if there is no entry yet in LandingPageModule table) module_types = get_query(models.LandingPageModuleType, context).order_by(models.LandingPageModuleType.default_order).all() modules = [] for module_type in module_types: module = query.filter( model.discussion_id == discussion_id ).join( model.module_type ).filter( models.LandingPageModuleType.identifier == module_type.identifier ).all() if module: modules.extend(module) else: # create the graphene object for this module type module = LandingPageModule( configuration=u'{}', id=randint(-100000, 0), enabled=module_type.required, module_type=module_type, order=module_type.default_order, title=None, subtitle=None ) modules.append(module) return sorted(modules, key=attrgetter('order'))
def resolve_profile_fields(self, args, context, info): model = models.ProfileField query = get_query(model, context) discussion_id = context.matchdict['discussion_id'] user_id = context.authenticated_userid fields = get_query( models.AbstractConfigurableField, context).filter( models.AbstractConfigurableField.discussion_id == discussion_id ).order_by(models.AbstractConfigurableField.order).all() profile_fields = [] if user_id is None: raise Exception('No user id') for field in fields: saobj = query.filter( model.discussion_id == discussion_id ).filter( models.ProfileField.configurable_field == field ).filter( models.ProfileField.agent_profile_id == user_id ).first() if saobj: profile_field = saobj else: profile_field = ProfileField( agent_profile=models.AgentProfile.get(user_id), id=randint(-100000, 0), configurable_field=field, ) profile_fields.append(profile_field) return profile_fields
def resolve_posts(self, args, context, info): discussion_id = context.matchdict['discussion_id'] discussion = models.Discussion.get(discussion_id) identifiers = args.get('identifiers', []) model = models.AssemblPost # Note: This is only used by BigDatext, posts in moderating phase excluded query = get_posts_for_phases(discussion, identifiers, include_moderating=False) # If no posts in the specified identifiers, we return an empty list if identifiers and query is None: return [] elif query is None: # If we have no identifier, we return all of posts query = get_query(model, context) # We filter posts by their discussion id query = query.filter( model.discussion_id == discussion_id, model.hidden == False, # noqa: E712 model.tombstone_condition() ) # We filter posts by their modification date start_date = args.get('start_date', None) end_date = args.get('end_date', None) if start_date: start_date = dateutil.parser.parse(start_date) query = query.filter(model.modification_date >= start_date) if end_date: end_date = dateutil.parser.parse(end_date) query = query.filter(model.modification_date <= end_date) return query.all()
def resolve_has_resources_center(self, args, context, info): model = models.Resource query = get_query(model, context) discussion_id = context.matchdict['discussion_id'] resources_count = query.filter( model.discussion_id == discussion_id).count() return bool(resources_count)
def resolve_tags(self, args, context, info): discussion_id = context.matchdict['discussion_id'] _filter = args.get('filter', '') model = models.Keyword query = get_query(model, context).filter( model.discussion_id == discussion_id) if not _filter: return query.limit(30).all() _filter = '%{}%'.format(_filter) return query.filter(model.value.ilike(_filter)).all()
def compile_query(cls, model_cls, flat_query, info): """ Given a flat query, return SqlAlchemy query :param model_cls: Model class. :param flat_query: flat dict to be returned at the end after processing :return: SqlAlchemy query """ from graphene_sqlalchemy.utils import get_query final_query = get_query(model_cls, info.context) for k, v in flat_query.items(): # If query field is uid or contains uid, replace with (id) if 'uid' in k: k = k.replace('uid', 'id') # these parameters will be already parsed at this point by get_query() # they don't exist in models any way if k in ['before', 'last', 'after', 'first']: continue # normal fields, not relation fields if '.' not in k: filter = cls.parse_query(model_cls, k, v) else: attrs = k.split('.') attr, sub_attr = attrs[0], attrs[1] sub_model = model_cls()._get_model_from_table_name( getattr(model_cls, attr).prop.table.name) # backeref relation if getattr(model_cls, attr).prop.backref: filter = getattr(model_cls, attr).any( cls.parse_query(sub_model, sub_attr, v)) else: # Foreign keys filter = getattr(model_cls, attr).has( cls.parse_query(sub_model, sub_attr, v)) if not final_query: final_query = model_cls.query.filter(filter) else: final_query = final_query.filter(filter) return final_query
def mutate(root, args, context, info): cls = models.ProfileField discussion_id = context.matchdict['discussion_id'] user_id = context.authenticated_userid agent_profile = models.AgentProfile.get(user_id) require_instance_permission(CrudPermissions.UPDATE, agent_profile, context) with cls.default_db.no_autoflush as db: for field_info in args.get('data'): profile_field_id = field_info['id'] profile_field_id = int(Node.from_global_id(profile_field_id)[1]) profile_field = cls.get(profile_field_id) if profile_field: require_instance_permission(CrudPermissions.UPDATE, profile_field, context) profile_field.value_data = field_info['value_data'] else: configurable_field_id = field_info['configurable_field_id'] configurable_field_id = int(Node.from_global_id(configurable_field_id)[1]) configurable_field = models.AbstractConfigurableField.get(configurable_field_id) if configurable_field.identifier == ConfigurableFieldIdentifiersEnum.FULLNAME.value: agent_profile.real_name_p = field_info['value_data']['value'] elif configurable_field.identifier == ConfigurableFieldIdentifiersEnum.EMAIL.value: agent_profile.preferred_email = field_info['value_data']['value'] elif configurable_field.identifier == ConfigurableFieldIdentifiersEnum.USERNAME.value: agent_profile.username_p = field_info['value_data']['value'] elif configurable_field.identifier == ConfigurableFieldIdentifiersEnum.CUSTOM.value: require_cls_permission(CrudPermissions.CREATE, cls, context) profile_field = cls( agent_profile=agent_profile, configurable_field_id=configurable_field_id, discussion_id=discussion_id, value_data=field_info['value_data'] ) db.add(profile_field) db.flush() profile_fields = get_query(cls, context).filter(cls.discussion_id == discussion_id) return UpdateProfileFields(profile_fields=profile_fields)
def resolve_ideas(self, args, context, info): discussion_id = context.matchdict['discussion_id'] discussion = models.Discussion.get(discussion_id) phase_identifier = args.get('identifier') if phase_identifier in ('survey', 'brightMirror'): root_thematic = get_root_thematic_for_phase( discussion, phase_identifier) if root_thematic is None: return [] return root_thematic.get_children() model = models.Idea query = get_query(model, context) descendants_query = discussion.root_idea.get_descendants_query( inclusive=False) query = query.outerjoin(models.Idea.source_links).filter( model.id.in_(descendants_query) ).filter( model.hidden == False, # noqa: E712 model.sqla_type == 'idea', model.tombstone_date == None # noqa: E711 ).options( contains_eager(models.Idea.source_links), subqueryload(models.Idea.attachments).joinedload("document"), # subqueryload(models.Idea.message_columns), joinedload(models.Idea.title).joinedload("entries"), # joinedload(models.Idea.synthesis_title).joinedload("entries"), joinedload(models.Idea.description).joinedload("entries"), ).order_by(models.IdeaLink.order, models.Idea.creation_date) if phase_identifier == 'multiColumns': # Filter out ideas that don't have columns. query = query.filter( models.Idea.message_view_override == 'messageColumns') return query
def resolve_text_fields(self, args, context, info): model = models.AbstractConfigurableField query = get_query(model, context) discussion_id = context.matchdict['discussion_id'] return query.filter(model.discussion_id == discussion_id).order_by( model.order)
def resolve_landing_page_module_types(self, args, context, info): model = models.LandingPageModuleType return get_query(model, context)
def resolve_sections(self, args, context, info): model = models.Section query = get_query(model, context) discussion_id = context.matchdict['discussion_id'] return query.filter(model.discussion_id == discussion_id).order_by( model.order)
def resolve_text_fields(self, args, context, info): model = models.AbstractConfigurableField query = get_query(model, context) discussion_id = context.matchdict['discussion_id'] return query.filter(model.discussion_id == discussion_id).order_by(model.order)
def resolve_sections(self, args, context, info): model = models.Section query = get_query(model, context) discussion_id = context.matchdict['discussion_id'] return query.filter(model.discussion_id == discussion_id).order_by(model.order)
def get_query(cls, model, info, sort_by=None, **args): return get_query(model, info.context).order_by(desc(sort_by))