def mutate_and_get_payload(cls, root, info, **input):
try:
group_id = int(from_global_id(input['group_id']).type_id)
filter_group = models.SavedFilterGroup.objects.get(pk=group_id)
filter_group.state = input['state']
filter_group.group_name = input['group_name']
filter_group.save()
original_filterDetails = models.FilterDetail.objects.filter(
filter_group__pk=group_id).delete()
except Exception:
print("Error updating new filter group!")
finally:
filter_details = input['filter_details']
for filter_detail in filter_details:
filter_id = int(
from_global_id(filter_detail['filter_id']).type_id)
filter = Filter.objects.get(pk=filter_id)
detail = models.FilterDetail.objects.create(
filter_group=filter_group,
filter=filter,
state=filter_detail['state'],
first_argument=filter_detail['first_argument'],
second_argument=filter_detail['second_argument'],
third_argument=filter_detail['third_argument'],
fourth_argument=filter_detail['fourth_argument'],
fifth_argument=filter_detail['fifth_argument'])
detail.save()
return cls(filter_group=filter_group)
def mutate_and_get_payload(cls, root: Any, info: graphene.ResolveInfo,
**input_data: dict) -> 'CreatePassage':
serializer = PassageService(
data={
'name': input_data['name'],
'description': input_data['description'],
'is_ending': input_data['is_ending'],
'story_id': from_global_id(input_data['story_id']).type_id,
'character_id': from_global_id(
input_data['character_id']).type_id,
})
serializer.is_valid(raise_exception=True)
passage = serializer.save()
return cls(passage=passage)
def mutate_and_get_payload(cls, root: Any, info: graphene.ResolveInfo,
**input_data: dict) -> 'UpdateStory':
story = from_global_id(input_data['story_id'])
serializer = StoryService.for_instance(
story.type_id,
data={
'title': input_data['title'],
'subtitle': input_data['subtitle'],
'description': input_data['description'],
'published_year': input_data['published_year'],
'author_id': from_global_id(input_data['author_id']).type_id
})
serializer.is_valid(raise_exception=True)
story = serializer.save()
return cls(story=story)
def mutate_and_get_payload(cls, root: Any, info: graphene.ResolveInfo,
**input_data: dict) -> 'CreateChoice':
serializer = ChoiceService(
data={
'description':
input_data['description'],
'is_main_story':
input_data['is_main_story'],
'from_passage_id':
from_global_id(input_data['from_passage_id']).type_id,
'to_passage_id':
from_global_id(input_data['to_passage_id']).type_id,
})
serializer.is_valid(raise_exception=True)
choice = serializer.save()
return cls(choice=choice)
def mutate_and_get_payload(cls, root, info, **input):
try:
member = info.context.user.member
filter_group_state = "notify"
filter_group = models.SavedFilterGroup.objects.create(
member=member,
group_name=input['group_name'],
state=filter_group_state)
filter_group.save()
filter_details = input['filter_details']
for filter_detail in filter_details:
filter_id = int(
from_global_id(filter_detail['filter_id']).type_id)
filter = Filter.objects.get(pk=filter_id)
detail = models.FilterDetail.objects.create(
filter_group=filter_group,
filter=filter,
state=filter_detail['state'],
first_argument=filter_detail['first_argument'],
second_argument=filter_detail['second_argument'],
third_argument=filter_detail['third_argument'],
fourth_argument=filter_detail['fourth_argument'],
fifth_argument=filter_detail['fifth_argument'])
detail.save()
except Exception:
return "Error creating new filter group!"
return cls(filter_group=filter_group)
def mutate_and_get_payload(cls, root: Any, info: graphene.ResolveInfo,
**input_data: dict) -> 'UpdateCharacter':
decoded = from_global_id(input_data['character_id'])
serializer = CharacterService.for_instance(
decoded.type_id, data={'name': input_data['name']})
serializer.is_valid(raise_exception=True)
character = serializer.save()
return cls(character=character)
def test_to_global_id__can_be_decoded_from_default_name(self):
class TypeWithGlobalIDWithoutName(graphene.ObjectType):
class Meta:
interfaces = (graphene.Node, )
encoded = to_global_id(TypeWithGlobalIDWithoutName, 3)
decoded = from_global_id(encoded)
self.assertEqual(decoded, GlobalID('TypeWithGlobalIDWithoutName', 3))
def mutate_and_get_payload(cls, root, info, **input):
# try:
_id = int(from_global_id(input['id']).type_id)
following = models.Following.objects.get(pk=_id)
following.state = input['state']
following.save()
# except Exception:
# return "Update failed!"
return cls(following=following)
def mutate_and_get_payload(cls, root, info, **input):
try:
_id = int(from_global_id(input['id']).type_id)
following = models.Following.objects.get(pk=_id)
following.delete()
ok = True
except Exception:
ok = False
return cls(ok=ok)
def mutate_and_get_payload(cls, root, info, **input):
try:
filter_id = int(from_global_id(input['id']).type_id)
filter_group = models.SavedFilterGroup.objects.get(pk=filter_id)
filter_group.delete()
ok = True
except Exception:
ok = False
return cls(ok=ok)
def test_to_global_id__can_be_decoded_from_type_name(self):
class TypeWithGlobalIDAndName(graphene.ObjectType):
class Meta:
interfaces = (graphene.Node, )
name = 'WithGlobalID'
encoded = to_global_id(TypeWithGlobalIDAndName, 2)
decoded = from_global_id(encoded)
self.assertEqual(decoded, GlobalID('WithGlobalID', 2))
def mutate_and_get_payload(cls, root, info, **input):
try:
filter_detail_id = int(
from_global_id(input['filter_detail_id']).type_id)
filter_detail = models.FilterDetail.objects.get(
pk=filter_detail_id)
filter_group = filter_detail.filter_group
filter_detail.delete()
return cls(filter_group=filter_group)
except Exception:
return "Failed to delete filter detail!"
def mutate_and_get_payload(cls, root, info, **input):
try:
group_id = int(from_global_id(input['group_id']).type_id)
filter_group = models.SavedFilterGroup.objects.get(pk=group_id)
filter_id = int(
from_global_id(input['filter_detail']['filter_id']).type_id)
filter = Filter.objects.get(pk=filter_id)
filter_detail = models.FilterDetail.objects.create(
filter_group=filter_group,
filter=filter,
state=input['filter_detail']['state'],
first_argument=input['filter_detail']['first_argument'],
second_argument=input['filter_detail']['second_argument'],
third_argument=input['filter_detail']['third_argument'],
fourth_argument=input['filter_detail']['fourth_argument'],
fifth_argument=input['filter_detail']['fifth_argument'])
filter_detail.save()
return cls(filter_group=filter_group)
except Exception:
return "Failed to create filter detail!"
def mutate_and_get_payload(cls, root: Any, info: graphene.ResolveInfo,
**input_data: dict) -> 'UpdateAuthor':
author = from_global_id(input_data['author_id'])
serializer = AuthorService.for_instance(
author.type_id,
data={
'first_name': input_data['first_name'],
'last_name': input_data['last_name'],
'twitter_account': input_data['twitter_account'],
})
serializer.is_valid(raise_exception=True)
author = serializer.save()
return cls(author=author)
def mutate_and_get_payload(cls, root: Any, info: graphene.ResolveInfo,
**input_data: dict) -> 'UpdateFilter':
filter_id = int(from_global_id(input_data['filter_id']).type_id)
serializer = FilterService.for_instance(
filter_id,
data={
'category': input_data['category'],
'filter_name': input_data['filter_name'],
'filter_content': input_data['filter_content'],
})
serializer.is_valid(raise_exception=True)
filter = serializer.save()
return cls(filter=filter)
def mutate_and_get_payload(cls, root, info, **input):
# try:
filter_detail_id = int(
from_global_id(input['filter_detail_id']).type_id)
filter_detail = models.FilterDetail.objects.get(pk=filter_detail_id)
filter_group = filter_detail.filter_group
if 'state' in input.keys():
filter_detail.state = input['state']
if input['first_argument'] != 0.0:
filter_detail.first_argument = input['first_argument']
if input['second_argument'] != 0.0:
filter_detail.second_argument = input['second_argument']
if input['third_argument'] != 0.0:
filter_detail.third_argument = input['third_argument']
if input['fourth_argument'] != 0.0:
filter_detail.fourth_argument = input['fourth_argument']
if input['fifth_argument'] != 0.0:
filter_detail.fifth_argument = input['fifth_argument']
filter_detail.save()
return cls(filter_group=filter_group)
def mutate_and_get_payload(cls, root: Any, info: graphene.ResolveInfo,
**input_data: dict) -> 'DeleteFilter':
filter_id = int(from_global_id(input_data['filter_id']).type_id)
ok = FilterService.delete(filter_id)
return cls(ok=str(ok))