308 lines
9.6 KiB
Python
308 lines
9.6 KiB
Python
from BaseModels.mailSender import techSendMail
|
|
from GeneralApp.funcs_options import get_mail_send_options
|
|
from .models import *
|
|
from .forms import *
|
|
from django.utils.translation import gettext as _
|
|
from django.template.loader import render_to_string
|
|
from datetime import datetime, timedelta
|
|
from django.db.models import F, Q
|
|
|
|
elements_on_page = 25
|
|
|
|
|
|
def get_cargo_types_by_type_transport(type_transport, form=None):
|
|
cargo_types = copy.deepcopy(cargo_type_choices)
|
|
if type_transport in ['avia']:
|
|
cargo_types = cargo_types[:2] + cargo_types[3:]
|
|
|
|
if not form:
|
|
return cargo_types
|
|
|
|
form.fields['cargo_type'].choices = cargo_types
|
|
|
|
form.base_fields['cargo_type'].choices = cargo_types
|
|
|
|
return form
|
|
|
|
|
|
|
|
def get_profile_new_route_page_html(request, data):
|
|
|
|
form = RouteForm()
|
|
Dict = {
|
|
'form': form
|
|
}
|
|
|
|
tpl = None
|
|
|
|
try:
|
|
|
|
errors_off = True
|
|
|
|
form = RouteForm(data)
|
|
if not form.is_valid():
|
|
pass
|
|
form = RouteForm(initial=form.cleaned_data)
|
|
|
|
if 'type_transport' in data:
|
|
form = get_cargo_types_by_type_transport(data['type_transport'], form)
|
|
|
|
|
|
if 'owner_type' in data:
|
|
form.initial['owner_type'] = data['owner_type']
|
|
|
|
if data['owner_type'] == 'mover':
|
|
tpl = 'v2/blocks/b_make_mover_order.html'
|
|
form.fields['type_transport'].choices = type_transport_choices[:-1]
|
|
else:
|
|
tpl = 'v2/blocks/b_make_customer_route.html'
|
|
form.fields['type_transport'].choices = type_transport_choices
|
|
|
|
Dict.update({'owner_type': data['owner_type']})
|
|
|
|
|
|
if request.user and request.user.is_authenticated and request.user.user_profile and request.user.user_profile.phone:
|
|
form.initial.update({'phone': request.user.user_profile.phone})
|
|
|
|
Dict = {
|
|
'form': form,
|
|
'errors_off': errors_off
|
|
}
|
|
|
|
|
|
# print(form)
|
|
except Exception as e:
|
|
# form.errors.append({'__all__': f'Ошибка: {str(e)}'})
|
|
print(str(e))
|
|
|
|
html = render_to_string(tpl, Dict, request=request)
|
|
return html
|
|
|
|
|
|
# def get_country_n_city_str_by_type_transport_and_address_point(type_transport, address_point):
|
|
# city = get_city_by_type_transport_and_address_point(type_transport, address_point)
|
|
# return city.get_country_n_city_str()
|
|
|
|
|
|
def get_city_by_type_transport_and_address_point(type_transport, address_point):
|
|
from ReferenceDataApp.models import Airport, City
|
|
|
|
try:
|
|
if type_transport == 'avia':
|
|
return Airport.objects.get(id=address_point).city
|
|
else:
|
|
return City.objects.get(id=address_point)
|
|
except Exception as e:
|
|
msg = f'get_city_by_type_transport_and_address_point Error = {str(e)}, type_transport = {type_transport}, address_point = {address_point}'
|
|
print(msg)
|
|
return None
|
|
|
|
def get_city_by_address_point(address_point):
|
|
from ReferenceDataApp.models import Airport, City
|
|
|
|
try:
|
|
return City.objects.get(id=address_point)
|
|
except Exception as e:
|
|
msg = f'get_city_by_address_point Error = {str(e)}, address_point = {address_point}'
|
|
print(msg)
|
|
return None
|
|
|
|
|
|
def get_profile_my_routes_page_content_html(request):
|
|
routes_Dict = get_routes_Dict(request.user)
|
|
if 'errors' in routes_Dict:
|
|
msg = f'get_my_routes_page_content_html errors = {str(routes_Dict)}'
|
|
print(msg)
|
|
return msg
|
|
|
|
from SubscribesApp.funcs import get_cur_user_subscribe
|
|
user_subscribe = get_cur_user_subscribe(request.user)
|
|
if user_subscribe:
|
|
routes_Dict.update(user_subscribe.remains_route_adding_options())
|
|
|
|
html = render_to_string('v2/blocks/b_my_routes.html', routes_Dict, request=request)
|
|
return html
|
|
|
|
|
|
def get_routes_Dict(user=None, data=None):
|
|
from ReferenceDataApp.models import Airport, Country, City
|
|
|
|
# if not user and user.is_authenticated:
|
|
# errors_Dict = {
|
|
# 'errors': {
|
|
# 'all__': f'ошибка идентификации пользователя'
|
|
# }
|
|
# }
|
|
# return errors_Dict
|
|
kwargs = {}
|
|
if user:
|
|
kwargs.update({
|
|
'owner': user
|
|
})
|
|
|
|
|
|
from_el = None
|
|
to_el = None
|
|
|
|
res_Dict = {}
|
|
|
|
if data:
|
|
|
|
type_transport = None
|
|
if 'type_transport' in data and data['type_transport']:
|
|
items_list = data['type_transport'].split(',')
|
|
kwargs.update({f'type_transport__in': items_list})
|
|
|
|
if len(items_list) == 1:
|
|
type_transport = items_list[0]
|
|
|
|
|
|
for key, val in data.items():
|
|
if val:
|
|
if key == 'weight':
|
|
weight_list = val.split(';')
|
|
if len(weight_list) > 1:
|
|
if weight_list[0]:
|
|
kwargs.update({f'{key}__gte': int(weight_list[0])})
|
|
if weight_list[1]:
|
|
kwargs.update({f'{key}__lte': int(weight_list[1])})
|
|
else:
|
|
kwargs.update({f'{key}__lte': int(weight_list[0])})
|
|
|
|
# if key == 'type_transport':
|
|
# items_list = val.split(',')
|
|
# kwargs.update({f'{key}__in': items_list})
|
|
|
|
|
|
if key in (
|
|
'departure_DT', 'arrival_DT'
|
|
):
|
|
dates = val.split(' - ')
|
|
kwargs.update({
|
|
f'{key}__date__gte': datetime.strptime(dates[0], '%d.%m.%Y'),
|
|
f'{key}__date__lte': datetime.strptime(dates[1], '%d.%m.%Y').replace(hour=23, minute=59, second=59)
|
|
})
|
|
|
|
if key not in (
|
|
'from_address_point_txt', 'to_address_point_txt', 'csrfmiddlewaretoken', 'sort', 'weight',
|
|
'from_el', 'to_el', 'from_address_point', 'to_address_point', 'type_transport',
|
|
'departure_DT', 'arrival_DT'
|
|
):
|
|
kwargs.update({key: val})
|
|
|
|
if key == 'from_address_point': # в from_address_point всегда город
|
|
# city = get_city_by_type_transport_and_address_point(type_transport, val)
|
|
city = get_city_by_address_point(val)
|
|
kwargs.update({f'from_city': city})
|
|
|
|
|
|
res_Dict.update({
|
|
'from_address_point_txt': city.get_country_n_city_str()
|
|
})
|
|
|
|
if key == 'to_address_point': # в to_address_point всегда город
|
|
# city = get_city_by_type_transport_and_address_point(type_transport, val)
|
|
city = get_city_by_address_point(val)
|
|
kwargs.update({f'to_city': city})
|
|
res_Dict.update({
|
|
'to_address_point_txt': city.get_country_n_city_str()
|
|
})
|
|
|
|
if key == 'from_el':
|
|
from_el = int(val)
|
|
if key == 'to_el':
|
|
to_el = int(val)
|
|
|
|
# rising_routes = Route.objects.filter(
|
|
# **kwargs,
|
|
# ).exclude(
|
|
# rising_DT=None
|
|
# ).order_by(
|
|
# '-rising_DT', '-departure_DT', '-arrival_DT', '-modifiedDT'
|
|
# )
|
|
# routes = Route.objects.exclude(
|
|
# rising_DT=None
|
|
# ).filter(
|
|
# departure_DT__lt=datetime.now()
|
|
# )
|
|
# routes.update(
|
|
# rising_DT=None
|
|
# )
|
|
|
|
routes_rising_off = Route.objects.exclude(rising_DT=None).filter(
|
|
Q(rising_DT__lt=datetime.now() - timedelta(days=1)) | Q(departure_DT__lt=datetime.now())
|
|
)
|
|
if routes_rising_off:
|
|
routes_rising_off.update(rising_DT=None)
|
|
|
|
routes = Route.objects.filter(
|
|
**kwargs
|
|
).order_by(
|
|
F('rising_DT').desc(nulls_last=True),
|
|
# '-rising_DT',
|
|
'-departure_DT', '-arrival_DT', '-modifiedDT'
|
|
)
|
|
|
|
routes_count = routes.count()
|
|
|
|
|
|
|
|
|
|
if from_el and to_el:
|
|
routes = routes[from_el:to_el]
|
|
elif from_el:
|
|
routes = routes[from_el:]
|
|
elif to_el:
|
|
routes = routes[:to_el]
|
|
else:
|
|
to_el = elements_on_page
|
|
routes = routes[:to_el]
|
|
|
|
last_block = False
|
|
if not to_el or to_el >= routes_count:
|
|
last_block = True
|
|
|
|
if routes_count - to_el > elements_on_page:
|
|
next_page_els_count = elements_on_page
|
|
else:
|
|
next_page_els_count = routes_count - to_el
|
|
|
|
try:
|
|
|
|
# for route in routes:
|
|
#
|
|
# try:
|
|
#
|
|
# if route.type_transport == 'avia':
|
|
# route.from_airport = Airport.objects.get(id=route.from_address_point)
|
|
# route.to_airport = Airport.objects.get(id=route.to_address_point)
|
|
# route.from_city = route.from_airport.city
|
|
# route.to_city = route.to_airport.city
|
|
# else:
|
|
# route.from_city = City.objects.get(id=route.from_address_point)
|
|
# route.to_city = City.objects.get(id=route.to_address_point)
|
|
#
|
|
# route.from_country = route.from_city.country
|
|
# route.to_country = route.to_city.country
|
|
# except Exception as e:
|
|
# msg = f'get_routes_for_user get route Error = {str(e)}'
|
|
# print(msg)
|
|
|
|
res_Dict.update({
|
|
'routes': routes,
|
|
'last_block': last_block,
|
|
'last_el': to_el,
|
|
'next_page_els_count': next_page_els_count
|
|
})
|
|
return res_Dict
|
|
|
|
|
|
except Exception as e:
|
|
msg = f'get_routes_for_user = {str(e)}'
|
|
print(msg)
|
|
errors_Dict = {
|
|
'errors': {
|
|
'all__': msg
|
|
}
|
|
}
|
|
return errors_Dict |