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 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_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 get_query(cls, model, info, sort_by=None, **args):
return get_query(model, info.context).order_by(desc(sort_by))