def emailSubscribeChannelDelete(_):
@check_permissions([staffonly])
def resolve(_, info, slug):
models.SubscribeChannel.objects.get(slug=slug).delete()
return True
return g.Field(g.Boolean, args=g.arguments({'slug': str}), resolve=resolve)
def mastermindDatingCreateParticipant(_):
@check_permissions([staffonly])
def resolve(_, info, cohort_id, email):
KchUser = get_user_model()
try:
kocherga_user = KchUser.objects.get(email=email)
except KchUser.DoesNotExist:
kocherga_user = KchUser.objects.create_user(email)
cohort = models.Cohort.objects.get(pk=cohort_id)
(participant, _) = models.Participant.objects.get_or_create(
user=kocherga_user,
cohort=cohort,
)
return {'participant': participant}
return g.Field(
g.NN(ParticipantMutationResult),
args=g.arguments({
'cohort_id': 'ID!',
'email': str
}),
resolve=resolve,
)
def staffGrantGooglePermissionsToMember(helper):
@check_permissions([user_perm('staff.manage')])
def resolve(obj, info, id):
member = models.Member.objects.get(pk=id)
member.grant_google_permissions()
return True
return g.Field(g.Boolean, args=g.arguments({'id': 'ID!'}), resolve=resolve)
class cashierRedeemPayment(helpers.BaseField):
def resolve(self, _, info, id):
payment = models.Payment.objects.get(pk=id)
payment.redeem()
return True
permissions = [user_perm('cashier.redeem')]
args = g.arguments({'id': 'ID!'})
result = g.Boolean
class importer(helpers.BaseField):
permissions = [permissions.staffonly]
result = g.NN(Importer)
args = g.arguments({
'module_name': str,
})
def resolve(self, _, info, module_name):
return get_importer(module_name)
def mastermindDatingCohortById(helper):
@check_permissions([staffonly])
def resolve(_, info, id):
return models.Cohort.objects.get(pk=id)
return g.Field(
g.NN(types.MastermindDatingCohort),
args=g.arguments({'id': 'ID!'}),
resolve=resolve,
)
def instances_field():
@check_permissions([permissions.manage_events])
def resolve(obj, info, limit=None):
return obj.instances(limit=limit)
return g.Field(
g.NNList(Event),
args=g.arguments({'limit': Optional[int]}),
resolve=resolve,
)
def emailSubscribeChannelAddEmail(_):
@check_permissions([staffonly])
def resolve(_, info, slug, email):
channel = models.SubscribeChannel.objects.get(slug=slug)
channel.subscribe_email(email)
return True
return g.Field(
g.Boolean, args=g.arguments({'slug': str, 'email': str}), resolve=resolve
)
def mastermindDatingActivateVoting(_):
@check_permissions([staffonly])
def resolve(_, info, participant_id):
obj = models.Participant.objects.get(pk=participant_id)
obj.tinder_activate()
return {'participant': obj}
return g.Field(
g.NN(ParticipantMutationResult),
args=g.arguments({'participant_id': 'ID!'}),
resolve=resolve,
)
def mastermindDatingDeleteCohort(helper):
@check_permissions([staffonly])
def resolve(_, info, cohort_id):
obj = models.Cohort.objects.get(pk=cohort_id)
obj.delete()
return {'ok': True}
return g.Field(
g.NN(BasicResult),
args=g.arguments({'cohort_id': 'ID!'}),
resolve=resolve,
)
def description_field():
def resolve(obj, info, format=None):
# PLAIN is default for now, for backward-compatibility
if format == 'PLAIN' or format is None:
return markup.Markup(obj.description).as_plain()
elif format == 'SOURCE' or format is None:
return obj.description
else:
raise Exception(f"Unknown markup format {format}")
args = g.arguments({'format': EventsMarkupFormat})
return g.Field(g.NN(g.String), args=args, resolve=resolve)
def mastermindDatingCreateGroup(helper):
@check_permissions([staffonly])
def resolve(_, info, cohort_id):
cohort = models.Cohort.objects.get(pk=cohort_id)
models.Group.objects.create_for_cohort(cohort)
return {'cohort': cohort}
return g.Field(
g.NN(CohortMutationResult),
args=g.arguments({'cohort_id': 'ID!'}),
resolve=resolve,
)
def mastermindDatingUnsetEventForCohort(_):
@check_permissions([staffonly])
def resolve(_, info, cohort_id):
cohort = models.Cohort.objects.get(pk=cohort_id)
cohort.event = None
cohort.save()
return {'cohort': cohort}
return g.Field(
g.NN(CohortMutationResult),
args=g.arguments({'cohort_id': 'ID!'}),
resolve=resolve,
)
def myPrivacyModeSet(helper):
@permissions.check_permissions([permissions.authenticated])
def resolve(_, info, mode: str):
if not hasattr(info.context.user, 'customer'):
raise Exception("User doesn't have a customer profile")
customer = info.context.user.customer
customer.privacy_mode = mode
customer.full_clean()
customer.save()
return True
return g.Field(g.Boolean, args=g.arguments({'mode': str}), resolve=resolve)
def image_rendition_field(model, field_name, permissions: List[Any] = []):
@check_permissions(permissions)
def resolve(obj, info, spec):
image = getattr(obj, field_name)
if not image:
return None
return image.get_rendition(spec)
field = model._meta.get_field(field_name)
assert issubclass(field.related_model, wagtail.images.models.AbstractImage)
Result = types.WagtailImageRendition
if not field.null:
Result = g.NN(Result)
return g.Field(Result, args=g.arguments({'spec': str}), resolve=resolve)
def mastermindDatingSetPresenceStatus(_):
@check_permissions([staffonly])
def resolve(_, info, participant_id, present):
obj = models.Participant.objects.get(pk=participant_id)
obj.present = present
obj.full_clean()
obj.save()
return {'participant': obj}
return g.Field(
g.NN(ParticipantMutationResult),
args=g.arguments({
'participant_id': 'ID!',
'present': bool
}),
resolve=resolve,
)
def create_PhotoRibbonBlock():
def resolve_value(obj, info, spec):
return [image.get_rendition(spec) for image in obj.value]
return g.ObjectType(
'PhotoRibbonBlock',
interfaces=[WagtailBlock],
fields=g.fields({
'id':
'ID!',
'value':
g.Field(
g.NNList(WagtailImageRendition),
args=g.arguments({'spec': str}),
resolve=resolve_value,
),
}),
)
def build_WagtailImage():
def resolve_rendition(obj, info, spec):
return obj.get_rendition(spec)
return g.ObjectType(
'WagtailImage',
lambda: g.fields({
'id':
'ID!',
'url':
str,
'width':
int,
'height':
int,
'rendition':
g.Field(
g.NN(WagtailImageRendition),
args=g.arguments({'spec': str}),
resolve=resolve_rendition,
),
}),
)
def emailSubscribeChannelCreate(_):
@check_permissions([staffonly])
def resolve(_, info, params):
slug = params['slug']
interest_ids = params['interest_ids']
interests = models.MailchimpInterest.objects.filter(pk__in=interest_ids).all()
instance = models.SubscribeChannel.objects.create(slug=slug)
instance.interests.set(interests)
return True
# input EmailSubscribeChannelCreateInput {
# slug: String!
# interest_ids: [ID!]!
# }
Input = g.InputObjectType(
'EmailSubscribeChannelCreateInput',
g.input_fields({'slug': str, 'interest_ids': g.NNList(g.ID)}),
)
# TODO - rename params -> input
return g.Field(
g.Boolean, args=g.arguments({'params': g.NN(Input)}), resolve=resolve
)
def suggested_dates_field():
def resolve(obj, info, limit, until_ts=None, from_date=None, to_date=None):
from_date_parsed = None
to_date_parsed = None
if from_date:
from_date_parsed = datetime.strptime(from_date, '%Y-%m-%d').date()
if to_date:
to_date_parsed = datetime.strptime(to_date, '%Y-%m-%d').date()
elif until_ts:
to_date_parsed = datetime.fromtimestamp(until_ts, tz=TZ).date()
return obj.suggested_dates(from_date=from_date_parsed,
to_date=to_date_parsed,
limit=limit)
return g.Field(
g.NNList(g.String),
args=g.arguments({
'limit': int,
'from_date': Optional[str],
'to_date': Optional[str],
'until_ts': Optional[int], # deprecated
}),
resolve=resolve,
)
def block_to_gfield(
name: str,
block_type: wagtail.core.blocks.Block,
registrator: Callable[
[g.ObjectType],
None], # registers extra block types, usually from StreamBlock
types_for_page_chooser: Dict[str, g.ObjectType] = {},
):
if any(
isinstance(block_type, c) for c in (
wagtail.core.blocks.CharBlock,
wagtail.core.blocks.TextBlock,
wagtail.core.blocks.RawHTMLBlock,
kocherga.wagtail.blocks.URLOrAbsolutePathBlock,
wagtailmath.blocks.MathBlock,
)):
return str
if isinstance(block_type, wagtail.core.blocks.IntegerBlock):
return int
if isinstance(block_type, wagtail.core.blocks.BooleanBlock):
return bool
if isinstance(block_type, wagtailgeowidget.blocks.GeoBlock):
return g.NN(types.WagtailGeo)
if isinstance(block_type, wagtail.core.blocks.RichTextBlock):
def resolve_richtext_value(obj, info):
value = graphql.default_field_resolver(obj, info)
return wagtail.core.rich_text.expand_db_html(value.source)
return g.Field(g.NN(g.String), resolve=resolve_richtext_value)
if isinstance(block_type, ImageChooserBlock):
def resolve_image_value(obj, info, spec):
image = graphql.default_field_resolver(obj, info)
if not image:
return None
return image.get_rendition(spec)
Result = types.WagtailImageRendition
if block_type.required:
Result = g.NN(Result)
return g.Field(Result,
args=g.arguments({'spec': str}),
resolve=resolve_image_value)
if isinstance(block_type, wagtail.core.blocks.ListBlock):
child_field = block_to_gfield(name, block_type.child_block,
registrator, types_for_page_chooser)
if isinstance(child_field, g.Field):
child_type = child_field.type
if child_field.resolve:
# handling this case is more complicated than I expected and we don't need it for now
raise Exception(
"Wrapping fields with custom resolvers in ListBLock is not implemented yet"
)
else:
child_type = g.as_type(child_field)
return g.NN(g.List(child_type))
if isinstance(block_type, wagtail.core.blocks.StructBlock):
return g.NN(
g.ObjectType(
name + 'Value',
fields=g.fields({
k: block_to_gfield(name + '_' + k, v, registrator,
types_for_page_chooser)
for k, v in block_type.child_blocks.items()
}),
))
if isinstance(block_type, wagtail.core.blocks.StreamBlock):
nested_name_to_full_graphql_name = (
lambda n: name + '_' + wagtail_to_graphql_block_name(k))
nested_types = []
for k, v in block_type.child_blocks.items():
all_nested_types = block_to_types(
(nested_name_to_full_graphql_name(k), v),
types_for_page_chooser,
rewrite_name=False,
)
nested_types.append(all_nested_types[0])
# for nested_type in nested_types:
# registrator(nested_type)
return g.NNList(
g.UnionType(
name + 'Values',
types=nested_types,
resolve_type=lambda obj, *_: nested_name_to_full_graphql_name(
obj.block.name),
))
if isinstance(block_type, wagtail.core.blocks.PageChooserBlock):
value_type = types_for_page_chooser[
block_type.target_model.graphql_type]
if block_type.required:
value_type = g.NN(value_type)
return value_type
raise Exception(f"Don't know how to handle block type {block_type}")
('PopulateCohortFromEvent', 'populate_from_event'),
('SendInviteEmails', 'send_invite_emails'),
('ClearAllGroups', 'clear_all_groups'),
('RunSolver', 'run_solver'),
('BroadcastSolution', 'broadcast_solution'),
]:
@check_permissions([staffonly])
def resolve(_, info, cohort_id):
obj = models.Cohort.objects.get(pk=cohort_id)
getattr(obj, method)()
return {'cohort': obj}
field = g.Field(
g.NN(CohortMutationResult),
args=g.arguments({'cohort_id': 'ID!'}),
resolve=resolve,
)
c.add_field('mastermindDating' + field_name, field)
@c.field
def mastermindDatingDeleteCohort(helper):
@check_permissions([staffonly])
def resolve(_, info, cohort_id):
obj = models.Cohort.objects.get(pk=cohort_id)
obj.delete()
return {'ok': True}
return g.Field(
g.NN(BasicResult),
def build_WagtailPageMeta():
def _can_edit(page, user):
return page.permissions_for_user(user).can_edit()
def resolve_permissions(page, info):
return {'can_edit': _can_edit(page, info.context.user)}
WagtailPageRevision = g.ObjectType(
'WagtailPageRevision',
fields=lambda: g.fields({
'id':
'ID!',
'created_at':
str,
'as_page':
g.Field(g.NN(WagtailPage),
resolve=lambda obj, info: obj.as_page_object()),
}),
)
def resolve_revisions(page, info):
if not _can_edit(page, info.context.user):
raise Exception("Can't get revisions without can_edit permission")
return list(page.revisions.all())
def resolve_single_revision(page, info, id):
if not _can_edit(page, info.context.user):
raise Exception("Can't get revisions without can_edit permission")
return page.revisions.get(pk=id)
return g.ObjectType(
'WagtailPageMeta',
g.fields({
'slug':
str,
'description':
g.Field(g.NN(g.String),
resolve=lambda page, info: page.search_description),
'html_url':
g.Field(
g.NN(g.String),
resolve=lambda page, info: page.url,
deprecation_reason='renamed to `url`',
),
'url':
str,
'permissions':
g.Field(
g.NN(
g.ObjectType('WagtailPagePermissions',
g.fields({'can_edit': bool}))),
resolve=resolve_permissions,
),
# 'live_revision_id': 'ID', # can be null if page is not published yet
'revisions':
g.Field(
g.NNList(WagtailPageRevision),
resolve=resolve_revisions,
),
'revision':
g.Field(
g.NN(WagtailPageRevision),
args=g.arguments({'id': 'ID!'}),
resolve=resolve_single_revision,
),
}),
)