def addresses_from_persons(queryset, user):
entities = EntityCredentials.filter(user,
queryset.filter(is_deleted=False))
addresses = get_address_model().objects.filter(
content_type=ContentType.objects.get_for_model(queryset.model))
# get address ids which owner has billing or shipping or both
billing_shipping_ids = {
owner: billing or shipping
for owner, billing, shipping in entities.filter(
Q(billing_address__isnull=False)
| Q(shipping_address__isnull=False)).values_list(
'pk', 'billing_address', 'shipping_address')
}
# get address ids which owner without billing nor shipping
address_ids = {
owner: pk
for owner, pk in addresses.filter(object_id__in=entities.filter(
billing_address__isnull=True,
shipping_address__isnull=True,
).values_list('pk', flat=True)).order_by('-pk').values_list(
'object_id', 'pk')
}
# merge ids
address_ids.update(billing_shipping_ids)
return addresses.filter(
pk__in=address_ids.values()) # TODO: select_related('geoaddress') ??
def copy_or_create_address(address, owner, name):
if address is None:
name = str(name)
return get_address_model().objects.create(name=name,
owner=owner,
address=name)
return address.clone(owner)
def all_apps_ready(self):
from creme import persons
self.Contact = persons.get_contact_model()
self.Organisation = persons.get_organisation_model()
self.Address = persons.get_address_model()
super().all_apps_ready()
self.hook_user()
self.hook_user_form()
from . import signals
def all_apps_ready(self):
from creme import persons
self.Contact = persons.get_contact_model()
self.Organisation = persons.get_organisation_model()
self.Address = persons.get_address_model()
super().all_apps_ready()
self.hook_user()
self.hook_user_form()
from . import signals # NOQA
if apps.is_installed('creme.reports'):
self.register_reports_graph_fetchers()
def to_python(self, value):
if not value:
return Q()
# TODO: remove not-editable fields ??
# TODO: factorise with mass_import
address_field_names = [*get_address_model().info_field_names()]
try:
address_field_names.remove('name')
except ValueError:
pass
fk_name = self.cell.value
q = Q()
for fname in address_field_names:
q |= Q(**{f'{fk_name}__{fname}__icontains': value})
return q
def get_neighbours(request):
GET = request.GET
address_id = get_from_GET_or_404(GET, 'address_id', int)
filter_id = get_from_GET_or_404(GET, 'filter_id', default=None)
source = get_object_or_404(get_address_model(), id=address_id)
distance = get_radius()
entity_filter = get_object_or_404(EntityFilter,
id=filter_id) if filter_id else None
query_distance = GET.get('distance', '')
if query_distance.isdigit():
distance = float(query_distance)
neighbours = source.geoaddress.neighbours(distance).select_related(
'address')
if entity_filter:
model = entity_filter.entity_type.model_class()
# filter owners of neighbours
owner_ids = entity_filter.filter(
model.objects.filter(
is_deleted=False,
pk__in=neighbours.values_list('address__object_id', flat=True),
)).values_list('pk', flat=True)
neighbours = neighbours.filter(
address__content_type=ContentType.objects.get_for_model(model),
address__object_id__in=owner_ids,
)
# Filter credentials
has_perm = request.user.has_perm_to_view
addresses = [
address_as_dict(neighbor.address) for neighbor in neighbours
if has_perm(neighbor.address.owner)
]
return {
'source_address': address_as_dict(source),
'addresses': addresses,
}
def set_address_info(request):
get = partial(get_from_POST_or_404, request.POST)
address = get_object_or_404(
get_address_model().objects.select_for_update(),
id=get('id', cast=int),
)
request.user.has_perm_to_change_or_die(address.owner)
data = {
'latitude': get('latitude'),
'longitude': get('longitude'),
'geocoded': get('geocoded').lower() == 'true',
'status': get('status'),
}
try:
address.geoaddress.update(**data)
except GeoAddress.DoesNotExist:
GeoAddress.objects.create(address=address, **data)
return HttpResponse()
from functools import partial
from django.apps import apps
from django.contrib.contenttypes.models import ContentType
from django.urls import reverse
from django.utils.translation import gettext as _
from creme.creme_core.constants import DEFAULT_VAT
from creme.creme_core.models import Currency, Vat
from creme.creme_core.tests.base import CremeTestCase, skipIfNotInstalled
from creme.persons import get_address_model, get_organisation_model
from .base import CTYPE_KEY, RecurrentGenerator, skipIfCustomGenerator
Address = get_address_model()
Organisation = get_organisation_model()
if apps.is_installed('creme.billing'):
from creme.billing import (
get_credit_note_model,
get_invoice_model,
get_quote_model,
get_sales_order_model,
get_template_base_model,
)
from creme.billing.models import (
CreditNoteStatus,
InvoiceStatus,
QuoteStatus,
SalesOrderStatus,
from creme import persons
from creme.creme_core.gui.bricks import Brick, BrickDependencies
from creme.creme_core.models import EntityFilter
from .models import GeoAddress
from .utils import (
address_as_dict,
get_google_api_key,
get_openstreetmap_settings,
get_radius,
)
Contact = persons.get_contact_model()
Organisation = persons.get_organisation_model()
Address = persons.get_address_model()
class _MapBrick(Brick):
dependencies: BrickDependencies = (Address, )
def get_filter_choices(self, user, *models):
choices = []
get_ct = ContentType.objects.get_for_model
ctypes = [get_ct(model) for model in models]
efilters_per_ctid = defaultdict(list)
for efilter in EntityFilter.objects.filter_by_user(user)\
.filter(entity_type__in=ctypes):
efilters_per_ctid[efilter.entity_type_id].append(efilter)
def populate_addresses(self, verbosity=0):
self.sysout('Populate geolocation information of addresses...',
verbosity > 0)
# GeoAddress.populate_geoaddresses(get_address_model().objects.filter(Q(zipcode__isnull=False) | Q(city__isnull=False)))
GeoAddress.populate_geoaddresses(get_address_model().objects.exclude(
zipcode='', city=''))
def populate_addresses(self, verbosity=0):
self.sysout('Populate geolocation information of addresses...',
verbosity > 0)
GeoAddress.populate_geoaddresses(get_address_model().objects.exclude(
zipcode='', city=''))
