def get_messages(request, order, next_messages=0):
dict_addition_for_message={}
last_messages = int(next_messages)+20
# dbl.log("22" )
dbl.log("22 некст аалааьа " + str(next_messages))
chat_list = Chat.objects.filter(order_id = order.id).order_by('-date')[int(next_messages):last_messages]
count = len(chat_list)
# Лист приложений
list_additions = []
for one_message in chat_list:
# dbl.log("4444" )
addition_list = Chat_Addition.objects.filter(chat_id=one_message.id)
# Добавление элемента в словарь
dict_addition_for_message[one_message] = addition_list
message_block = render_message_block( request, dict_addition_for_message )
return message_block, count
def client_feedback(request):
# ЗДЕСЬ БУДЕТ ПРОВЕРКА АУТЕНТИФИКАЦИИ
# if request.user.is_authenticated:
# pass
# client = User.objects.get(user=request.user)
# else:
# client = ''
client = ''
# Получение данных из формы в переменную
form = FeedbackForm(request.POST)
# Получение данных из формы и сохранение в бд
if request.method == "POST":
try:
# Здесь автоматически проверяются все поля формы методами clean_...
if form.is_valid():
# Сохранение запроса (происходит тогда, когда все поля валидны)
form.save()
return redirect('feedback:feedback_success')
except Exception as error:
pass
dbl.log("Ошибка работы с фидбеком" + str(error))
return render(request, 'review/feedback.html', {
'client': client,
'form': form
})
def add_pay(request):
# Получение данных из формы в переменную
form = PayForm(request.GET)
data = {'status': 'no'}
if form.is_valid():
try:
pay = Pay()
# Заполнение полей модели
order_id = form.cleaned_data['order_id']
order = Order.objects.get(id=int(order_id))
pay.order = order
pay.amount = form.cleaned_data['amount']
pay.save()
# Получения суммы оплат по данному заказу и обновление paid_amount
amount = Pay.get_payment_of_order(order.id)
order.paid_amount = amount
order.save()
data = {'status': 'ok'}
# except :
# pass
except Exception as error:
pass
dbl.log("Ошибка работы " + str(error))
return HttpResponse(json.dumps(data), content_type='application/json')
def software_download(request, software_id):
form = Register_by_email_phone_Form()
url_to_download = ""
try:
# Объявление начальных значений
user = None
cookie = {}
# Получение текущего пользователя
user, cookie = CustomUser.get_user_or_create(request)
if user:
software = Software.objects.get(id=int(software_id))
# if software:
# Строка запроса к платежной системе
# url_to_download = "/software_id=" + str(software.pk) + "&amount=" + str(software.cost)
response = render(request, 'soft/download.html', {
'software': software,
'user': user
})
response = util.views.wrap_cookie(response, cookie)
return response
except Exception as error:
pass
dbl.log("Ошибка работы " + str(error))
return redirect('software:catalog')
def chat(request, id):
# Объявление начальных значений переменных
order = None
try:
# Проверка принадлежности запрашиваемого заказа к текущему пользователю
# Получения пользователя
user = CustomUser.get_user(request)
if user:
# Получение заказа
order = Order.get_order_by_client(id, user)
# Получение пременных из запроса
next_messages = request.GET.get('next', None)
# count_messages = request.GET.get('count', None)
# Тогда просто отрисовывается страница чата с полседними 20 сообщениями
if next_messages == None:
dbl.log("111" )
next_messages = 0
message_block, count = get_messages(request, order, next_messages=next_messages)
next_messages = 20
return render(request, 'order/chat.html', {'order':order, 'message_block':message_block})
# Догрузка сообщений
else:
dbl.log("444444444444444444" )
# Данные по умолчанию - код ответа
data = {'status': 'error'}
# dbl.log("111" )
message_block, count = get_messages(request, order, next_messages=next_messages)
next_messages = int(next_messages)+20
dbl.log(str(next_messages) )
data['status'] = 'success'
data['next'] = next_messages
data['count'] = count
data['result'] = message_block
dbl.log("10101001" )
return HttpResponse(json.dumps(data), content_type='application/json')
except Exception as error:
pass
dbl.log("Ошибка работы" + str(error))
return render(request, 'order/chat.html', {'order':order, 'chat':chat})
def clean_date_from(self):
date_from = self.cleaned_data['date_from']
dbl.log('звездыыыыы'+str(date_from))
if date_from is not None:
return util.forms.clean_date(date_from)
def request_to_order(request):
# Добавление клиента в заявку, если пользователь авторизован
if request.user.is_authenticated:
client = request.user
else:
client = ''
# Получение данных из формы в переменную
form = RequestForm(request.POST)
# Получение данных из формы и сохранение в бд
if request.method == "POST":
try:
# Здесь автоматически проверяются все поля формы методами clean_...
if form.is_valid():
# Сохранение запроса (происходит тогда, когда все поля валидны)
form.save()
return redirect('order:request_success')
except Exception as error:
pass
dbl.log("Ошибка работы" + str(error))
return render(request, 'order/request_to_order.html', {'client':client, 'form': form})
def Login(request):
if request.user.is_authenticated:
return redirect('software:catalog')
else:
form = LoginForm()
message = ''
if request.method == 'POST':
form = LoginForm(request.POST)
dbl.log('вью форма ' + str(form))
if form.is_valid():
email = form.cleaned_data.get('email_phone')
password = form.cleaned_data.get('password')
dbl.log('вью ' + str(email) + str(password))
user = authenticate(email=email, password=password)
dbl.log('вью юзер ' + str(user))
if user is not None:
dbl.log('вью юзер не ноль ' + str(user) + str())
if user.is_active:
dbl.log('вью юзер активный' + str(user) + str())
login(request, user)
return redirect('software:catalog')
else:
message = 'Проверьте логин и пароль, и попробуйте снова'
return render(request, 'registration/login.html', {
'form': form,
'message': message
})
def clean_email(self):
dbl.log(str(self.cleaned_data['email']))
if self.cleaned_data['email'] is not None:
dbl.log("aaa")
return util.forms.clean_email(self)
def render_horizontal_widgets(list_soft,
id_widget=None,
display_type="",
widget_shell=True,
show_more=""):
# list_soft - список ПО, id_widget - id блока виджетов, display_type - скрытий или видимы блок, widget_shell - true/false наличие большого контейнера виджета
photo_dict = {}
result = ''
try:
for soft in list_soft:
soft_photo = soft.get_main_photo()
# Добавляем ключ и значение в словарь
if soft_photo is not None:
for s in soft_photo:
photo_dict[soft.id] = s
except Exception as error:
pass
dbl.log("Ошибка работы " + str(error))
result = render_to_string(
'common/pattern_horizontal_widgets.html', {
'list_soft': list_soft,
'photo_dict': photo_dict,
'id_widget': id_widget,
'display_type': display_type,
'widget_shell': widget_shell,
'show_more': show_more
})
return result
def clean_star(self):
star = self.cleaned_data['star']
dbl.log('звезда !'+str(star))
# Проверка валидности значения рейтинга
if star == "":
dbl.log('звездыыыыы'+str(star))
raise ValidationError("Пожалуйста поставьте оценку")
return star
def review_page(request, id):
# Объявление начальных значений переменных
similar_block = ""
similar_tags_block = ""
user = None
try:
# Получение текущего пользователя
user = CustomUser.get_user(request)
this_object = Review.objects.get(id=id)
# Получаем список приложений данного отзыва
review_img = this_object.get_addition()
software = Software()
photo_dict = {}
if this_object.software is not None:
software = Software.objects.get(id=this_object.software.id)
if software:
soft_photo = software.get_main_photo()
if soft_photo is not None:
for s in soft_photo:
photo_dict[software.id] = s
# Второстепенные объекты - похожие ПО
similar_block = software_views.render_similars(
software, id_widget="same_software")
similar_tags_block = software_views.render_similars_tags(
software)
# except:
# raise Http404("Отзыв не найден")
except Exception as error:
pass
dbl.log("Ошибка работы с отзывом" + str(error))
rating = [1, 2, 3, 4, 5]
return render(
request, 'review/review.html', {
'review': this_object,
'rating': rating,
'review_img': review_img,
'software': software,
'photo_dict': photo_dict,
'similar_block': similar_block,
'similar_tags_block': similar_tags_block,
'user': user
})
def Registration(request):
form = RegisterForm()
# Если пользователь авторизирован, то отправляем его на главную страницу
if request.user.is_authenticated:
return redirect('software:catalog')
else:
message = ''
if request.method == 'POST':
form = RegisterForm(request.POST)
dbl.log('вью форма ' + str(form))
if form.is_valid():
# form.save()
email = form.cleaned_data.get('email_phone')
# password = CustomUser.objects.make_random_password(length=8, allowed_chars="abcdefghjkmnpqrstuvwxyz01234567889")
# user.set_password(password)
password = form.cleaned_data.get('password')
# dbl.log('вью '+str(email)+str(password))
# user = CustomUserManager().get_user_by_email_phone(email_or_phone=email)
user = CustomUser.get_user_by_email_phone(email_or_phone=email)
# Пользователя с такими данными нет, значит можно регистрировать
if user is None or str(user) is None:
# new_user = CustomUser()
email_phone = form.cleaned_data['email_phone']
# dbl.log('емайл '+str(email_phone))
is_email_bool = is_email(email_phone=email_phone)
# dbl.log('емайл 2 '+str(email_phone))
if is_email_bool:
# Сохранение запроса (происходит тогда, когда все поля валидны)
new_user = CustomUser.objects.create_user(
email=email_phone, phone=None, password=password)
else:
# Сохранение запроса (происходит тогда, когда все поля валидны)
new_user = CustomUser.objects.create_user(
email=None, phone=email_phone, password=password)
login(request,
new_user,
backend='user.authentication.Email_PhoneAuthBackend')
return redirect('software:catalog')
else:
message = 'Пользователь с такими данными уже есть'
# else:
# form = RegisterForm()
return render(request, 'registration/registration.html', {
'form': form,
'message': message
})
def add_download(request, software_id):
message = ""
download_link = ""
list_crumb = []
try:
# Получения пользователя
user = CustomUser.get_user(request)
if user:
software = Software.objects.get(id=int(software_id))
Download.objects.get_or_create(client=user, software=software)
message = "Благодарим вас за доверие! Через 5 секунд начнется автоматическая загрузка."
# download_url = software.file
# download_url = '/softwares/download?id='+str(software.id)
download_url = '/softwares/' + str(
software.id) + '/download/send_file'
dbl.log(str(download_url))
h1 = "Успешная загрузка"
list_crumb = [['Главная', 'software:catalog'],
['Каталог', 'software:catalog'],
[
software.name, 'software:software_page',
software.id
],
[
'Скачать бесплатно',
'software:software_download', software.id
]]
return render(
request, 'common/successfull.html', {
'message': message,
'download_link': download_link,
'h1': h1,
'list_crumb': list_crumb,
'download_url': download_url
})
except Exception as error:
pass
dbl.log("Ошибка работы " + str(error))
message = "К сожалению, что-то пошло не так. Возможно вам стоит попробовать в следующий раз."
return render(request, 'common/fail.html', {'message': message})
def index(request):
# Блок новинок
new_soft = Software.get_new()
dbl.log("0")
# Ф-ия составления html кода горихонтальных виджетов
block_new_soft = render_horizontal_widgets(new_soft,
id_widget="new_software")
# Блок видов ПО
site_soft = Software.software_list_by_type(cl_val=2)
block_site_soft = render_horizontal_widgets(
site_soft,
id_widget="site_software",
display_type="style=display:none;",
widget_shell=False,
show_more="/softwares/?classification_1_value_2=2")
desktop_soft = Software.software_list_by_type(cl_val=1)
block_desktop_soft = render_horizontal_widgets(
desktop_soft,
id_widget="desktop_software",
widget_shell=False,
show_more="/softwares/?classification_1_value_1=1")
mobile_soft = Software.software_list_by_type(cl_val=3)
block_mobile_soft = render_horizontal_widgets(
mobile_soft,
id_widget="mobile_software",
display_type="style=display:none;",
widget_shell=False,
show_more="/softwares/?classification_1_value_3=3")
# Блок отзывов
list_review = Review.objects.all().filter(
date_of_delete=None, visibility=True,
star__gte=4).order_by('-date')[:3]
# Блок тегов
list_tag = Tag.objects.all().filter(date_of_delete=None,
visibility=True).order_by('name')
return render(
request, 'main/index.html', {
'block_new_soft': block_new_soft,
'block_site_soft': block_site_soft,
'block_desktop_soft': block_desktop_soft,
'block_mobile_soft': block_mobile_soft,
'list_review': list_review,
'list_tag': list_tag
})
def clean_order_id(self):
order_id = self.cleaned_data['order_id']
dbl.log("000 " + str(order_id))
try:
order = Order.objects.get(id=int(order_id))
dbl.log("00000 " + str(order))
except:
raise ValidationError(
"Такого заказа нет, вы не можете его оплатить")
return order_id
def create_user(self,
email=None,
phone=None,
password=None,
session=None,
expires=None,
**extra_fields):
if session:
dbl.log('сесиия ' + str(session))
dbl.log("время " + str(expires))
extra_fields.setdefault('is_superuser', False)
user = self.model(guest_session=session, expires=expires)
user.save()
dbl.log('сесиия юзер до')
# dbl.log('сесиия юзер' +str(user) )
dbl.log('сесиия юзер после')
return user
extra_fields.setdefault('is_superuser', False)
return self._create_user(email=email,
phone=phone,
password=password,
**extra_fields)
def render_message_block(request, dict_addition_for_message):
result='' # Переменная шаблона ответа
dbl.log("===111" )
if dict_addition_for_message :
# dbl.log("===222" )
result = render_to_string('order/pattern_block_message_for_chat.html', {'dictionary':dict_addition_for_message}, request=request)
# dbl.log("===333" )
# dbl.log("===333" + str(result))
# result = render_to_string('discussion/pattern_block_discussion.html', {'discussions_list':discussions_list,
# 'comments_dict':comments_dict,'software':software, 'show_more':show_more}, request=request)
return result
def _create_user(self,
email=None,
phone=None,
password=None,
**extra_fields):
# if not email:
# raise ValueError('Введите email')
if email:
email = self.normalize_email(email)
# extra_fields.setdefault('phone', No)
user = self.model(email=email, **extra_fields)
else:
user = self.model(phone=phone, **extra_fields)
dbl.log('манагер ' + str(email) + str(phone) + str(password))
# user = self.model(email=email, phone=phone, **extra_fields)
# dbl.log(str(user))
user.set_password(password)
user.save()
return user
def software_send_file(request, software_id):
# todo Осуществить проверку на правомочия скачивания файла
software = Software.objects.get(id=int(software_id))
if software:
dbl.log("путь 1 " + str(settings.MEDIA_ROOT))
path = str(settings.MEDIA_ROOT) + '/' + str(software.file)
dbl.log("путь " + str(path))
file = open(
path,
'rb') # Открываешь файл, который вытащила из БД по переданному ИД
response = FileResponse(file) # Формируеьш ответ.
return response # И выдаешь в браузер
message = "К сожалению, что-то пошло не так. Возможно вам стоит попробовать в следующий раз."
return render(request, 'common/fail.html', {'message': message})
def clean_date_of_birth(self):
date_of_birth = self.cleaned_data['date_of_birth']
# Проверка валидности значения имени
# if re.match(r'^[A-zА-я]+\s?[A-zА-я]*\s?[A-zА-я]*$', patronymic) is None:
# raise ValidationError("Некорретное отчество. Введите имя еще раз или оставьте это поле пустым")
if re.match(r'^\d{4}-\d{2}-\d{2}$', str(date_of_birth)) is None:
raise ValidationError("Неверный тип даты")
dbl.log(str(date_of_birth))
years = 10
days_per_year = 365.24
dbl.log(
str(datetime.date.today() -
datetime.timedelta(days=(years * days_per_year))))
if date_of_birth >= datetime.date.today() - datetime.timedelta(
days=(years * days_per_year)):
raise ValidationError(
"Кажется выбрана нереальная дата рождения, просим вас поменять значение на реальное"
)
return date_of_birth
def add_favourite(request, software_id):
try:
# Объявление начальных значений
user = None
cookie = {}
# Получение текущего пользователя
user, cookie = CustomUser.get_user_or_create(request)
if user:
software = Software.objects.get(id=int(software_id))
data = {'status': 'success'}
fav = software.is_favourite(user)
if fav:
fav.delete()
data['result'] = False
else:
Favourite.objects.create(client=user, software=software)
data['result'] = True
response = HttpResponse(json.dumps(data),
content_type='application/json')
response = util.views.wrap_cookie(response, cookie)
return response
except Exception as error:
pass
dbl.log("Ошибка работы " + str(error))
return redirect('software:catalog')
def clean_date_of_birth(self):
dbl.log("rrr")
dbl.log(str(self.cleaned_data['date_of_birth']))
if self.cleaned_data['date_of_birth'] is not None:
dbl.log("aaa")
return util.forms.clean_date_of_birth(self)
else:
return self.cleaned_data['date_of_birth']
def clean_surname(self):
dbl.log("rrr")
dbl.log(str(self.cleaned_data['surname']))
if len(self.cleaned_data['surname']) > 0:
dbl.log("aaa")
return util.forms.clean_surname(self)
else:
return self.cleaned_data['surname']
def review_create(request):
# Получение данных из формы в переменную
form = ReviewForm(request.POST)
dbl.log("Форма" + str(form))
# global list_crumb_for_software
list_crumb_for_software = [['Главная', 'main:index'],
['Отзывы', 'review:list_review']]
# Получение данных из формы и сохранение в бд
if request.method == "POST":
try:
# Проверка принадлежности запрашиваемого заказа к текущему пользователю
# Получения пользователя
user = CustomUser.get_user(request)
# Здесь автоматически проверяются все поля формы методами clean_...
if form.is_valid():
new_review = Review()
new_review.kind = 'com'
if user:
new_review.client = user
new_review.content = form.cleaned_data['content']
new_review.star = form.cleaned_data['star']
new_review.name = form.cleaned_data['name']
new_review.email_phone = form.cleaned_data['email_phone']
new_review.save()
addition_file = request.FILES.getlist('file')
# Сохранение приложений файлов к отзыву (происходит тогда, когда все поля валидны)
for file in addition_file:
dbl.log("777")
new_addition = Review_Addition()
new_addition.review = new_review
new_addition.photo = file
new_addition.save()
return redirect('review:review_success')
except Exception as error:
pass
dbl.log("Ошибка работы с отзывом" + str(error))
rating = [5, 4, 3, 2, 1]
return render(request, 'review/review_create.html', {
'form': form,
'rating': rating,
'list_crumb': list_crumb_for_software
})
def clean_patronymic(self):
dbl.log("rrr")
dbl.log(str(self.cleaned_data['patronymic']))
if len(self.cleaned_data['patronymic']) > 0:
dbl.log("aaa")
return util.forms.clean_patronymic(self)
else:
return self.cleaned_data['patronymic']
def software_buy(request, software_id):
form = Register_by_email_phone_Form()
try:
# Объявление начальных значений
user = None
cookie = {}
# Получение текущего пользователя
user, cookie = CustomUser.get_user_or_create(request)
dbl.log("заказ " + str(user))
if user:
# Объявление начальных значений
order = None
url_to_pay = ""
software = Software.objects.get(id=int(software_id))
# Создание заказа
new_order = Order()
new_order.software = software
new_order.client = user
new_order.cost = software.price
new_order.name = software.name
# todo
# Еще добавить тип ПО надо!
# Еще добавить тип заказа надо!
order = new_order.get_order_or_create()
dbl.log("заказ " + str(order))
if order:
# Строка запроса к платежной системе
url_to_pay = "/order_id=" + str(order.pk) + "&amount=" + str(
order.cost)
response = render(request, 'soft/buy.html', {
'software': software,
'user': user,
'url_to_pay': url_to_pay
})
response = util.views.wrap_cookie(response, cookie)
return response
except Exception as error:
pass
dbl.log("Ошибка работы " + str(error))
return redirect('software:catalog')
def list_review(request):
review_list = Review.objects.all().filter(date_of_delete=None,
visibility=True)
# Получение данных из формы в переменную
form = Search_ReviewForm(request.GET)
try:
# Здесь автоматически проверяются все поля формы методами clean_...
if form.is_valid():
pass
# Получение пременных из формы поиска
rating_to = form.cleaned_data['rating_to']
rating_from = form.cleaned_data['rating_from']
date_from = form.cleaned_data['date_from']
date_to = form.cleaned_data['date_to']
review_type = form.cleaned_data['review_type']
dbl.log("мммм " + str(date_from))
dbl.log("мммм " + str(date_to))
sort_param = form.cleaned_data['sort']
if sort_param is None:
sort_param = ""
count = form.cleaned_data['count']
if count == "":
count = 10
count = int(count)
try:
page = int(form.cleaned_data['page'])
except:
page = 1
dbl.log("мммм " + str(count))
dbl.log("мммм " + str(page))
# review_type_name = "Дополнительные возможности..."
dbl.log("111111111 ddkjdkd " +
str(re.match(r'^\d{1,2}\.\d{2}\.\d{4}$', str(date_from))))
# Фильтрация по дате начала отображения
if date_from:
# date_from_for_db = datetime.datetime.strptime(str(date_from), '%d.%m.%Y')
review_list = review_list.filter(date__gte=date_from)
# Фильтрация по дате окончания отображения
if date_to:
# date_to_for_db = datetime.datetime.strptime(str(date_to), '%d.%m.%Y')
review_list = review_list.filter(date__lte=date_to)
# Фильтрация по начальной границе рейтинга
if rating_from:
review_list = review_list.filter(star__gte=rating_from)
# Фильтрация по конечной границе рейтинга
if rating_to:
review_list = review_list.filter(star__lte=rating_to)
# Фильтрация по дополнительным фильтрам
if review_type:
if review_type == 'with_content':
review_list = review_list.filter(~Q(content=''))
# review_type='С текстом комментария'
if review_type == 'without_content':
review_list = review_list.filter(content='')
# review_type='Без текста комментария'
review_list = review_list.order_by('-date')
# Сортировка, показать по, перейти на страницу
review_list = util.views.sort_show_by(review_list, sort_param, count,
page)
except Exception as error:
pass
dbl.log("Ошибка работы с отзывом" + str(error))
rating = [1, 2, 3, 4, 5]
return render(request, 'review/reviews.html', {
'review_list': review_list,
'form': form,
'rating': rating
})
def software_page(request, id):
# Объявление начальных значений переменных
# Хэш классификаций ПО
classif = {}
software = Software()
software_img = Q()
main_photo = Q()
software_tag = Q()
list_descr = []
similar_block = ""
similar_tags_block = ""
discussion_comment_block = ""
# Строка фильтра для хлебных крошек
str_filter_for_breadcrumb = ""
try:
software = Software.objects.get(id=id)
# Получение главного фото
main_photo_query = software.get_main_photo()
dbl.log("сойт 2 " + str(main_photo_query))
# Здесь перебор в цикле, но на самом деле в этом запросе всего 1 объект
for photo in main_photo_query:
main_photo = photo
dbl.log("сойт 3 " + str(main_photo))
# Получаем список приложений данного ПО (ФАЙЛЫ, ФОТОГРАФИИ)
software_img = software.get_addition()
dbl.log("сойт 4 " + str(software_img))
# Исключения главного фото (main_photo) из списка фото
if software_img:
software_img = software_img.exclude(pk=main_photo.id)
# Получаем список тегов данного ПО
software_tag = software.get_tags()
# Для разрыва текста (скрытого и открытого)
# Сплит строки по '\n' по первому вхождению - получаем массив элементов одной переменной
list_descr = software.description.split('\n', 1)
# Получаем список классификаций данного ПО
classif, str_filter_for_breadcrumb = software.get_classifications()
# Второстепенные объекты - похожие ПО
similar_block = render_similars(software, id_widget="same_software")
similar_tags_block = render_similars_tags(software)
discussion_comment_block = render_discussion_comment(software,
request,
limit=5)
# Получение текущего пользователя
user = CustomUser.get_user(request)
return render(
request, 'soft/software.html', {
'software': software,
'software_img': software_img,
'main_photo': main_photo,
'classif': classif,
'list_descr': list_descr,
'software_tag': software_tag,
'similar_block': similar_block,
'similar_tags_block': similar_tags_block,
'discussion_comment_block': discussion_comment_block,
'user': user,
'str_filter_for_breadcrumb': str_filter_for_breadcrumb
})
# except:
# raise Http404("ПО не найдено")
except Exception as error:
pass
dbl.log("Ошибка работы " + str(error))
# return render(request, 'soft/software.html', {'software':software, 'software_img':software_img, 'main_photo':main_photo, 'classif':classif,
# 'list_descr':list_descr, 'software_tag':software_tag, 'similar_block':similar_block, 'similar_tags_block':similar_tags_block,
# 'discussion_comment_block':discussion_comment_block})
raise Http404("ПО не найдено")
def catalog(request):
soft_list = Software.objects.all().filter(date_of_delete=None,
visibility=True)
dbl.log("mmmmm")
dbl.log("бббб" + str(request))
# Получение пременных из формы поиска
search_query_name = request.GET.get('soft_name', '')
search_query_tags = request.GET.get('soft_tags', '')
soft_price = request.GET.get('soft_price', '')
soft_pricefrom = request.GET.get('soft_pricefrom', '')
soft_priceto = request.GET.get('soft_priceto', '')
modification = request.GET.get('modification', '')
sort_param = request.GET.get('sort', '')
if sort_param is None:
sort_param = ""
count = request.GET.get('count', '10')
if count == "":
count = 10
count = int(count)
try:
page = int(request.GET.get('page', '1'))
except:
page = 1
# Словарь для фильтра классификаций
classification_dict = {}
vertical_widget = None
list_tags = []
# Перебор всех пришедших аргументов
for req in request.GET.items():
# Проверка валидности значения имени (классификации)
if re.match(r'classification_(\d+)_value_(\d+)', str(req[0])):
# Проверка значения поля формы поиска
if str(req[1]) != "" and str(req[1]).isdigit():
# Добавление значения в словарь
classification_dict[str(req[0])] = str(req[1])
# Перменная составления запроса с фильтрами по классификациям
cond = Q()
# Перебор словаря классификаций
for cl_val in classification_dict.values():
# Добавление условия фильтрации
cond |= Q(classification_value=int(cl_val))
# Фильтрация списка всех ПО по выбранным классификациям
soft_list = soft_list.filter(cond)
# Исключение повторений ПО
soft_list = soft_list.order_by('id').distinct()
# Фильтрация по цене (бесплатные ПО)
if soft_price == "soft_price_free":
soft_list = soft_list.filter(price=0)
# Фильтрация по цене (платные ПО)
if soft_price == "soft_price_paid":
soft_list = soft_list.exclude(price=0)
# Фильтрация по начальной цене
if soft_pricefrom:
soft_list = soft_list.filter(price__gte=soft_pricefrom)
# Фильтрация по конечной цене
if soft_priceto:
soft_list = soft_list.filter(price__lte=soft_priceto)
# Фильтрация по наименованию ПО
if search_query_name:
soft_list = soft_list.filter(name__icontains=search_query_name)
# Фильтрация по полю доработки
if modification:
soft_list = soft_list.filter(modification=True)
# Фильтрация по списку тегов ПО
if search_query_tags:
# Сплит строки запроса
dbl.log("ввввввв " + str(search_query_tags))
list_tags = re.split(r'[ ,]+', search_query_tags)
dbl.log("ртртртрт " + str(list_tags))
# Фильтрация ПО по списку тегов
soft_list = Software.get_softwares_by_tags(soft_list, list_tags)
dbl.log("ddddddddd " + str(soft_list))
# Хэш классификаций ПО
tags_dict = {}
photo_dict = {}
vertical_widget_photo_dict = {}
for soft in soft_list:
soft_tags_list = soft.get_tags()
soft_photo = soft.get_main_photo()
# Добавляем ключ и значение в словарь
tags_dict[soft.id] = soft_tags_list
if soft_photo is not None:
# Здесь перебор в цикле, но на самом деле в этом запросе всего 1 объект
for s in soft_photo:
photo_dict[soft.id] = s
# Получение текущего пользователя
user = CustomUser.get_user(request)
# Получение списка всех видов ПО
classifications = Classification.objects.all().filter(
date_of_delete=None, visibility=True).order_by('id')
# if request.is_ajax():
# dbl.log("hhhh")
# for soft in soft_list:
# dbl.log("--- " + str(soft))
# response = sort( request, soft_list)
# dbl.log("hhhh "+str(response))
# return response
# Сортировка, показать по, перейти на страницу
soft_list = util.views.sort_show_by(soft_list, sort_param, count, page)
# Составление вертикального виджета
# Список типов виджетов
choice_widget_list = ['popular', 'new']
# Выбор типа
choice_widget = random.choice(choice_widget_list)
# dbl.log("виджеты " + str(choice_widget))
# Популярные ПО
if choice_widget == "popular":
vertical_widget_all = Software.get_popular()
# dbl.log("виджеты " + str(vertical_widget_all))
if len(vertical_widget_all) > 6:
vertical_widget = random.sample(vertical_widget_all, 6)
else:
vertical_widget = vertical_widget_all
# dbl.log("виджеты " + str(vertical_widget))
# Новые ПО
elif choice_widget == "new":
vertical_widget = Software.get_new()
for soft in vertical_widget:
vertical_widget_soft_photo = soft.get_main_photo()
if vertical_widget_soft_photo is not None:
# Здесь перебор в цикле, но на самом деле в этом запросе всего 1 объект
for s in vertical_widget_soft_photo:
vertical_widget_photo_dict[soft.id] = s
response = render(
request, 'soft/catalog.html', {
'soft_list': soft_list,
'photo_dict': photo_dict,
'count': count,
'sort_param': sort_param,
'page': page,
'modification': modification,
'search_query_name': search_query_name,
'soft_price': soft_price,
'soft_pricefrom': soft_pricefrom,
'list_tags': list_tags,
'soft_priceto': soft_priceto,
'tags_dict': tags_dict,
'classifications': classifications,
'classification_dict': classification_dict,
'user': user,
'choice_widget': choice_widget,
'vertical_widget': vertical_widget,
'vertical_widget_photo_dict': vertical_widget_photo_dict
})
return response
