121 lines
5.3 KiB
Python
121 lines
5.3 KiB
Python
import logging
|
|
from django.utils.translation import gettext_lazy as _
|
|
|
|
from .geo import GeoAPI
|
|
from ..forms import AdoptionNoticeSearchForm
|
|
from ..models import SearchSubscription, AdoptionNotice, AdoptionNoticeNotification, SexChoicesWithAll, Location
|
|
|
|
|
|
def notify_search_subscribers(adoption_notice: AdoptionNotice):
|
|
"""
|
|
This functions checks for all search subscriptions if the new adoption notice fits the search.
|
|
If the new adoption notice fits the search subscription, it sends a notification to the user that created the search.
|
|
"""
|
|
for search_subscription in SearchSubscription.objects.all():
|
|
if search_subscription.adoption_notice_fits_search(adoption_notice):
|
|
notification_text = f"{_('Zu deiner Suche')} {search_subscription} wurde eine neue Vermittlung gefunden"
|
|
AdoptionNoticeNotification.objects.create(user=search_subscription.owner,
|
|
title=f"{_('Neue Vermittlung')}: {adoption_notice.title}",
|
|
adoption_notice=adoption_notice,
|
|
text=notification_text)
|
|
|
|
|
|
class Search:
|
|
def __init__(self):
|
|
self.sex = None
|
|
self.area_search = None
|
|
self.max_distance = None
|
|
self.location_string = None
|
|
self.search_position = None
|
|
self.location = None
|
|
self.place_not_found = False # Indicates that a location was given but could not be geocoded
|
|
self.search_form = None
|
|
|
|
def __str__(self):
|
|
return f"Search: {self.sex=}, {self.location=}, {self.search_position=}, {self.area_search=}, {self.max_distance=}"
|
|
|
|
def __eq__(self, other):
|
|
"""
|
|
Custom equals that also supports SearchSubscriptions
|
|
|
|
Only allowed to be called for located subscriptions
|
|
"""
|
|
return self.location.name == other.location.name and self.sex == other.sex and self.max_distance == other.max_distance
|
|
|
|
def _locate(self):
|
|
if self.location is None:
|
|
self.location = Location.get_location_from_string(self.location_string)
|
|
|
|
def adoption_notice_fits_search(self, adoption_notice: AdoptionNotice):
|
|
# Make sure sex is set and sex is not set to all (then it can be disregarded)
|
|
if self.sex is not None and self.sex != SexChoicesWithAll.ALL:
|
|
# AN does not fit search if search sex is not in available sexes of this AN
|
|
if not self.sex in adoption_notice.sexes:
|
|
return False
|
|
# make sure it's an area search and the place is found to check location
|
|
if self.area_search and not self.place_not_found:
|
|
# If adoption notice is in not in search distance, return false
|
|
if not adoption_notice.in_distance(self.search_position, self.max_distance):
|
|
return False
|
|
return True
|
|
|
|
|
|
def get_adoption_notices(self):
|
|
adoptions = AdoptionNotice.objects.order_by("-created_at")
|
|
# Filter for active adoption notices
|
|
adoptions = [adoption for adoption in adoptions if adoption.is_active]
|
|
# Check if adoption notice fits search.
|
|
adoptions = [adoption for adoption in adoptions if self.adoption_notice_fits_search(adoption)]
|
|
|
|
return adoptions
|
|
|
|
def search_from_request(self, request):
|
|
if request.method == 'POST':
|
|
self.search_form = AdoptionNoticeSearchForm(request.POST)
|
|
self.search_form.is_valid()
|
|
self.sex = self.search_form.cleaned_data["sex"]
|
|
if self.search_form.cleaned_data["location_string"] != "" and self.search_form.cleaned_data[
|
|
"max_distance"] != "":
|
|
self.area_search = True
|
|
self.location_string = self.search_form.cleaned_data["location_string"]
|
|
self.max_distance = int(self.search_form.cleaned_data["max_distance"])
|
|
|
|
geo_api = GeoAPI()
|
|
self.search_position = geo_api.get_coordinates_from_query(self.location_string)
|
|
if self.search_position is None:
|
|
self.place_not_found = True
|
|
else:
|
|
self.search_form = AdoptionNoticeSearchForm()
|
|
|
|
@staticmethod
|
|
def search_from_search_subscription(search_subscription: SearchSubscription):
|
|
search = Search()
|
|
search.sex = search_subscription.sex
|
|
search.location = search_subscription.location
|
|
search.search_position = (search_subscription.location.latitude, search_subscription.location.longitude)
|
|
search.area_search = True
|
|
search.max_distance = search_subscription.max_distance
|
|
|
|
|
|
return search
|
|
|
|
|
|
def subscribe(self, user):
|
|
logging.info(f"{user} subscribed to search")
|
|
self._locate()
|
|
SearchSubscription.objects.create(owner=user,
|
|
location=self.location,
|
|
sex=self.sex,
|
|
radius=self.max_distance)
|
|
|
|
def is_subscribed(self, user):
|
|
"""
|
|
Returns true if a user is already subscribed to a search with these parameters
|
|
"""
|
|
user_subscriptions = SearchSubscription.objects.filter(owner=user)
|
|
self._locate()
|
|
for subscription in user_subscriptions:
|
|
if self == subscription:
|
|
return True
|
|
return False
|