def get_plan(user):
"""
Return the plan of user.
"""
if not has_user_related(user):
return ""
return get_user_related(user).plan
def user_type(value):
"""
Return the user type of a request.user object.
"""
if not has_user_related(value):
return False
return get_user_related(value).__class__.__name__
def check_auth(self, request):
"""
Allow premium users to query.
"""
if has_user_related(request.user):
user = get_user_related(request.user)
return user.is_premium
return False
def related_user(request):
"""
A context processor that returns the related user from a request.user.
:param request: the request to be processed
"""
if not has_user_related(request.user):
return {}
return {"related_user": get_user_related(request.user)}
def dehydrate(self, bundle):
"""
Make sur the user does not see the fields he has no
right to.
:param bundle: the bundle to trim
"""
if not hasattr(bundle, "request") or not models.has_user_related(bundle.request.user):
bundle.data = pick(bundle.data, *self.FIELD_ACCESS_NOT_LOGGED)
else:
user = models.get_user_related(bundle.request.user)
if not user.is_premium:
bundle.data = without(bundle.data, *self.FIELD_DENIED_BASIC)
return bundle
def search(request):
"""
Search view.
"""
data = request.POST if request.method == "POST" else request.GET
search_type = data.get("type")
if request.user.is_authenticated():
related = get_user_related(request.user)
favorites = related.favorites.all()
if not search_type and isinstance(related, Prestataire):
search_type = "famille"
else:
favorites = []
search_type = "prestataire" if search_type not in ["famille", "prestataire"] else search_type
if search_type == "famille":
FormClass = forms.FamilleSearchForm
objects = Famille.objects.filter(compute_user_visibility_filters(request.user))
template = "search/famille.html"
else:
FormClass = forms.PrestataireSearchForm
objects = Prestataire.objects.filter(compute_user_visibility_filters(request.user))
template = "search/prestataire.html"
form = FormClass({"pc": data.get("postal_code")})
if not settings.ALLOW_BASIC_PLAN_IN_SEARCH:
objects = objects.filter(plan=UserInfo.PLANS["premium"])
if data.get("postal_code"):
objects = objects.filter(Q(postal_code=data["postal_code"]) | Q(city=data["postal_code"]))
objects = objects.order_by("-updated_at")
objects = [obj for obj in objects if obj.visibility_score_is_enough]
total_search_results = len(objects)
nb_search_results = min(settings.NB_SEARCH_RESULTS, total_search_results)
objects = objects[:nb_search_results]
result_template = get_result_template_from_user(request, search_type)
return render(
request, template,
get_context(
search_form=form, results=objects, result_template=result_template,
nb_search_results=nb_search_results, ordering=form.ordering_dict,
favorites=favorites, user=request.user, search_type=search_type,
max_nb_search_results=settings.NB_SEARCH_RESULTS,
total_search_results=total_search_results
)
)
def email_moderation(message):
"""
Only allow email for premium users.
:param message: the message to be sent
"""
from famille.models import get_user_related
try:
sender = get_user_related(message.sender)
except (ObjectDoesNotExist, AttributeError):
return (False, u"Votre compte ne vous permet pas d'envoyer d'email.")
if not sender.is_premium:
return (False, u"Vous devez avoir un compte premium pour accéder à cette fonctionnalité.")
return True
def profile(request, type, uid):
"""
Display the profile of a user.
A nice 404 view is shown to the user
if the profile does not exist OR the profile
is not premium.
A nice 401 view is shown to the user if the
profile didn't want to show itself to the user
or globally.
"""
if type not in ("famille", "prestataire"):
raise Http404
context = {}
if type == "famille":
ModelClass = Famille
RatingClass = FamilleRatings
RatingFormClass = forms.RatingFamilleForm
else:
ModelClass = Prestataire
RatingClass = PrestataireRatings
RatingFormClass = forms.RatingPrestataireForm
try:
user = ModelClass.objects.get(pk=uid)
except ModelClass.DoesNotExist:
return render(request, "profile/404.html", status=404)
# the user can view its own profile but others cannot if he is not premium
if request.related_user != user and not user.is_premium:
return render(request, "profile/404.html", status=404)
if not user.profile_access_is_authorized(request):
return render(request, "profile/401.html", status=401)
if has_user_related(request.user):
related_user = get_user_related(request.user)
context["related_user"] = related_user
context["favorited"] = related_user.favorites.filter(object_id=user.pk, object_type=type.title()).count()
# users cant vote for themselves or twice for a user
if user != related_user and not RatingClass.user_has_voted_for(related_user, user):
rating = RatingClass(user=user, by=related_user.simple_id)
context["rating_form"] = RatingFormClass(instance=rating)
return render(request, "profile/%s.html" % type, get_context(profile=user, **context))
def get_rating_form(profile, request_user):
"""
Return the rating form instance for a profile and
a given user. Return None in case of a problem
or the request user already voted.
:param profile: the profile to be rated
:param request_user: the request user
"""
if isinstance(profile, Famille):
RatingClass = FamilleRatings
RatingFormClass = RatingFamilleForm
else:
RatingClass = PrestataireRatings
RatingFormClass = RatingPrestataireForm
if has_user_related(request_user):
related_user = get_user_related(request_user)
if not RatingClass.user_has_voted_for(related_user, profile):
rating = RatingClass(user=profile, by=related_user.simple_id)
return RatingFormClass(instance=rating)
return None
def filters_post_sorting(self, object_list):
"""
Apply distance filtering after sorting since it returns a list.
"""
distance = self.__request.GET.get("distance__iexact")
postal_code = self.__request.GET.get("pc__iexact")
tarif = self.__request.GET.get("tarif__in")
user = self.__request.user
del self.__request
object_list = [obj for obj in object_list if obj.visibility_score_is_enough]
if tarif and len(tarif.split(",")) == 2:
object_list = self.filter_tarif(tarif.split(","), object_list)
if postal_code:
return self.filter_postal_code(postal_code, object_list)
if not distance or not models.user_is_located(user):
return object_list
related = models.get_user_related(user)
return self.filter_distance(distance, related.geolocation, object_list)
def get_related(value):
"""
Returns the related user of a request.user.
"""
return get_user_related(value)
def test_get_user_related(self):
self.assertIsInstance(models.get_user_related(self.user1), models.Famille)
self.assertIsInstance(models.get_user_related(self.user2), models.Prestataire)
self.assertRaises(ObjectDoesNotExist, models.get_user_related, self.user3)
def wrapped(request, *args, **kwargs):
try:
request.related_user = get_user_related(request.user)
except ObjectDoesNotExist:
raise Http404
return func(request, *args, **kwargs)
