def register(request):
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid() and not request.user.is_authenticated():
data = form.cleaned_data
new_user = User.objects.create_user(username=data['nickname'],
password=data['password'])
new = CustomUser(user=new_user,
sex=data.get('sex'),
phone=data.get('phone'))
new.save()
login(
request,
authenticate(username=new_user.username,
password=data.get('password2')))
_return = {'message': '感谢您的注册'}
_return.update(get_header(request))
return render(request, 'redirect.html', _return)
else:
return render(request, 'register.html', {'form': form})
elif request.method == 'GET':
if request.user.is_authenticated():
return render(request, 'redirect.html', {'message': '您已登陆'})
form = RegisterForm()
_return = {'form': form}
_return.update(get_header(request))
return render(request, 'register.html', _return)
def setUp(self):
self.user = CustomUser(username="******", password="******")
self.user.save()
self.create_like_article_url = reverse("create_like_article", args=[1, 'testuser'])
self.data_like_article = {
"reaction": 1
}
def setUp(self):
self.list_categories = ['boisson', 'tartine', 'sandwich', 'viande']
self.list_products = ['coca', 'tartine nutella', 'club', 'entrecote']
self.command = Command()
self.login = CustomUser(username='******',
email='*****@*****.**',
password='******')
self.login.save()
def order_page(request, id):
# Объявление начальных значений переменных
order_img = Q()
main_photo = Q()
list_note = []
order = None
try:
# Проверка принадлежности запрашиваемого заказа к текущему пользователю
# Получения пользователя
user = CustomUser.get_user(request)
if user:
# Получение заказа
order = Order.get_order_by_client(id, user)
if order != None:
# Получаем список приложений данного ПО (ФАЙЛЫ, ФОТОГРАФИИ)
if order.kind == "buy":
software = Software.objects.get( order_software = id )
# Получение главного фото
main_photo_query = software.get_main_photo()
# Здесь перебор в цикле, но на самом деле в этом запросе всего 1 объект
for photo in main_photo_query:
main_photo = photo
order_img = software.get_addition()
else:
# Получение главного фото
main_photo_query = order.get_main_photo()
# Здесь перебор в цикле, но на самом деле в этом запросе всего 1 объект
for photo in main_photo_query:
main_photo = photo
order_img = order.get_addition()
# Исключения главного фото (main_photo) из списка фото
if order_img:
order_img = order_img.exclude(pk=main_photo.id)
# Для разрыва текста (скрытого и открытого)
# Сплит строки по '\n' по первому вхождению - получаем массив элементов одной переменной
if order.note:
list_note = order.note.split('\n', 1)
# Получение текущего пользователя
user = CustomUser.get_user(request)
return render(request, 'order/order.html', {'order':order, 'user':user, 'list_note':list_note, 'order_img':order_img, 'main_photo':main_photo})
except:
raise Http404("Заказ не найден")
raise Http404("Заказ не найден")
class TestManageNotification(TestCase):
def setUp(self):
self.user = CustomUser(username="******", password="******")
self.user.save()
def test_create_notification(self):
ManageNotification().create_notification(self.user, "testuser", 1)
notif_is_exist = Notification.objects.all().count()
self.assertEquals(notif_is_exist, 1)
def setUp(self):
self.user = CustomUser(username="******", password="******")
self.user.save()
self.create_article_url = reverse("create_article")
self.categories = Categories.objects.get_or_create(id=64)
self.data_article = {
"title": "testTile",
"content_article": "test content",
"id_category": 64
}
class TestCommentsEndpoint(APITestCase):
def setUp(self):
self.user = CustomUser(username="******", password="******")
self.user.save()
self.category = Categories(name_category="TestCategory")
self.category.save()
self.article = Article(
title="TestTitle",
content_article="Test Content",
id_category=self.category,
id_user=self.user,
).save()
self.get_all_url = reverse("getAll",
args=[Article.objects.all()[0].id, 1])
self.create_like_comment_url = reverse("create_like_comment",
args=[0, 'testuser'])
self.create_comment_url = reverse("Create_comment",
args=[0, 'testuser'])
self.data_like_comment = {"recation_comment": 1}
self.data_comment = {"content_comment": "test comment"}
def test_get_all_comment(self):
response = self.client.get(self.get_all_url)
self.assertEquals(response.status_code, status.HTTP_200_OK)
def test_post_like_comment_unauthenticated(self):
response = self.client.post(self.create_like_comment_url,
self.data_like_comment,
format='json')
self.assertEquals(response.status_code, status.HTTP_403_FORBIDDEN)
def test_post_like_comment_authenticated(self):
self.client.force_login(
CustomUser.objects.get_or_create(username='******')[0])
response = self.client.post(self.create_like_comment_url,
self.data_like_comment,
format='json')
self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_post_create_comment_article_unauthenticated(self):
response = self.client.post(self.create_comment_url,
self.data_comment,
format='json')
self.assertEquals(response.status_code, status.HTTP_403_FORBIDDEN)
def test_post_create_comment_article_authenticated(self):
self.client.force_login(
CustomUser.objects.get_or_create(username='******')[0])
response = self.client.post(self.create_comment_url,
self.data_comment,
format='json')
self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST)
def post(self, request):
serializer = self.serializer_class(data=request.data)
if serializer.is_valid():
logger.info("Valid incoming data")
username = serializer.data['username']
password1 = serializer.data['password1']
password2 = serializer.data['password2']
email = serializer.data['email']
user = CustomUser(username=username,
password=password1,
email=email)
user.save()
return Response(status=201)
else:
return Response(status=400)
def render_block_software(request, soft_list):
# Хэш классификаций ПО
tags_dict = {}
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)
# Получение списка тегов похожих ПО
result = ''
result = render_to_string('soft/pattern_block_software.html', {
'soft_list': soft_list,
'photo_dict': photo_dict,
'user': user
})
return result
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 favourites(request):
# Получения пользователя
user = CustomUser.get_user(request)
dbl.log("1")
if user:
dbl.log("1")
favourites = Software.get_favourites_by_user(user)
dbl.log("1"+str(favourites))
# Словарь главных фото
photo_dict = {}
dbl.log("1")
for soft in favourites:
# Получение главного фото
soft_photo = soft.get_main_photo()
if soft_photo is not None:
# Здесь перебор в цикле, но на самом деле в этом запросе всего 1 объект
for s in soft_photo:
dbl.log("1")
photo_dict[soft.id] = s
dbl.log("1")
response= render(request, 'user/favourites.html', {'favourites':favourites, 'user':user, 'photo_dict':photo_dict})
return response
def setUp(self):
self.user = CustomUser(username="******", password="******").save()
self.id_user = CustomUser.objects.get(username="******").id
self.research_user_url = reverse("research_user", args=['test'])
self.create_subscribed_url = reverse("create_subscribed", args=['testuser'])
self.all_info_user = reverse("all_info_user", args=[self.id_user])
self.data_post_subscribe = {"id_receiving": self.id_user}
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 test_get_myaccount_with_bad_id(self):
self.client.force_login(CustomUser.objects.get_or_create(username='******')[0])
CustomUser(username="******").save()
myaccount_url = reverse('myaccount', args=[CustomUser.objects.all()[1].id])
account_url = reverse('account', args=[CustomUser.objects.all()[1].id])
response = self.client.get(myaccount_url)
self.assertRedirects(response, account_url, status_code=302)
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 favourites_clean(request):
# Получения пользователя
user = CustomUser.get_user(request)
if user:
favourites = Favourite.get_favourites_by_user(user)
for fav in favourites:
fav.delete()
return render(request, 'user/favourites.html', {'favourites':None})
def setUp(self):
self.user = CustomUser(username="******", password="******")
self.user.save()
self.category = Categories(name_category="TestCategory")
self.category.save()
self.article = Article(
title="TestTitle",
content_article="Test Content",
id_category=self.category,
id_user=self.user,
).save()
self.get_all_url = reverse("getAll",
args=[Article.objects.all()[0].id, 1])
self.create_like_comment_url = reverse("create_like_comment",
args=[0, 'testuser'])
self.create_comment_url = reverse("Create_comment",
args=[0, 'testuser'])
self.data_like_comment = {"recation_comment": 1}
self.data_comment = {"content_comment": "test comment"}
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 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})
class TestCreateArticle(APITestCase):
def setUp(self):
self.user = CustomUser(username="******", password="******")
self.user.save()
self.create_article_url = reverse("create_article")
self.categories = Categories.objects.get_or_create(id=64)
self.data_article = {
"title": "testTile",
"content_article": "test content",
"id_category": 64
}
def test_post_create_article_unauthenticate(self):
response = self.client.post(self.create_article_url, self.data_article)
self.assertEquals(response.status_code, status.HTTP_403_FORBIDDEN)
def test_post_create_article_authenticated(self):
self.client.force_login(CustomUser.objects.get_or_create(username='******')[0])
response = self.client.post(self.create_article_url, self.data_article, format='json')
self.assertEquals(response.status_code, 200)
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')
class TestPostLikeEndpoint(APITestCase):
def setUp(self):
self.user = CustomUser(username="******", password="******")
self.user.save()
self.create_like_article_url = reverse("create_like_article", args=[1, 'testuser'])
self.data_like_article = {
"reaction": 1
}
def test_post_create_like_article_unaunthenticated(self):
response = self.client.post(
self.create_like_article_url,
self.data_like_article
)
self.assertEquals(response.status_code, status.HTTP_403_FORBIDDEN)
def test_post_create_like_article_authenticated(self):
self.client.force_login(CustomUser.objects.get_or_create(username='******')[0])
response = self.client.post(self.create_like_article_url, self.data_like_article, format='json')
self.assertEquals(response.status_code, 400)
class TestCommand(TestCase):
def setUp(self):
self.list_categories = ['boisson', 'tartine', 'sandwich', 'viande']
self.list_products = ['coca', 'tartine nutella', 'club', 'entrecote']
self.command = Command()
self.login = CustomUser(username='******',
email='*****@*****.**',
password='******')
self.login.save()
def test_get_email_user_subscribe(self):
UserSubscribeEmail(id_user=self.login).save()
self.command.get_email_user_subscribe()
self.assertEquals(self.command.list_email, ['*****@*****.**'])
def test_get_random_products(self):
for i in range(3):
category = Categories(name_category=self.list_categories[i])
category.save()
Products(id_category=category,
product_name=self.list_products[i]).save()
self.command.get_random_products()
self.command.text_content()
self.assertEquals(len(self.command.txt.split('\n')), 4)
self.assertEquals(len(self.command.list_products), 3)
self.assertEquals(len(self.command.list_categories), 3)
def test_send_all_email(self):
self.command.list_email = ['*****@*****.**']
msg = ('Toujours pleins de substituants chez PureButterWeb',
"ahahahah", '*****@*****.**', self.command.list_email)
mail.send_mass_mail((msg, ), fail_silently=False)
self.assertEquals(len(mail.outbox), 1)
def setUp(self):
CustomUser(username="******").save()
Categories(name_category="TestCategory").save()
Article(
title="TestTitle",
content_article="Test Content",
id_category=Categories.objects.all()[0],
id_user=CustomUser.objects.all()[0],
).save()
Comment(
id_article=Article.objects.all()[0],
id_user=CustomUser.objects.all()[0],
content_comment="test comment",
).save()
self.all_data_article = AllDataArticle()
self.all_data_comment = AllDataComment()
self.obj_article = Article.objects.all()
self.obj_comment = Comment.objects.all()
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 downloads(request):
# Получения пользователя
user = CustomUser.get_user(request)
if user:
downloads = Software.get_downloads_by_user(user)
# Словарь главных фото
photo_dict = {}
for soft in downloads:
# Получение главного фото
soft_photo = soft.get_main_photo()
if soft_photo is not None:
# Здесь перебор в цикле, но на самом деле в этом запросе всего 1 объект
for s in soft_photo:
photo_dict[soft.id] = s
response= render(request, 'user/downloads.html', {'downloads':downloads, 'user':user, 'photo_dict':photo_dict})
return response
def check_is_admin(request):
return CustomUser.get_by_email(request.user.email).role == 1
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 save(self, commit=True):
return CustomUser.create(self.cleaned_data.get("email"), self.cleaned_data.get("password1"),
self.cleaned_data.get("first_name"), self.cleaned_data.get("middle_name"),
self.cleaned_data.get("last_name"))
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
