class wagtailCollectionPermissions(helpers.BaseField):
WagtailCollectionPermission = g.ObjectType(
'WagtailCollectionPermission',
fields=g.fields({
'id': 'ID!',
'permission': g.NN(AuthPermission),
'collection': g.NN(wagtail_types.WagtailCollection),
}),
)
permissions = []
def resolve(self, group, info):
return group.collection_permissions.all()
result = g.NNList(WagtailCollectionPermission)
class zadarmaPbxCall(helpers.BaseField):
permissions = [staffonly]
args = {'pbx_call_id': 'ID!'}
result = g.NN(types.ZadarmaPbxCall)
def resolve(self, _, info, pbx_call_id):
return models.PbxCall.objects.get(pk=pbx_call_id)
class cashierPayments(helpers.BaseField):
permissions = [staffonly]
args = helpers.connection_args()
result = g.NN(CashierPaymentConnection)
def resolve(self, _, info, **pager):
return models.Payment.objects.relay_page(**pager) # FIXME - order
class ratioTicket(helpers.BaseField):
def resolve(self, _, info, id):
return models.Ticket.objects.get(pk=id)
permissions = PERMISSIONS
args = {'id': 'ID!'}
result = g.NN(types.RatioTicket)
class cm2Order(helpers.BaseField):
def resolve(self, _, info, id):
return models.Order.objects.get(pk=id)
args = {'id': 'ID!'}
result = g.NN(types.Cm2Order)
permissions = [staffonly]
class staffMember(helpers.BaseField):
permissions = [permissions.staffonly]
args = {'id': 'ID!'}
result = g.NN(types.StaffMember)
def resolve(self, _, info, id):
return models.Member.objects.get(pk=id)
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 mastermindDatingCreateCohort(helper):
@check_permissions([staffonly])
def resolve(_, info):
cohort = models.Cohort.objects.create()
return {'cohort': cohort}
return g.Field(g.NN(CohortMutationResult), resolve=resolve)
class ratioTrainingBySlug(helpers.BaseField):
def resolve(self, _, info, slug):
return models.Training.objects.get(slug=slug)
permissions = PERMISSIONS
args = {'slug': str}
result = g.NN(types.RatioTraining)
class cm2CreateCustomer(helpers.BaseFieldWithInput):
def resolve(self, _, info, input):
return models.Customer.objects.create(**input)
permissions = [staffonly]
input = {'card_id': int, 'first_name': str, 'last_name': str}
result = g.NN(types.Cm2Customer)
class eventAnnounce(helpers.BaseFieldWithInput):
def resolve(self, _, info, input):
event = models.Event.objects.get(uuid=input['event_id'])
assert event.event_type == 'public'
target = input['target']
if target == 'VK':
event.vk_announcement.announce()
elif target == 'FB':
event.fb_announcement.announce()
elif target == 'TIMEPAD':
event.timepad_announcement.announce()
else:
raise Exception(f"Unknown target {target}")
event.notify_update()
return {
'ok': True,
'event': event,
}
permissions = [permissions.manage_events]
input = {
'event_id': 'ID!',
'target': g.NN(EventAnnounceTarget),
}
result = EventUpdateResult
class ratioOrders(helpers.BaseField):
def resolve(self, _, info, **pager):
return models.Order.objects.relay_page(order='-created', **pager)
permissions = PERMISSIONS
args = helpers.connection_args()
result = g.NN(types.RatioOrderConnection)
class updateRatioTicketType(helpers.BaseFieldWithInput):
def resolve(self, _, info, input):
ticket_type = models.TicketType.objects.get(uuid=input['id'])
for field in (
'price',
'name',
'discount_by_email',
'discount_percent_by_email',
):
if input.get(field) is not None:
setattr(ticket_type, field, input[field])
ticket_type.full_clean()
ticket_type.save()
return ticket_type
permissions = [user_perm('ratio.manage')]
input = {
'id': 'ID!',
'price': Optional[int],
'name': Optional[str],
'discount_by_email': Optional[int],
'discount_percent_by_email': Optional[int],
}
result = g.NN(types.RatioTicketType)
class events(helpers.BaseField):
def resolve(self, obj, info, search=None, filter=None, **pager):
qs = models.Event.objects.all()
if not info.context.user.is_staff:
# only staff can access old anticafe events which might include personal data (phone numbers, emails)
qs = qs.exclude_anticafe_dates()
if search:
qs = qs.filter(
title__icontains=search
) # TODO - use wagtail/elastic search instead
if filter:
if 'event_type' in filter:
qs = qs.filter(event_type=filter['event_type'])
return qs.relay_page(order='start', **pager)
permissions = [permissions.manage_events]
FilterInput = g.InputObjectType(
'EventsFilterInput', g.input_fields({'event_type': Optional[str]})
)
args = {**helpers.connection_args(), 'search': Optional[str], 'filter': FilterInput}
result = g.NN(types.EventConnection)
class updateRatioTicket(helpers.BaseFieldWithInput):
def resolve(self, _, info, input):
ticket = models.Ticket.objects.get(pk=input['id'])
for field in (
'first_name',
'last_name',
'notion_link',
):
if input.get(field) is not None:
setattr(ticket, field, input[field])
if input.get('ticket_type') is not None:
ticket_type_id = input['ticket_type']
ticket_type = models.TicketType.objects.get(uuid=ticket_type_id)
ticket.ticket_type = ticket_type
ticket.full_clean()
ticket.save()
return ticket
permissions = [user_perm('ratio.manage')]
input = {
'id': 'ID!',
'first_name': Optional[str],
'last_name': Optional[str],
'notion_link': Optional[str],
'ticket_type': 'ID',
}
result = g.NN(types.RatioTicket)
class ratioAddTicket(helpers.BaseFieldWithInput):
def resolve(self, _, info, input):
training_id = input.pop('training')
training = models.Training.objects.get(pk=training_id)
ticket_type_id = input.pop('ticket_type', None)
ticket_type = None
if ticket_type_id:
ticket_type = models.TicketType.objects.get(uuid=ticket_type_id)
ticket = models.Ticket.objects.create(
**input,
training=training,
ticket_type=ticket_type,
)
return ticket
permissions = [user_perm('ratio.manage')]
input = {
'training': 'ID!', # TODO - remove and derive from ticket_type
'ticket_type': 'ID', # TODO - required
'email': str,
'first_name': Optional[str],
'last_name': Optional[str],
'payment_amount': int,
'ticket_class': Optional[str],
'comment': Optional[str],
}
result = g.NN(types.RatioTicket)
def events(_):
async def subscribe(obj, info):
# check permissions
await sync_to_async(permissions.manage_events,
thread_sensitive=True)(obj, info)
async for msg in channels.update_group.subscribe():
logger.debug('Event update: ' + str(msg))
yield msg
@check_permissions([permissions.manage_events])
def resolve(msg, info):
logger.debug(info.context)
if not msg:
# this can happen if we invoke subscription via HTTP due to incorrectly configured Apollo client & link
logger.error('weird, msg is empty')
return # this will cause an exception anyway since `events` result is non-nullable
# It'd be better to yield event, but it's problematic because all other resolver are sync
# and Django ORM can't be called in async context.
return {
'type': msg['type'],
'id': msg['uuid'],
}
return g.Field(g.NN(EventNotification),
resolve=resolve,
subscribe=subscribe)
def build_comments_count_field(permissions: List[helpers.PermissionType]):
def resolve(obj, info, **pager):
assert isinstance(obj, models.Commentable)
return obj.comments.count()
result = g.NN(g.Int)
return g.Field(result, resolve=check_permissions(permissions)(resolve))
class imageTemplateBySlug(helpers.BaseField):
def resolve(self, _, info, slug):
return models.Template.by_name(slug)
permissions = [staffonly]
args = {'slug': str}
result = g.NN(types.ImageTemplate)
class ofdDocuments(helpers.BaseField):
def resolve(self, _, info, **pager):
return models.OfdDocument.objects.relay_page(**pager)
permissions = [user_perm('kkm.ofd')]
args = helpers.connection_args()
result = g.NN(types.OfdDocumentConnection)
class authLogout(helpers.BaseField):
permissions = [authenticated]
result = g.NN(
g.ObjectType('AuthLogoutResult', g.fields({'ok': Optional[bool]})))
def resolve(self, _, info):
logout(info.context)
return {'ok': True}
class closeKkmShift(helpers.BaseField):
def resolve(self, _, info):
models.Controller.load().close_shift()
return {'ok': True}
permissions = [user_perm('kkm.kkmserver')]
result = g.NN(basic_types.BasicResult)
class ratioTestimonials(helpers.BaseField):
def resolve(self, _, info, **pager):
return models.Testimonial.objects.select_related('product').relay_page(
**pager)
permissions = []
args = helpers.connection_args()
result = g.NN(types.RatioTestimonialConnection)
class eventsPrototype(helpers.BaseField):
def resolve(self, obj, info, id):
return models.EventPrototype.objects.get(pk=id)
permissions = [permissions.manage_events]
args = {'id': 'ID!'}
result = g.NN(types.EventsPrototype)
class eventsWeeklyDigestCurrent(helpers.BaseField):
def resolve(self, obj, info):
digest = models.WeeklyDigest.objects.current_digest()
digest.create_image_if_necessary()
return digest
permissions = [permissions.manage_events]
result = g.NN(types.EventsWeeklyDigest)
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)
class deleteAuthGroup(helpers.BaseField):
def resolve(self, _, info, id):
group = auth_models.Group.objects.get(pk=id)
group.delete()
return {'ok': True}
permissions = [user_perm('auth.audit')]
args = {'id': 'ID!'}
result = g.NN(basic_types.BasicResult)
class createAuthGroup(helpers.BaseField):
def resolve(self, _, info, name):
group = auth_models.Group.objects.create(name=name)
group.full_clean()
return group
permissions = [user_perm('auth.audit')]
args = {'name': str}
result = g.NN(types.AuthGroup)
class ratioPaymentDelete(helpers.BaseField):
def resolve(self, _, info, payment_id):
payment = models.Payment.objects.get(pk=payment_id)
payment.delete()
return {'ok': True}
permissions = [user_perm('ratio.manage')]
args = {'payment_id': 'ID!'}
result = g.NN(basic_types.BasicResult)
class promocodes(helpers.BaseField):
def resolve(self, obj, info, **pager):
return models.Promocode.objects.filter(
ticket_type_promocodes=obj.pk).relay_page(**pager)
permissions = [user_perm('ratio.manage')]
args = helpers.connection_args()
result = g.NN(RatioPromocodeConnection)
