def list(self, request):
"""
this method returns list of adgroups and if 'q' as query parameter
is given it will filter objects with given query and returns list
"""
q = request.GET.get("q", "")
self.queryset = self.get_queryset()
if q:
q_list = q.split(" ")
category_filter = reduce(
operator.or_, [Q(category__name__icontains=s) for s in q_list])
campaign_filter = reduce(
operator.or_, [Q(campaign__name__icontains=s) for s in q_list])
self.queryset = self.queryset.filter(category_filter
| campaign_filter).distinct()
page = self.paginate_queryset(self.queryset)
if page is not None:
serializer = self.get_serializer(page, many=True)
if serializer.data:
paginated_response = self.get_paginated_response(
serializer.data)
return Response(create_response(paginated_response.data))
serializer = self.get_serializer(self.queryset, many=True)
return Response(create_response(serializer.data))
def retrieve(self, request, pk=None):
"""
this method returns single adgroup object for given pk value
if object not found it will return error
"""
obj = self.get_object()
serializer = self.get_serializer(obj)
return Response(create_response(serializer.data))
def destroy(self, request, pk=None):
"""
this method is used to delete Advertisement object
"""
obj = self.get_object()
obj.delete()
return Response(create_response(
{"Msg": "Advertisement deleted successfully"}),
status=200)
def create(self, request):
"""
this method is used to create new adgroup object
"""
serializer = AdGroupSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(create_response(serializer.data))
return Response(create_error_response(serializer.errors), status=400)
def update(self, request, pk=None):
"""
this method is used to update existing adgroup
"""
obj = AdGroup.objects.get(id=pk)
serializer = AdGroupSerializer(obj, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(create_response(serializer.data))
return Response(create_error_response(serializer.errors), status=400)
def get(self, request):
domain_id = self.request.GET.get("domain")
if not domain_id:
return Response(
create_error_response({"domain": ["Domain id is required"]}))
domain = Domain.objects.filter(domain_id=domain_id).first()
if not domain:
return Response(
create_error_response({"domain": ["Domain id is required"]}))
ads = Advertisement.objects.filter(adgroup__campaign__domain=domain,
is_active=True).order_by('?')
if ads:
ad = ads[random.randint(0, len(ads) - 1)]
ad.delivered += 1
ad.save()
ad_serializer = AdvertisementSerializer(
ad, context={"request": request})
return Response(create_response(ad_serializer.data))
return Response(create_response({}))
def create(self, request):
"""
this method is used to create new campaign object
"""
post_data = request.data.copy()
if request.user.domain:
post_data["domain"] = request.user.domain.id
serializer = CampaignSerializer(data=post_data)
if serializer.is_valid():
serializer.save()
return Response(create_response(serializer.data))
return Response(create_error_response(serializer.errors), status=400)
def get(self, request, format=None, *args, **kwargs):
"""
List all news category
"""
domain = request.user.domain
groups = GetAdGroupSerializer(
AdGroup.objects.filter(campaign__domain=domain), many=True)
types = AdTypeSerializer(AdType.objects.all(), many=True)
return Response(
create_response({
"groups": groups.data,
"types": types.data
}))
def create(self, request):
"""
this method is used to create new adgroup object
"""
file_obj = request.data['file']
serializer = AdSerializer(data=request.data)
if serializer.is_valid():
obj = serializer.save()
if file_obj:
obj.media = file_obj
obj.save()
return Response(create_response(serializer.data))
return Response(create_error_response(serializer.errors), status=400)
def update(self, request, pk=None):
"""
this method is used to update existing adgroup
"""
file = request.data['file']
advertisment = Advertisement.objects.get(id=pk)
serializer = AdSerializer(advertisment, data=request.data)
# import pdb
# pdb.set_trace()
if serializer.is_valid():
updated = serializer.save()
if file:
updated.media = file
updated.save()
return Response(create_response(serializer.data))
return Response(create_error_response(serializer.errors), status=400)
def get(self, request, format=None, *args, **kwargs):
"""
List all news category
"""
current_date = datetime.datetime.now()
categories = CategorySerializer(Category.objects.all(), many=True)
campaigns = CampaignSerializer(Campaign.objects.filter(
domain=request.user.domain,
is_active=True,
start_date__lte=current_date,
end_date__gte=current_date),
many=True)
return Response(
create_response({
"categories": categories.data,
"campaigns": campaigns.data
}))
def get(self, request):
date_range = request.GET.get("date_range")
start_date, end_date, error = self.get_date_range(date_range)
if error:
return Response(error, status=400)
if not request.user.domain:
data = [{"name": None, "article_count": 0}]
no_data = True
avg = {"avg_count": 0}
return Response(
create_response({
"result": data,
"no_data": no_data,
"avg_count": avg["avg_count"]
}))
domain_id = request.user.domain.domain_id
pipeline = [{
"$match": {
"$and": [{
"ts": {
"$gte": start_date,
"$lte": end_date
}
}, {
"domain": domain_id
}]
}
}, {
"$match": {
"$or": [{
"action": "article_detail"
}, {
"action": "article_search_details"
}]
}
}, {
"$group": {
"_id": "$author_name",
"count": {
"$sum": 1
}
}
}, {
"$project": {
"_id": 0,
"name": "$_id",
"article_count": "$count"
}
}]
data = list(self.events.collection.aggregate(pipeline))
no_data = False
if not data:
data = [{"name": None, "article_count": 0}]
no_data = True
avg = {"avg_count": 0}
past_avg = {"avg_count": 0}
else:
past_start_date, past_end_date, error = self.get_past_range(
date_range)
past_avg = self.get_avg(past_start_date, past_end_date, domain_id)
avg = self.get_avg(start_date, end_date, domain_id)
return Response(
create_response({
"result":
data,
"no_data":
no_data,
"avg_count":
avg["avg_count"],
"diff":
round(avg["avg_count"] - past_avg["avg_count"], 2)
}))
def get(self, request):
date_range = request.GET.get("date_range")
start_date, end_date, error = self.get_date_range(date_range)
if error:
return Response(error, status=400)
if not request.user.domain:
res = {"dateStr": None, "web": 0, "android": 0, "ios": 0}
no_data = True
avg = {"avg_count": 0}
return Response(
create_response({
"result": res,
"no_data": no_data,
"avg_count": avg["avg_count"]
}))
domain_id = request.user.domain.domain_id
pipeline = [{
"$match": {
"$and": [{
"ts": {
"$gte": start_date,
"$lte": end_date
}
}, {
"domain": domain_id
}]
}
}, {
"$match": {
"$or": [{
"action": "article_detail"
}, {
"action": "article_search_details"
}]
}
}, {
"$project": {
"_id": 0,
"datePartDay": {
"$concat": [{
"$substr": [{
"$dayOfMonth": "$ts"
}, 0, 2]
}, "-", {
"$substr": [{
"$month": "$ts"
}, 0, 2]
}, "-", {
"$substr": [{
"$year": "$ts"
}, 0, 4]
}]
},
"platform": "$platform"
}
}, {
"$group": {
"_id": {
"datePartDay": "$datePartDay",
"platform": "$platform"
},
"count": {
"$sum": 1
}
}
}, {
"$project": {
"_id": 0,
"dateObj": {
"$dateFromString": {
"dateString": "$_id.datePartDay"
}
},
"count": "$count",
"platform": "$_id.platform",
"dateStr": "$_id.datePartDay"
}
}, {
"$sort": {
"dateObj": 1
}
}]
data = list(self.events.collection.aggregate(pipeline))
if data:
res = []
past_start_date, past_end_date, error = self.get_past_range(
date_range)
past_avg = self.get_avg(past_start_date, past_end_date, domain_id)
for key, values in groupby(data, itemgetter("dateStr")):
d = {"dateStr": key}
for v in values:
d[v["platform"]] = v["count"]
res.append(d)
no_data = False
avg = self.get_avg(start_date, end_date, domain_id)
else:
res = {"dateStr": None, "web": 0, "android": 0, "ios": 0}
no_data = True
avg = {"avg_count": 0}
past_avg = {"avg_count": 0}
return Response(
create_response({
"result":
res,
"no_data":
no_data,
"diff":
round(avg["avg_count"] - past_avg["avg_count"], 2),
"avg_count":
avg["avg_count"]
}))
def get(self, request):
date_range = request.GET.get("date_range")
start_date, end_date, error = self.get_date_range(date_range)
if error:
return Response(error, status=400)
if not request.user.domain:
res = {
"data": [{
"dateStr": "0",
"dateObj": "0",
"count": 0
}],
"max": {
"count": None,
"dateStr": None
},
"dateStr": 0,
"avg_count": 0
}
no_data = True
avg = {"avg_count": 0}
return Response(
create_response({
"result": res,
"no_data": no_data,
"avg_count": avg["avg_count"]
}))
domain_id = request.user.domain.domain_id
pipeline = self.pipeline(start_date, end_date, domain_id)
data = list(self.events.collection.aggregate(pipeline))
if data:
def max_func(x):
return x["count"]
max_values = max(data, key=max_func)
avg = self.get_avg(start_date, end_date, domain_id)
past_start_date, past_end_date, error = self.get_past_range(
date_range)
past_avg = self.get_avg(past_start_date, past_end_date, domain_id)
res = {
"data": data,
"max": {
"count": max_values["count"],
"dateStr": max_values["dateStr"]
}
}
no_data = False
else:
res = {
"data": [{
"dateStr": "0",
"dateObj": "0",
"count": 0
}],
"max": {
"count": None,
"dateStr": None
},
"dateStr": 0,
"avg_count": 0
}
no_data = True
avg = {"avg_count": 0}
past_avg = {"avg_count": 0}
return Response(
create_response({
"result":
res,
"no_data":
no_data,
"avg_count":
avg["avg_count"],
"diff":
round(avg["avg_count"] - past_avg["avg_count"], 2)
}))
def get(self, request):
date_range = request.GET.get("date_range")
start_date, end_date, error = self.get_date_range(date_range)
if error:
return Response(error, status=400)
if not request.user.domain:
data = [{"dateStr": None, "avg_count": 0}]
no_data = True
avg = {"avg_count": 0}
return Response(
create_response({
"result": data,
"no_data": no_data,
"avg_count": avg["avg_count"]
}))
domain_id = request.user.domain.domain_id
pipeline = [{
"$match": {
"$and": [{
"ts": {
"$gte": start_date,
"$lte": end_date
}
}, {
"domain": domain_id
}]
}
}, {
"$project": {
"_id": 0,
"datePartDay": {
"$concat": [{
"$substr": [{
"$dayOfMonth": "$ts"
}, 0, 2]
}, "-", {
"$substr": [{
"$month": "$ts"
}, 0, 2]
}, "-", {
"$substr": [{
"$year": "$ts"
}, 0, 4]
}]
},
"sid": "$sid"
}
}, {
"$group": {
"_id": {
"datePartDay": "$datePartDay",
"sid": "$sid"
},
"count": {
"$sum": 1
}
}
}, {
"$project": {
"_id": 0,
"dateObj": {
"$dateFromString": {
"dateString": "$_id.datePartDay"
}
},
"count": "$count",
"sid": "$_id.sid",
"dateStr": "$_id.datePartDay"
}
}, {
"$group": {
"_id": "$dateStr",
"avg_count": {
"$avg": "$count"
}
}
}, {
"$project": {
"_id": 0,
"dateStr": "$_id",
"avg_count": {
"$round": ["$avg_count", 1]
}
}
}, {
"$sort": {
"dateStr": -1
}
}]
data = list(self.events.collection.aggregate(pipeline))
no_data = False
if not data:
data = [{"dateStr": None, "avg_count": 0}]
no_data = True
avg = {"avg_count": 0}
past_avg = {"avg_count": 0}
else:
past_start_date, past_end_date, error = self.get_past_range(
date_range)
past_avg = self.get_avg(past_start_date, past_end_date, domain_id)
avg = self.get_avg(start_date, end_date, domain_id)
return Response(
create_response({
"result":
data,
"no_data":
no_data,
"avg_count":
avg["avg_count"],
"diff":
round(avg["avg_count"] - past_avg["avg_count"], 2)
}))
def get(self, request):
date_range = request.GET.get("date_range")
start_date, end_date, error = self.get_date_range(date_range)
if error:
return Response(error, status=400)
if not request.user.domain:
res = [{
"author": None,
"article_details": 0,
"article_search_details": 0
}]
no_data = True
avg = {"avg_count": 0}
return Response(
create_response({
"result": res,
"no_data": no_data,
"avg_count": avg["avg_count"]
}))
domain_id = request.user.domain.domain_id
pipeline = [{
"$match": {
"$and": [{
"ts": {
"$gte": start_date,
"$lte": end_date
}
}, {
"domain": domain_id
}]
}
}, {
"$match": {
"$or": [{
"action": "article_detail"
}, {
"action": "article_search_details"
}]
}
}, {
"$group": {
"_id": {
"action": "$action",
"author_name": "$author_name"
},
"count": {
"$sum": 1
}
}
}, {
"$project": {
"_id": 0,
"author": "",
"action": "$_id.action",
"count": "$count"
}
}, {
"$sort": {
"author": 1
}
}]
data = list(self.events.collection.aggregate(pipeline))
if data:
res = []
past_start_date, past_end_date, error = self.get_past_range(
date_range)
past_avg = self.get_avg(past_start_date, past_end_date, domain_id)
for key, values in groupby(data, itemgetter("author")):
d = {"author": key}
for v in values:
d[v["action"]] = v["count"]
res.append(d)
no_data = False
avg = self.get_avg(start_date, end_date, domain_id)
else:
res = [{
"author": None,
"article_details": 0,
"article_search_details": 0
}]
no_data = True
avg = {"avg_count": 0}
past_avg = {'avg_count': 0}
return Response(
create_response({
"result":
res,
"no_data":
no_data,
"avg_count":
avg["avg_count"],
"diff":
round(avg["avg_count"] - past_avg["avg_count"], 2)
}))
