def save(self, *args, **kwargs):
if not self.id:
self.created_at = timezone.now()
self.created_by = get_current_user()
self.modified_at = timezone.now()
self.modified_by = get_current_user()
return super().save(*args, **kwargs)
def resolve_user_modules(self, info, **args):
# TODO: definitely not performant, but shows what we can do directly in graphene
# implement using a direct django join. Now doing definitely too many calls to db through the orm
# master data
user = get_current_user()
all_modules = list(Module.objects.all())
user_modules = []
# now calc module status
for module in all_modules:
if user.is_authenticated:
module_progress = UserModuleProgress.objects.filter(
user=user, module=module).first()
else:
module_progress = None
user_modules.append(
UserModuleNode(module_progress=module_progress,
module=module,
status=module_progress is not None))
field = relay.ConnectionField.resolve_connection(
UserModuleConnection, args, user_modules)
return field
def mutate_and_get_payload(cls, *args, **kwargs):
u = get_current_user()
if u.is_superuser:
try:
image_instance = get_object(get_image_model(), kwargs['id'])
if image_instance:
image_data = kwargs.get('image')
updated_image = update_create_instance(
image_instance, image_data, exception=['id', 'tags'])
tag_slugs = image_data.get('tag_slugs', '')
if tag_slugs is not None:
tag_slugs = [
t.strip() for t in tag_slugs.split(',')
if t.strip()
]
tags = list(Tag.objects.filter(slug__in=tag_slugs))
tag_slugs = [
t for t in tag_slugs
if t not in [e.slug for e in tags]
]
updated_image.tags.set(*(tags + tag_slugs))
if updated_image.pk:
return cls(updated_image=updated_image,
tags=Tag.objects.all())
except ValidationError as e:
errors = get_errors(e)
except Exception as e:
errors = ['Error: {}'.format(e)]
else:
errors = ['image not found']
return cls(updated_image=None, tags=None, errors=errors)
def save(self, *args, **kwargs): user = get_current_user() if user and user.is_authenticated: if not self.pk: self.created_by = user self.modified_by = user return super().save(*args, **kwargs)
def resolve_user_module_units(self, info, **args):
module_slug = args['module_slug']
# master data
user = get_current_user()
user_module_units = []
# if user.is_authenticated:
module = Module.objects.get(slug=module_slug)
# progress data
#
# TODO: change back after fix in test data generation
# module_progress = UserModuleProgress.objects.get(user=user, module=module)
#
if user.is_authenticated:
module_progress = UserModuleProgress.objects.filter(user=user, module=module).first()
# all module units
module_units = Unit.objects.filter(id__in=module.get_child_ids()).live()
for module_unit in module_units:
user_unit_progress = UserUnitProgress.objects.filter(module_progress=module_progress, unit=module_unit).first()
user_module_units.append(UserUnitNode(unit=module_unit, status=user_unit_progress is not None))
else:
module_units = Unit.objects.filter(id__in=module.get_child_ids()).live()
for module_unit in module_units:
user_module_units.append(UserUnitNode(unit=module_unit, status=False))
field = relay.ConnectionField.resolve_connection(UserUnitConnection, args, user_module_units)
return field
def resolve_images(*args, **kwargs):
# FIXME tagging app?
u = get_current_user()
if not u.is_superuser:
return get_image_model().objects.none()
return get_image_model().objects.filter(tags=None, collection__name='services').exclude(
tags__name=HIDE_FROM_SEARCH).order_by('-id')
def resolve_module_user_goal(self, info, **kwargs):
user = get_current_user()
module_slug = kwargs.get('module_slug')
if module_slug is not None and user.is_authenticated:
return UserGoal.objects.get(goal__module__slug=module_slug,
user=user)
return []
def mutate(self, info, module_slug):
current_user = get_current_user()
module = Module.objects.get(slug=module_slug)
try:
module, created = UserModuleProgress.objects.get_or_create(user=current_user, module=module)
return StartModuleProgress(created=True, module_slug=module_slug)
except Exception as ex:
return StartModuleProgress(created=False, module_slug=module_slug, failed=True, exception=ex)
def mutate(self, info, module_slug):
current_user = get_current_user()
module = Module.objects.get(slug=module_slug)
found_module_progress = UserModuleProgress.objects.filter(user=current_user, module=module)
try:
found_module_progress.delete()
return DeleteModuleProgress(deleted=True, module_slug=module_slug)
except Exception as ex:
return DeleteModuleProgress(deleted=False, module_slug=module_slug, failed=True, exception=ex)
def mutate_and_get_payload(cls, *args, **kwargs):
user_module_progress = get_object_or_404(
UserModuleProgress,
user=get_current_user(),
module__slug=kwargs.pop('module_slug')
)
for k, v in kwargs.items():
setattr(user_module_progress, k, v)
user_module_progress.save()
return cls(user_module_progress=user_module_progress)
def mutate(self, info, unit_slug, module_slug):
current_user = get_current_user()
module = Module.objects.get(slug=module_slug)
unit = Unit.objects.get(slug=unit_slug)
try:
module_progress = UserModuleProgress.objects.get(user=current_user,
module=module)
unit, created = UserUnitProgress.objects.get_or_create(
module_progress=module_progress, unit=unit)
return StartUnitProgress(created=True, unit_slug=unit_slug)
except Exception as ex:
return StartUnitProgress(created=False,
unit_slug=unit_slug,
failed=True,
exception=ex)
def mutate(self, info, module_slug, goal_level):
current_user = get_current_user()
try:
user_goal = UserGoal.objects.filter(
goal__module__slug=module_slug,
user__username=current_user.username)
found_goals = len(user_goal)
if found_goals == 1:
user_goal = list(user_goal)[0]
# we have the user goal, update it
goal = Goal.objects.get(module__slug=module_slug,
level=goal_level)
user_goal.goal = goal
user_goal.save()
return DefineUserGoal(ok=True,
message=DefineUserGoal.UPDATE,
user_goal=user_goal)
elif found_goals == 0:
# we don't have the user goal, create a new one
goal = Goal.objects.get(module__slug=module_slug,
level=goal_level)
user_goal = UserGoal(user=current_user, goal=goal)
user_goal.save()
return DefineUserGoal(ok=True,
message=DefineUserGoal.CREATE,
user_goal=user_goal)
else:
return DefineUserGoal(
ok=False,
message=
'more than 1 UserGoal for module: {} and goal-level: {} found'
.format(module_slug, goal_level))
except Exception as ex:
return DefineUserGoal(ok=False, message=ex)
def qs(self):
usr = get_current_user()
return User.objects.filter(id=usr.id)
def qs(self):
user = get_current_user()
if not user:
return model_cls.objects.none()
return super(UserFilter, self).qs.filter(user=user)
def resolve_all_modules_progress(self, info, **args):
user = get_current_user()
if user.is_authenticated:
return UserModuleProgress.objects.filter(
module__slug=args.get('module__slug'), user=user)
return UserModuleProgress.objects.none()
def resolve_tags(self):
u = get_current_user()
if not u.is_superuser:
return Tag.objects.none()
return Tag.objects.all()
def resolve_user(self, *args, **kwargs):
user = get_current_user()
if user.is_authenticated:
return user
