def limit(self, limit_number):
"""
Limit number Elements
"""
current_pipe = pipes.LimitPipe(limit_number)
self.pipeline.add_pipe(current_pipe)
return self
def test_pipeline_exclude_limit(self):
pipeline_test = pipeline.Pipeline(
recommend_utils.ListIterator([1, 2, 3, 4, 5, 6, 7]),
[pipes.ExcludePipe([1]),
pipes.LimitPipe(5)])
self.assertEqual(pipeline_test.to_list(), [2, 3, 4, 5, 6])
def test_pipeline_refresh_as_pipes(self):
pipeline_test = pipeline.Pipeline(
recommend_utils.ListIterator([1, 2, 3, 4, 5, 6, 7]),
[pipes.ExcludePipe([1]),
pipes.LimitPipe(5)])
result = pipeline_test.refresh_as_pipes()
self.assertEqual(result, None)
def get_storefront_most_popular(request_profile,
pre_fetch=True,
ordering=None):
"""
Get Most Popular Listings for storefront
"""
username = request_profile.user.username
# Get most popular listings via a weighted average
most_popular_listings_raw = models.Listing.objects.for_user_organization_minus_security_markings(
username).filter(approval_status=models.Listing.APPROVED,
is_enabled=True,
is_deleted=False).order_by('-avg_rate',
'-total_reviews')
most_popular_listings = pipeline.Pipeline(
recommend_utils.ListIterator(
[listing for listing in most_popular_listings_raw]), [
pipes.ListingPostSecurityMarkingCheckPipe(username),
pipes.LimitPipe(36)
]).to_list()
sorted_most_popular_listings = custom_sort_listings(
most_popular_listings, ordering)
return sorted_most_popular_listings
def test_pipeline_limit(self):
pipeline_test = pipeline.Pipeline(
recommend_utils.ListIterator([1, 2, 3, 4, 5, 6, 7]),
[pipes.LimitPipe(5)])
self.assertEqual(pipeline_test.to_list(), [1, 2, 3, 4, 5])
pipeline_test = pipeline.Pipeline(
recommend_utils.ListIterator([1, 2, 3, 4, 5, 6, 7]),
[pipes.LimitPipe(2)])
self.assertEqual(pipeline_test.to_list(), [1, 2])
pipeline_test = pipeline.Pipeline(
recommend_utils.ListIterator([1, 2, 3]), [pipes.LimitPipe(5)])
self.assertEqual(pipeline_test.to_list(), [1, 2, 3])
def test_pipeline_remove(self):
pipeline_test = pipeline.Pipeline(
recommend_utils.ListIterator([1, 2, 3, 4, 5, 6, 7]),
[pipes.ExcludePipe([1]),
pipes.LimitPipe(5)])
self.assertRaises(recommend_utils.UnsupportedOperationException,
pipeline_test.remove)
def test_pipeline_get_starts(self):
pipeline_test = pipeline.Pipeline(
recommend_utils.ListIterator([1, 2, 3, 4, 5, 6, 7]),
[pipes.ExcludePipe([1]),
pipes.LimitPipe(5)])
result = pipeline_test.get_starts()
self.assertEqual(str(result), 'ListIterator(7)')
def test_pipeline_count(self):
pipeline_test = pipeline.Pipeline(
recommend_utils.ListIterator([1, 2, 3, 4, 5, 6, 7]),
[pipes.ExcludePipe([1]),
pipes.LimitPipe(5)])
result = pipeline_test.count()
self.assertEqual(result, 5)
result = pipeline_test.count()
self.assertEqual(result, 0)
def test_pipeline_get_pipes(self):
pipeline_test = pipeline.Pipeline(
recommend_utils.ListIterator([1, 2, 3, 4, 5, 6, 7]),
[pipes.ExcludePipe([1]),
pipes.LimitPipe(5)])
result = ', '.join([str(pipe) for pipe in pipeline_test.get_pipes()])
self.assertEqual(
str(result),
'ListIterator(7), ExcludePipe(), LimitPipe(limit_number:5)')
def list(self, request, listing_pk=None):
queryset = self.filter_queryset(self.get_queryset(listing_pk))
serializer = serializers.ListingSerializer(
queryset, context={'request': request}, many=True)
similar_listings = pipeline.Pipeline(
recommend_utils.ListIterator(serializer.data), [
pipes.ListingDictPostSecurityMarkingCheckPipe(
self.request.user.username),
pipes.LimitPipe(10)
]).to_list()
return Response(similar_listings)
def get_storefront_recent(request_profile, pre_fetch=True):
"""
Get Recent Listings for storefront
"""
username = request_profile.user.username
# Get Recent Listings
recent_listings_raw = models.Listing.objects.for_user_organization_minus_security_markings(
username).order_by('-approved_date').filter(
approval_status=models.Listing.APPROVED,
is_enabled=True,
is_deleted=False)
recent_listings = pipeline.Pipeline(recommend_utils.ListIterator([listing for listing in recent_listings_raw]),
[pipes.ListingPostSecurityMarkingCheckPipe(username),
pipes.LimitPipe(24)]).to_list()
return recent_listings
def _get_recommended_listings(self):
profile_username = self.profile_instance.user.username
# Post security_marking check - lazy loading
pipeline_list = [
pipes.ListingPostSecurityMarkingCheckPipe(profile_username),
pipes.LimitPipe(10)
]
if self.randomize_recommended:
pipeline_list.insert(0, pipes.JitterPipe())
recommended_listings_iterator = recommend_utils.ListIterator(
self.recommended_listings_raw)
self.recommended_listings = pipeline.Pipeline(
recommended_listings_iterator, pipeline_list).to_list()
self.recommended_listings_ids = [
listing.id for listing in self.recommended_listings
]
def get_storefront_most_popular(username, pre_fetch=True):
"""
Get Most Popular Listings for storefront
"""
# Get most popular listings via a weighted average
most_popular_listings_raw = models.Listing.objects.for_user_organization_minus_security_markings(
username).filter(approval_status=models.Listing.APPROVED,
is_enabled=True,
is_deleted=False).order_by('-avg_rate',
'-total_reviews')
if pre_fetch:
most_popular_listings_raw = listing_serializers.ListingSerializer.setup_eager_loading(
most_popular_listings_raw)
most_popular_listings = pipeline.Pipeline(
recommend_utils.ListIterator(
[listing for listing in most_popular_listings_raw]), [
pipes.ListingPostSecurityMarkingCheckPipe(username),
pipes.LimitPipe(36)
]).to_list()
return most_popular_listings
def get_storefront_recommended(username, pre_fetch=True):
"""
Get Recommended Listings for storefront
"""
extra_data = {}
profile = models.Profile.objects.get(user__username=username)
if not profile.is_beta_user():
return [], extra_data
# Retrieve List of Recommended Apps for profile:
listing_ids_list, recommended_entry_data = get_recommendation_listing_ids(
profile)
extra_data['recommended_entry_data'] = recommended_entry_data
# Retrieve Profile Bookmarks and remove bookmarked from recommendation list
bookmarked_apps_list = set([
application_library_entry.listing.id for application_library_entry in
models.ApplicationLibraryEntry.objects.for_user(username)
])
listing_ids_list_temp = []
for current_listing_id in listing_ids_list:
if current_listing_id not in bookmarked_apps_list:
listing_ids_list_temp.append(current_listing_id)
listing_ids_list = listing_ids_list_temp
# Send new recommendation list minus bookmarked apps to User Interface
recommended_listings_queryset = models.Listing.objects.for_user_organization_minus_security_markings(
username).filter(pk__in=listing_ids_list,
approval_status=models.Listing.APPROVED,
is_enabled=True,
is_deleted=False).all()
if pre_fetch:
recommended_listings_queryset = listing_serializers.ListingSerializer.setup_eager_loading(
recommended_listings_queryset)
# Fix Order of Recommendations
id_recommended_object_mapper = {}
for recommendation_entry in recommended_listings_queryset:
id_recommended_object_mapper[
recommendation_entry.id] = recommendation_entry
# recommended_listings_raw = [id_recommended_object_mapper[listing_id] for listing_id in listing_ids_list]
recommended_listings_raw = []
for listing_id in listing_ids_list:
if listing_id in id_recommended_object_mapper:
recommended_listings_raw.append(
id_recommended_object_mapper[listing_id])
# Post security_marking check - lazy loading
recommended_listings = pipeline.Pipeline(
recommend_utils.ListIterator([
recommendations_listing
for recommendations_listing in recommended_listings_raw
]), [
pipes.JitterPipe(),
pipes.ListingPostSecurityMarkingCheckPipe(username),
pipes.LimitPipe(10)
]).to_list()
return recommended_listings, extra_data
def get_storefront_new(username, request):
"""
Returns data for /storefront api invocation including:
* recommended listings (max=10)
* featured listings (max=12)
* recent (new) listings (max=24)
* most popular listings (max=36)
Args:
username
Returns:
{
'recommended': [Listing],
'featured': [Listing],
'recent': [Listing],
'most_popular': [Listing]
}
"""
extra_data = {}
profile = models.Profile.objects.get(user__username=username)
if profile.highest_role() == 'APPS_MALL_STEWARD':
exclude_orgs = []
elif profile.highest_role() == 'ORG_STEWARD':
user_orgs = profile.stewarded_organizations.all()
user_orgs = [i.title for i in user_orgs]
exclude_orgs = [
agency.title
for agency in models.Agency.objects.exclude(title__in=user_orgs)
]
else:
user_orgs = profile.organizations.all()
user_orgs = [i.title for i in user_orgs]
exclude_orgs = [
agency.title
for agency in models.Agency.objects.exclude(title__in=user_orgs)
]
current_listings = get_user_listings(username, request, exclude_orgs)
# Get Recommended Listings for owner
if profile.is_beta_user():
recommendation_listing_ids, recommended_entry_data = get_recommendation_listing_ids(
profile)
listing_ids_list = set(recommendation_listing_ids)
recommended_listings_raw = []
for current_listing in current_listings:
if current_listing['id'] in listing_ids_list:
recommended_listings_raw.append(current_listing)
recommended_listings = pipeline.Pipeline(
recommend_utils.ListIterator(recommended_listings_raw), [
pipes.JitterPipe(),
pipes.ListingDictPostSecurityMarkingCheckPipe(username),
pipes.LimitPipe(10)
]).to_list()
else:
recommended_listings = []
# Get Featured Listings
featured_listings = pipeline.Pipeline(
recommend_utils.ListIterator(current_listings), [
pipes.ListingDictPostSecurityMarkingCheckPipe(username,
featured=True),
pipes.LimitPipe(12)
]).to_list()
# Get Recent Listings
recent_listings = pipeline.Pipeline(
recommend_utils.ListIterator(current_listings), [
pipes.ListingDictPostSecurityMarkingCheckPipe(username),
pipes.LimitPipe(24)
]).to_list()
most_popular_listings = pipeline.Pipeline(
recommend_utils.ListIterator(
sorted(current_listings,
key=lambda k: (k['avg_rate'], ['total_reviews']),
reverse=True)), [
pipes.ListingDictPostSecurityMarkingCheckPipe(username),
pipes.LimitPipe(36)
]).to_list()
# TODO 2PI filtering
data = {
'recommended': recommended_listings,
'featured': featured_listings,
'recent': recent_listings,
'most_popular': most_popular_listings
}
return data, extra_data
