def view_piece_of_news(request, piece_of_news_name_slug):
notify.send(request.user, actor=request.user, recipient=request.user, verb="BREAKING NEWS - Donuts are free for Chicago Police officers!")
context = {}
if request.method == "GET":
piece_of_news = News.objects.get(slug=piece_of_news_name_slug)
context['piece_of_news'] = piece_of_news
return render(request, 'pss/piece_of_news.html',context)
def add_friend_to_list(request, pk):
friend = get_object_or_404(Profile, pk=pk)
if request.method == 'POST':
form = MakeFriendForm(request.POST)
if form.is_valid():
user_friend_list = form.save(commit=False)
user_friend_list.friend = friend
user_friend_list.user = request.user
if_obj_exists = Friend.objects.filter(
friend=friend, user__exact=request.user).exists()
if if_obj_exists:
messages.warning(
request,
'{} ya esta en tu lista de amigos!'.format(friend))
return redirect('accounts:detail', pk=pk)
else:
notify.send(sender=request.user,
actor=request.user,
recipient=friend.user,
verb='te agrego a la lista de amigos',
nf_type='followed_by_one_user')
messages.success(
request, '{} fue agregado a tus amigos!'.format(friend))
user_friend_list.save()
return redirect('accounts:detail', pk=pk)
def add_comment_to_comment(request, comment_id):
comment = get_object_or_404(AgricultureComment, pk=comment_id)
post = comment.post
user = post.user
if request.method == 'POST':
form = AgricultureCommentForm(request.POST)
if form.is_valid():
recomment = form.save(commit=False)
recomment.post = post
recomment.parent = comment.id
recomment.depth = 1
recomment.user = request.user.username
recomment.save()
if request.user != user:
notify.send(request.user,
recipient=user,
actor=request.user,
description='agriculture',
verb='add recomment your comment : ' + post.title,
target=post,
nf_type='add_comment')
return redirect('agriculture:detail', post.id)
def group_invite(request, slug):
group = get_object_or_404(GroupProfile, slug=slug)
if not group.can_invite(request.user):
raise Http404()
form = GroupInviteForm(request.POST)
if form.is_valid():
for user in form.cleaned_data["invite_user_identifiers"].split("\n"):
group.invite(
user,
request.user,
role=form.cleaned_data["invite_role"],
)
# notify user that he/she is invited by the group
try:
requested_user = Profile.objects.get(email=user)
except:
pass
else:
notify.send(request.user, recipient=requested_user, actor=request.user,
verb='invited you to join')
return redirect("group_members", slug=group.slug)
def create_plan(request, username):
'''create new plan'''
if request.user.is_superuser:
user = User.objects.get(username=username)
form = PlanForm(request.POST or None)
if form.is_valid():
subtitle = form.cleaned_data.get('subtitle')
date = form.cleaned_data.get('date')
new_plan = Plan.objects.create(user=user,
subtitle=subtitle,
date=date)
messages.success(request, 'Plan Added!')
notify.send(request.user,
recipient=user,
actor=request.user,
verb='Added a new plan.',
nf_type='plan_by_one_user',
target=new_plan)
return HttpResponseRedirect(
reverse("nutrition:list", kwargs={"username": username}))
context = {
"form": form,
}
return render(request, 'nutrition/create_plan.html', context)
else:
return HttpResponse("Only authorized user can add nutrition meals")
def add_workshop(request):
workshops = Workshop.objects.all().order_by('-pk')
if request.method == 'POST':
form = WorkshopForm(request.POST, request.FILES)
if form.is_valid():
workshop = form.save(commit=False)
workshop.added_by = request.user
workshop.save()
# notify
training = workshop
author = User.objects.get(username=request.user)
author_friend = author.friend_set.all()
friends = []
for follower in author_friend:
friend = follower.current_user
friends.append(friend)
followers = list(friends)
if len(followers) >= 1:
notify.send(request.user,
recipient_list=followers,
actor=training,
verb='posted',
nf_type='all')
else:
pass
return render(request, 'Marketplace/workshop.html',
{'workshops': workshops})
else:
form = WorkshopForm()
return render(request, 'Marketplace/add_workshop.html', {'form': form})
def test_single_user_notify(self):
notify.send(User, recipient=self.recipient, actor=self.actor,
verb='poked you')
notification = Notification.objects.get(pk=1)
self.assertEqual(notification.recipient_id, self.recipient.id)
timedelta = timezone.now() - notification.created
self.assertLessEqual(timedelta.seconds, 60)
def map_publish(request, map_pk):
if request.method == 'POST':
try:
map = Map.objects.get(id=map_pk)
except Map.DoesNotExist:
return Http404("Map does not exist")
else:
if request.user != map.owner:
return HttpResponse(
loader.render_to_string(
'401.html', RequestContext(
request, {
'error_message': _("You are not allowed to publish this map.")})), status=401)
# return HttpResponse('you are not allowed to publish this map')
group = map.group
map.status = 'PENDING'
map.current_iteration += 1
map.save()
# notify organization admins about the new published map
managers = list( group.get_managers())
notify.send(request.user, recipient_list = managers, actor=request.user,
verb='pushed a new map for approval', target=map)
map_submission_activity = MapSubmissionActivity(map=map, group=group, iteration=map.current_iteration)
map_submission_activity.save()
# set all the permissions for all the managers of the group for this map
map.set_managers_permissions()
messages.info(request, 'Pushed map succesfully')
return HttpResponseRedirect(reverse('member-workspace-map'))
else:
return HttpResponseRedirect(reverse('member-workspace-map'))
def edit_purchase(request, purchase_id):
if request.user.is_anonymous:
return render(request,
"registration/login.html",
context={"anonymous": True})
purchase = Purchase.objects.get(pk=purchase_id)
edit_form = EditPurchaseForm(request.POST or None, request.FILES)
if request.method == 'POST':
if edit_form.is_valid():
purchase.price = edit_form.cleaned_data['price']
purchase.description = edit_form.cleaned_data['description']
purchase.available = edit_form.cleaned_data['available']
purchase.phone = edit_form.cleaned_data['phone']
purchase.save()
following_users = [u.user for u in purchase.subscribers.all()]
notify.send(request.user,
recipient_list=following_users,
actor=purchase,
verb='modified',
nf_type='edit_purchase')
return HttpResponseRedirect(
reverse('pet:my purchases',
kwargs={
'filter_type': 'timeCreate',
'pet_type': 'all'
}))
else:
messages.error(request, "Error")
context = {'form': edit_form, 'purchase': purchase}
return render(request, "edit_purchase.html", context)
def add_workout(request, username):
"""
New workout plan
:param request:
return
"""
if request.user.is_superuser:
user = User.objects.get(username=username)
form = WorkoutForm(request.POST or None)
if form.is_valid():
title = form.cleaned_data.get('title')
date = form.cleaned_data.get('creation_date')
workout = Workout.objects.create(user=user,
title=title,
creation_date=date)
notify.send(request.user,
recipient=workout.user,
actor=request.user,
verb='Added a new workout.',
nf_type='plan_by_one_user',
target=workout)
messages.success(request, 'Workout Day Added!')
return HttpResponseRedirect(
reverse("workout:overview",
kwargs={"username": workout.user.username}))
context = {
"form": form,
}
return render(request, 'workout/add_workout.html', context)
else:
return HttpResponse("Only authorized user can add workout plans")
return redirect('/')
def sculpt_save_receiver(sender, instance, created, *args, **kwargs):
if created and not instance.parent:
#notify a user.
user_regex = r'@(?P<username>[\w.@+-]+)'
usernames = re.findall(user_regex, instance.content)
# username = usernames[0]
# print(sender.user.username)
# print(instance.user)
# print(created)
# print(username)
# send notification to user here.
hash_regex = r'#(?P<hashtag>[\w\d-]+)'
hashtags = re.findall(hash_regex, instance.content)
parsed_hashtags.send(sender=instance.__class__, hashtag_list=hashtags)
#send hashtag signal to user here
else:
if (instance.reply):
notify.send(instance.user,
recipient=instance.parent.user,
actor=instance.user,
verb='Commented on your post')
def get(self, request, pk=None, format=None):
obj = get_object_or_404(Post, pk=self.kwargs.get("pk"))
url_ = obj.get_posts_url()
user = self.request.user
updated = False
liked = False
user_like = Like.objects.filter(post=obj, user=user)
if user_like:
liked = False
user_like.delete()
#obj.likes.remove(user)
else:
liked = True
#obj.likes.add(user)
Like.objects.create(user=user, post=obj)
notify.send(request.user,
recipient=obj.user,
actor=request.user,
verb='Like your post.',
nf_type='liked_by_one_user',
target=obj)
updated = True
data = {"updated": updated, "liked": liked}
return Response(data)
def change_friend(request, operation, pk):
current_user = User.objects.get(username=request.user)
new_friend = User.objects.get(pk=pk)
if operation == 'add':
Friend.add_friend(current_user, new_friend)
# django notify code
notify.send(request.user,
recipient=new_friend,
actor=request.user,
verb='followed you.',
nf_type='all')
elif operation == 'remove':
Friend.remove_friend(current_user, new_friend)
# django notify code
notify.send(request.user,
recipient=new_friend,
actor=request.user,
verb='stopped following you.',
nf_type='all')
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
def create_event(request):
"""
create an event from admin to user
:param request:
"""
if request.user.is_superuser:
form = AppointmentForm(request.POST)
if form.is_valid():
user = form.cleaned_data.get('user')
if (user == request.user):
context = {
'form': form,
'error_message': 'You are the meeting creator, Please add guest'
}
return render(request, 'create_event.html', context)
task = form.cleaned_data.get('task')
date = form.cleaned_data.get('date')
time = form.cleaned_data.get('time')
app = Appointment.objects.create(user=user, task=task, time=time, date=date, sender=request.user)
notify.send(request.user, recipient=app.user, actor=request.user, verb='Added a new Meeting.',
nf_type='app_by_one_user', target=app)
messages.success(request, 'Appointment Added!')
return HttpResponseRedirect(reverse("appointments:appoint", kwargs={"username": request.user.username}))
context = {'form': form}
return render(request, 'create_event.html', context)
return redirect('home')
def notifications(user):
profile = UserProfile.objects.get(user=user)
if profile.notif_upcoming_event:
for notif in Notification.objects.filter(recipient=user, read=True):
event = notif.actor #the only 'read' notifications are upcoming_event ones, the others are immediately deleted
event.notifications_sent = -1
notif.delete()
event.save()
for e in Event.objects.attending(user):
nb_days = (e.date_time() - timezone.now()).days
nb_minutes = (e.date_time() - timezone.now()).seconds / 60
nb_hours = nb_minutes / 60
#print('delay', e.date_time() - timezone.now(), (e.date_time() - timezone.now()).total_seconds())
seconds_before_event = (e.date_time() -
timezone.now()).total_seconds()
if (e.notifications_sent != -1) and not(e.has_begun()) and \
(seconds_before_event < 1/(2**e.notifications_sent)*INITIAL_DELAY_SECONDS) and (seconds_before_event >= 5 * 60):
e.notifications_sent = math.floor(
math.log2(
INITIAL_DELAY_SECONDS / seconds_before_event)) + 1
e.save()
notify.send(user, recipient = user, actor=e, \
verb = 'is in %d hours and %d minutes from now.' % (nb_hours,nb_minutes%60), nf_type = 'upcoming_event')
def form_valid(self, form):
recievers = []
for user in User.objects.all():
# if self.request.user.email != user.email:
recievers.append(user.email)
users = User.objects.all()
notify.send(self.request.user, recipient_list=list(users), actor=self.request.user,
verb='subvención', obj=form.instance, target=form.instance, nf_type='edit')
object = form.instance
html_message = loader.render_to_string(
'myapp/subv_email_create.html',
{
'name_actor': self.request.user.username,
'name_subv': form.cleaned_data.get('nombre'),
'object': object
}
)
send_mail('Gestión de subvenciones',
'',
self.request.user.email,
['*****@*****.**', '*****@*****.**'],#recievers
html_message=html_message
)
messages.success(self.request, 'Subvención actualizada correctamente!')
return super(SubvencionUpdateView, self).form_valid(form)
def unfollow_business(request, business_id):
business = models.Business.objects.get(pk=business_id)
if request.user.appuser in business.followers.all():
business.followers.remove(request.user.appuser)
managers = models.User.objects.filter(appuser__in=business.managers.all())
notify.send(request.user, recipient_list=list(managers.all()), actor=request.user.appuser,
verb='stopped following your business.', target=business, nf_type='followed_by_one_user')
def approve_request(request, cast: Cast, username: str):
"""
Approves a cast membership request
"""
user = get_object_or_404(User, username=username)
try:
cast.remove_member_request(user.profile)
except ValueError as exc:
messages.error(request, str(exc))
else:
try:
cast.add_member(user.profile)
except ValueError as exc:
messages.error(request, str(exc))
else:
notify.send(request.user,
recipient=user,
actor=request.user,
verb='approved',
obj=user,
target=cast,
nf_type='cast_member_result')
messages.success(request,
f'{user.profile.name} is now a member of {cast}')
return redirect('cast_member_requests', slug=cast.slug)
def layer_remove(request, layername, template='layers/layer_remove.html'):
layer = _resolve_layer(
request,
layername,
'base.delete_resourcebase',
_PERMISSION_MSG_DELETE)
if (request.method == 'GET'):
return render_to_response(template, RequestContext(request, {
"layer": layer
}))
if (request.method == 'POST'):
try:
with transaction.atomic():
delete_layer.delay(object_id=layer.id)
# notify layer owner that someone have deleted the layer
if request.user != layer.owner:
recipient = layer.owner
notify.send(request.user, recipient=recipient, actor=request.user,
target=layer, verb='deleted your layer')
except Exception as e:
message = '{0}: {1}.'.format(_('Unable to delete layer'), layer.typename)
if 'referenced by layer group' in getattr(e, 'message', ''):
message = _('This layer is a member of a layer group, you must remove the layer from the group '
'before deleting.')
messages.error(request, message)
return render_to_response(template, RequestContext(request, {"layer": layer}))
return HttpResponseRedirect(reverse("layer_browse"))
else:
return HttpResponse("Not allowed", status=403)
def add_friend_to_list(request, pk):
friend = get_object_or_404(Profile, pk=pk)
if request.method == 'POST':
form = MakeFriendForm(request.POST)
if form.is_valid():
user_friend_list = form.save(commit=False)
user_friend_list.friend = friend
user_friend_list.user = request.user
if_obj_exists = Friend.objects.filter(
friend=friend, user__exact=request.user).exists()
if if_obj_exists:
messages.warning(
request,
'{} is already in your friends list!'.format(friend))
return redirect('accounts:detail', pk=pk)
else:
notify.send(sender=request.user,
actor=request.user,
recipient=friend.user,
verb='added you to his friends list',
nf_type='followed_by_one_user')
messages.success(
request,
'{} was added to your friends list!'.format(friend))
user_friend_list.save()
return redirect('accounts:detail', pk=pk)
def layer_publish(request, layer_pk):
if request.method == 'POST':
try:
layer = Layer.objects.get(id=layer_pk)
except Layer.DoesNotExist:
return Http404("Layer does not exist")
else:
if request.user != layer.owner:
return HttpResponse(
loader.render_to_string(
'401.html', RequestContext(
request, {
'error_message': _("You are not allowed to publish this layer.")})), status=401)
# return HttpResponse('you are not allowed to publish this layer')
group = layer.group
layer.status = 'PENDING'
layer.current_iteration += 1
layer.save()
layer_submission_activity = LayerSubmissionActivity(layer=layer, group=group, iteration=layer.current_iteration)
layer_submission_activity.save()
# notify organization admins about the new published layer
managers = list( group.get_managers())
notify.send(request.user, recipient_list = managers, actor=request.user,
verb='pushed a new layer for approval', target=layer)
# set all the permissions for all the managers of the group for this layer
layer.set_managers_permissions()
messages.info(request, 'Pushed layer succesfully for approval')
return HttpResponseRedirect(reverse('member-workspace-layer'))
else:
return HttpResponseRedirect(reverse('member-workspace-layer'))
def dispute_create(request):
form = forms.DisputeForm(request.POST or None)
try:
order = request.user.appuser.user_orders.get(pk=request.GET.get('order_id'))
appointment = None
except:
order = None
appointment = request.user.appuser.user_appointments.get(pk=request.GET.get('appointment_id'))
if form.is_valid():
instance = form.save(commit=False)
instance.user = request.user.appuser
if order:
instance.order = order
instance.business = order.business
else:
instance.appointment = appointment
instance.business = appointment.business
create_conversation(instance, instance.business, instance.user)
instance.save()
managers = models.User.objects.filter(appuser__in=instance.business.managers.all())
notify.send(request.user, recipient_list=list(managers.all()), actor=request.user.appuser,
verb='created new dispute.', target=instance, nf_type='create')
return redirect('my user dispute list')
context = {
'form': form
}
return render(request, 'BaseApp/Dispute/create.html', context)
def test_render_template_tag(self):
notify.send(User, recipient=self.user,
actor_text='Joe', verb='followed you')
nf_list = Notification.objects.filter(recipient=self.user).active()
rendered = self.RENDER_TEMPLATE.render(
Context({'notifications': nf_list}))
self.assertIn('followed you', rendered)
def test_single_user_notify(self):
notify.send(User, recipient=self.recipient, actor=self.actor,
verb='poked you')
notification = Notification.objects.get(pk=1)
self.assertEqual(notification.recipient_id, self.recipient.id)
timedelta = timezone.now() - notification.created
self.assertLessEqual(timedelta.seconds, 60)
def test_render_template_tag(self):
notify.send(User, recipient=self.user,
actor_text='Joe', verb='followed you')
nf_list = Notification.objects.filter(recipient=self.user).active()
rendered = self.RENDER_TEMPLATE.render(
Context({'notifications': nf_list}))
self.assertIn('followed you', rendered)
def ticket(request, ticket_id):
ticket = get_object_or_404(Ticket, pk=ticket_id)
form = AnswerForm()
if request.method == "POST":
resolution = request.POST.get('resolution', '')
ticket.resolution = resolution
ticket.ticketState = Ticket.RESOLVED_STATUS
ticket.staff = request.user
ticket.resolved = datetime.now()
ticket.save()
notify.send(request.user,
recipient=ticket.user,
actor=request.user,
verb='followed you.',
nf_type='followed_by_one_user')
return HttpResponseRedirect(reverse('helpdesk:tickets'))
# if not _has_access_to_queue(request.user, ticket.queue):
# raise PermissionDenied()
return render(
request,
'helpdesk/ticket_staff.html',
{
'ticket': ticket,
'form': form,
# 'form': form,
})
def comment_question_ajax(request, pk):
question = get_object_or_404(Question, pk=pk)
last_comment = Comment.objects.filter(question_comments=question).last()
response_data = {}
if request.method == 'POST':
comment_text = request.POST.get('text')
new_comment = highlight(strip_tags(comment_text))
comment = Comment(content_object=question,
text=new_comment,
posted_by=request.user)
comment.save()
send_notify(request, question, 'answer', comment_text)
if question.asked_by != request.user:
notify.send(request.user,
recipient=question.asked_by,
actor=request.user,
verb='commented on your question',
obj=question,
nf_type='question_commented_on')
response_data['id'] = comment.pk
response_data['text_html'] = urlize(new_comment)
response_data['posted_by'] = comment.posted_by.username
response_data['posted_by_id'] = comment.posted_by.id
response_data['posted_on'] = shorten_naturaltime(
naturaltime(comment.posted_on))
if last_comment is None:
response_data['last_comment'] = "null"
else:
response_data['last_comment'] = last_comment.id
return JsonResponse(response_data)
def document_publish(request, document_pk):
if request.method == 'POST':
try:
document = Document.objects.get(id=document_pk)
except Document.DoesNotExist:
return Http404("Document does not exist")
else:
if request.user != document.owner:
return HttpResponse(
loader.render_to_string(
'401.html', RequestContext(
request, {
'error_message': _("you are not allowed to publish this document.")})), status=403)
# return HttpResponse('you are not allowed to publish this document')
group = document.group
document.status = 'PENDING'
document.current_iteration += 1
document.save()
document_submission_activity = DocumentSubmissionActivity(document=document, group=group, iteration=document.current_iteration)
document_submission_activity.save()
# notify organization admins about the new published document
managers = list( group.get_managers())
notify.send(request.user, recipient_list = managers, actor=request.user,
verb='pushed a new document for approval', target=document)
# set all the permissions for all the managers of the group for this documentt
document.set_managers_permissions()
messages.info(request, 'Pushed document succesfully for approval')
return HttpResponseRedirect(reverse('member-workspace-document'))
else:
return HttpResponseRedirect(reverse('member-workspace-document'))
def accept(request, pk):
if not request.user.is_authenticated:
return HttpResponse('Not logged in', status=401)
answer = Answer.objects.get(pk=pk)
if answer.answered_by == answer.question.asked_by:
return HttpResponseBadRequest('Answered by question-poster',
status=400)
if request.method == 'POST':
accept_type = request.POST.get('accept_type')
if accept_type == 'accept' and not answer.accepted:
answer.accepted = True
answer.save()
answer.answered_by.accepted_answer()
notify.send(request.user,
recipient=answer.answered_by,
actor=request.user,
verb='accepted your answer',
obj=answer,
target=answer.question,
nf_type='answer_accepted')
return JsonResponse({'accept_type': accept_type})
elif accept_type == 'cancel_accept' and answer.accepted:
answer.accepted = False
answer.save()
answer.answered_by.accepted_answer_cancel()
return JsonResponse({'accept_type': accept_type})
else:
return HttpResponseBadRequest('The request is not POST', status=400)
def news_feed(request):
posts = request.session['business'].business_base_posts.all().order_by('-is_important', 'changed_at')[:5]
form = forms.PostForm((request.POST or None))
if form.is_valid():
instance = form.save(commit=False)
instance.business = request.session['business']
instance.save()
followers = models.User.objects.filter(appuser__in=instance.business.followers.all())
if followers:
notify.send(request.user, recipient_list=list(followers), actor=instance.business,
verb='published new post.',
target=instance, nf_type='create')
return redirect('default')
if request.GET.get('like'):
post = models.BasePost.objects.get(pk=request.GET.get('like'))
post.followers.add(request.user.appuser)
if request.GET.get('dislike'):
post = models.BasePost.objects.get(pk=request.GET.get('dislike'))
post.followers.remove(request.user.appuser)
context = {
'form': form,
'posts': posts,
}
return render(request, 'BaseApp/NewsFeed/news_feed.html', context)
def purchase_detail(request, purchase_id):
try:
purchase = Purchase.objects.get(pk=purchase_id)
except Purchase.DoesNotExist:
raise Http404("Purchase does not exist")
comment_form = CommentForm(request.POST or None)
if request.method == 'POST':
if comment_form.is_valid():
new_comment = Comment.objects.create(post=purchase,
author=request.user)
new_comment.text = comment_form.cleaned_data['text']
new_comment.save()
notify.send(request.user,
recipient=purchase.owner.user,
actor=request.user,
verb='commented on your ',
target=purchase,
nf_type='comment')
return render(request, 'purchase_detail.html',
{'purchase': purchase})
return render(request, 'purchase_detail.html', {
'purchase': purchase,
'comment_form': comment_form
})
def order_create(request):
cart = Cart(request)
if request.method == 'POST':
form = OrderCreateForm(request.POST)
if form.is_valid():
order = form.save()
for item in cart:
OrderItem.objects.create(
order=order,
customer=request.user.profile.username,
product=item['product'],
price=item['price'],
calories=item['product'].calories,
quantity=item['quantity'])
import pdb
pdb.set_trace()
# clear the cart
cart.clear()
order_created(order.id)
request.session['order_id'] = order.id
# import pdb
# pdb.set_trace()
customer_user = User.objects.get(username='******')
notify.send(request.user,
recipient=customer_user,
actor=request.user,
verb='placed an order',
nf_type='followed_by_one_user')
# redirect to the payment
return redirect('shop:product_list')
# return redirect('payment:process')
else:
form = OrderCreateForm()
return render(request, 'orders/create.html', {'cart': cart, 'form': form})
def group_invite(request, slug):
group = get_object_or_404(GroupProfile, slug=slug)
if not group.can_invite(request.user):
raise Http404()
form = GroupInviteForm(request.POST)
if form.is_valid():
for user in form.cleaned_data["invite_user_identifiers"].split("\n"):
group.invite(
user,
request.user,
role=form.cleaned_data["invite_role"],
)
# notify user that he/she is invited by the group
try:
requested_user = Profile.objects.get(email=user)
except:
pass
else:
notify.send(request.user, recipient=requested_user, actor=request.user,
verb='invited you to join')
return redirect("group_members", slug=group.slug)
def return_equipment(request):
if request.method == "POST":
Issueance_pk = request.POST.get('Issueance_pk')
if UserProfile.objects.get(user=request.user).is_admin == True:
issue = Issueance.objects.get(pk=Issueance_pk)
equipment = issue.equipmentInstance
issue.returned = True
issue.save()
issue.return_date = timezone.now()
equipment.is_available = True
issue.save()
equipment.save()
followers = list(equipment.equipment.followers.all())
notify.send(
request.user,
recipient_list=followers,
actor=equipment,
verb='is available now!.',
)
notification = "equipment returned"
ctx = {
'noti': True,
}
return HttpResponse(json.dumps(ctx),
content_type='application/json')
ctx = {
'noti': False,
}
return HttpResponse(json.dumps(ctx), content_type='application/json')
def managers_delete(request, cast: Cast, pk: int):
"""
Remove a user from cast managers
"""
user = get_object_or_404(User, pk=pk)
if cast.managers.count() < 2:
messages.error(request, 'Casts must have at least one manager')
elif request.user == user:
messages.error(request, 'You cannot remove yourself')
else:
try:
cast.remove_manager(user.profile)
except ValueError as exc:
messages.error(request, str(exc))
else:
notify.send(request.user,
recipient_list=cast.managers_as_user + [user],
actor=request.user,
verb='removed',
obj=user,
target=cast,
nf_type='cast_manager')
messages.success(request,
f'{user.username} is no longer a manager')
return redirect('cast_managers_edit', slug=cast.slug)
def addarticle(request):
if request.method == 'POST':
form = articleForm(request.POST, request.FILES)
if form.is_valid():
article = form.save(commit=False)
article.added_by = request.user
article.save()
# django notify
post = article
author = User.objects.get(username=request.user)
author_friend = author.friend_set.all()
friends = []
for follower in author_friend:
friend = follower.current_user
friends.append(friend)
followers = list(friends)
if len(followers) >= 1:
notify.send(request.user,
recipient_list=followers,
actor=post,
verb='posted',
nf_type='all')
else:
pass
return redirect('articledetail', pk=article.pk)
else:
form = articleForm()
return render(request, 'Marketplace/articleform.html', {'form': form})
def save_model(self, request, obj, form, change):
u = []
if obj.is_dirty():
dirty_fields = obj.get_dirty_fields()
#print(dirty_fields)
for field in dirty_fields:
if field == 'image':
user = User.objects.filter(is_superuser=False)
for x in user:
for y in x.profile.selected:
if y == obj.id:
u.append(x)
#print(u)
if not u:
recipient = user
else:
recipient = u
notify.send(sender=self,
target=obj,
recipient_list=list(recipient),
verb="updated")
for person in recipient:
subject = 'Notification of update'
verb = "updated"
message = render_to_string(
'darshan/notification_email.html', {
'target': obj,
'verb': verb
})
person.email_user(subject, message)
obj.save()
def test_render_template_tag_for_box(self):
notify.send(User, recipient=self.user,
actor_text='Joe', verb='followed you')
nf_list = Notification.objects.filter(recipient=self.user).active()
rendered = self.RENDER_TEMPLATE_FOR_BOX.render(
Context({'notifications': nf_list}))
# to make things differentiable we'll use n-rTt-bx as a flag
# in the default ``box`` template.
self.assertIn('n-rTt-bx', rendered)
self.assertIn('followed you', rendered)
def test_multiple_user_notify(self):
notify.send(User, recipient_list=list(self.recipient_list),
actor=self.actor, verb='uploaded a new video')
notifications = Notification.objects.filter(verb__startswith='u')
self.assertEqual(notifications.count(), self.no_of_users)
username_list = [u.username for u in self.recipient_list]
for nf in notifications:
self.assertIn(nf.recipient.username, username_list)
timedelta = timezone.now() - nf.created
self.assertLessEqual(timedelta.seconds, 60)
def document_remove(request, docid, template='documents/document_remove.html'):
try:
document = _resolve_document(
request,
docid,
'base.delete_resourcebase',
_PERMISSION_MSG_DELETE)
if request.method == 'GET':
return render_to_response(template, RequestContext(request, {
"document": document
}))
if request.method == 'POST':
if getattr(settings, 'SLACK_ENABLED', False):
slack_message = None
try:
from geonode.contrib.slack.utils import build_slack_message_document
slack_message = build_slack_message_document("document_delete", document)
except:
print "Could not build slack message for delete document."
document.delete()
# notify document owner that someone have deleted the document
if request.user != document.owner:
recipient = document.owner
notify.send(request.user, recipient=recipient, actor=request.user,
target=document, verb='deleted your document')
try:
from geonode.contrib.slack.utils import send_slack_messages
send_slack_messages(slack_message)
except:
print "Could not send slack message for delete document."
else:
document.delete()
# notify document owner that someone have deleted the document
if request.user != document.owner:
recipient = document.owner
notify.send(request.user, recipient=recipient, actor=request.user,
target=document, verb='deleted your document')
return HttpResponseRedirect(reverse("document_browse"))
else:
return HttpResponse("Not allowed", status=403)
except PermissionDenied:
return HttpResponse(
loader.render_to_string(
'401.html', RequestContext(
request, {
'error_message': _("You are not allowed to delete this document.")})), status=401)
def userinvitation(request, slug):
"""
"""
if request.method == 'POST':
group = get_object_or_404(GroupProfile, slug=slug)
if group.access == "public-invite":
user_invitation = UserInvitationModel(user=request.user, group=group, state='pending')
user_invitation.save()
managers = list(group.get_managers())
notify.send(request.user, recipient_list=managers, actor=request.user,
target=group, verb='requested to join {}'.format(group.title))
return redirect("group_detail", slug=slug)
def setUp(self):
self.recipient = User.objects.create(username='******',
email='*****@*****.**',
password='******')
self.actor = User.objects.create(username='******',
email='*****@*****.**',
password='******')
self.nf_count = 10
self.assertEqual(self.recipient.id, 1)
self.assertEqual(self.actor.id, 2)
for x in range(self.nf_count):
notify.send(User, recipient=self.recipient, actor=self.actor,
verb='followed you')
def document_deny(request, document_pk):
if request.method == 'POST':
form = ResourceDenyForm(request.POST)
if form.is_valid():
try:
document = Document.objects.get(id=document_pk)
except Document.DoesNotExist:
return Http404("requested document does not exists")
else:
group = document.group
if request.user not in group.get_managers():
return HttpResponse(
loader.render_to_string(
'401.html', RequestContext(
request, {
'error_message': _("you are not allowed to deny this document.")})), status=401)
# return HttpResponse("you are not allowed to deny this document")
document_submission_activity = DocumentSubmissionActivity.objects.get(document=document, group=group, iteration=document.current_iteration)
document_audit_activity= DocumentAuditActivity(document_submission_activity=document_submission_activity)
comment_body = request.POST.get('comment')
comment_subject = request.POST.get('comment_subject')
document.status = 'DENIED'
document.last_auditor = request.user
document.save()
# notify document owner that someone have deleted the document
if request.user != document.owner:
recipient = document.owner
notify.send(request.user, recipient=recipient, actor=request.user,
target=document, verb='deleted your document')
document_submission_activity.is_audited = True
document_submission_activity.save()
document_audit_activity.comment_subject = comment_subject
document_audit_activity.comment_body = comment_body
document_audit_activity.result = 'DECLINED'
document_audit_activity.auditor = request.user
document_audit_activity.save()
messages.info(request, 'Denied document successfully')
return HttpResponseRedirect(reverse('admin-workspace-document'))
else:
messages.info(request, 'Please write a deny comment and try again')
return HttpResponseRedirect(reverse('admin-workspace-document'))
else:
return HttpResponseRedirect(reverse('admin-workspace-document'))
def layer_deny(request, layer_pk):
if request.method == 'POST':
form = ResourceDenyForm(data=request.POST)
if form.is_valid():
try:
layer = Layer.objects.get(id=layer_pk)
except:
return Http404("requested layer does not exists")
else:
group = layer.group
if request.user not in group.get_managers():
return HttpResponse(
loader.render_to_string(
'401.html', RequestContext(
request, {
'error_message': _("You are not allowed to deny this layer.")})), status=401)
# return HttpResponse("you are not allowed to deny this layer")
layer_submission_activity = LayerSubmissionActivity.objects.get(layer=layer, group=group, iteration=layer.current_iteration)
layer_audit_activity = LayerAuditActivity(layer_submission_activity=layer_submission_activity)
comment_body = request.POST.get('comment')
comment_subject = request.POST.get('comment_subject')
layer.status = 'DENIED'
layer.last_auditor = request.user
layer.save()
# notify layer owner that someone have denied the layer
if request.user != layer.owner:
recipient = layer.owner
notify.send(request.user, recipient=recipient, actor=request.user,
target=layer, verb='denied your layer')
layer_submission_activity.is_audited = True
layer_submission_activity.save()
layer_audit_activity.comment_subject = comment_subject
layer_audit_activity.comment_body = comment_body
layer_audit_activity.result = 'DECLINED'
layer_audit_activity.auditor = request.user
layer_audit_activity.save()
messages.info(request, 'layer denied successfully')
return HttpResponseRedirect(reverse('admin-workspace-layer'))
else:
messages.info(request, 'Please write a deny comment and try again')
return HttpResponseRedirect(reverse('admin-workspace-layer'))
else:
return HttpResponseRedirect(reverse('admin-workspace-layer'))
def appointment_details(request, appointment_id):
object = get_object_or_404(models.Appointment, pk=appointment_id)
if request.GET.get('accept'):
object.status = 'accepted'
object.save()
notify.send(request.user, recipient=object.user.user, actor=object.business,
verb='accepted your order.', target=object, nf_type='accept')
elif request.GET.get('reject'):
object.status = 'rejected'
object.save()
notify.send(request.user, recipient=object.user.user, actor=object.business,
verb='rejected your order.', target=object, nf_type='reject')
context = {
'object': object,
}
return render(request, 'BaseApp/Appointment/details.html', context)
def dispute_details(request, dispute_id):
object = request.session['business'].business_disputes.get(pk=dispute_id)
if request.GET.get('accept'):
object.status = 'accepted'
object.save()
notify.send(request.user, recipient=object.user.user, actor=object.business,
verb='accepted your order.', target=object, nf_type='accept')
elif request.GET.get('reject'):
object.status = 'rejected'
object.save()
notify.send(request.user, recipient=object.user.user, actor=object.business,
verb='rejected your order.', target=object, nf_type='reject')
context = {
"object": object,
}
return render(request, 'BaseApp/Dispute/details.html', context)
def setUp(self):
user = User(username='******', email='*****@*****.**')
user.set_password('pwd@user')
user.save()
self.user = User.objects.get(username='******')
actor = User.objects.create_user('actor', '*****@*****.**',
'pwd@actor')
for x in range(10):
notify.send(User, recipient=self.user, actor=actor,
verb='followed you', nf_type='followed_you')
factory = RequestFactory()
self.request = factory.get('/foobar/')
def discount_benefit_create(request):
form = forms.DiscountBenefitForm(request.POST or None)
items = models.Item.objects.filter(catalog__business__id=request.session['business'].id).exclude(
itemdiscount__new_price__gte=0)
services = models.Service.objects.filter(catalog__business__id=request.session['business'].id).exclude(
servicediscount__new_price__gte=0)
if form.is_valid():
instance = form.save(commit=False)
base_benefit = request.session['BaseBenefit']
base_benefit.business = request.session['business']
base_benefit.save()
instance.benefit = base_benefit
instance.save()
if instance.discount_type == 'item_discounts':
print()
selected = request.POST.getlist('item_checks')
for item in items:
if str(item.id) in selected:
item_discount = models.ItemDiscount()
item_discount.new_price = item.price * (1 - (instance.discount_percentage / 100))
item_discount.item = item
item_discount.save()
instance.item_discounts.add(item_discount)
elif instance.discount_type == 'service_discounts':
selected = request.POST.getlist('service_checks')
for service in services:
if str(service.id) in selected:
service_discount = models.ServiceDiscount()
service_discount.new_price = service.price * (1 - (instance.discount_percentage / 100))
service_discount.service = service
service_discount.save()
instance.service_discounts.add(service_discount)
else:
purchase_amount = request.POST.get('purchase_amount')
instance.purchase_amount_discount = float(purchase_amount)
instance.save()
followers = models.User.objects.filter(appuser__in=base_benefit.business.followers.all())
if followers:
notify.send(request.user, recipient_list=list(followers), actor=base_benefit.business,
verb='created a new discount benefit.', target=instance, nf_type='create')
return redirect('default')
context = {
'form': form,
'items': items,
'services': services,
}
return render(request, 'BaseApp/BaseBenefit/DiscountBenefit/create.html', context)
def map_deny(request, map_pk):
if request.method == 'POST':
form = ResourceDenyForm(request.POST)
if form.is_valid():
try:
map = Map.objects.get(id=map_pk)
except:
return Http404("requested map does not exists")
else:
group = map.group
if request.user not in group.get_managers():
return HttpResponse(
loader.render_to_string(
'401.html', RequestContext(
request, {
'error_message': _("You are not allowed to deny this map.")})), status=401)
# return HttpResponse("you are not allowed to deny this map")
map_submission_activity = MapSubmissionActivity.objects.get(map=map, group=group, iteration=map.current_iteration)
map_audit_activity= MapAuditActivity(map_submission_activity=map_submission_activity)
comment_body = request.POST.get('comment')
comment_subject = request.POST.get('comment_subject')
map.status = 'DENIED'
map.last_auditor = request.user
map.save()
# notify map owner that someone have denied the map
if request.user != map.owner:
recipient = map.owner
notify.send(request.user, recipient=recipient, actor=request.user,
target=map, verb='denied your map')
map_submission_activity.is_audited = True
map_submission_activity.save()
map_audit_activity.comment_subject = comment_subject
map_audit_activity.comment_body = comment_body
map_audit_activity.result = 'DECLINED'
map_audit_activity.auditor = request.user
map_audit_activity.save()
messages.info(request, 'Denied map successfully')
return HttpResponseRedirect(reverse('admin-workspace-map'))
else:
messages.info(request, 'Please write an deny comment and try again')
return HttpResponseRedirect(reverse('admin-workspace-map'))
else:
return HttpResponseRedirect(reverse('admin-workspace-map'))
def order_create(request):
business_id = request.GET.get('order_business_id')
business = models.Business.objects.get(pk=business_id)
items_list = models.Item.objects.all().filter(catalog__business__id=business_id)
form = forms.OrderForm(request.POST or None)
address_form = forms.AddressForm(request.POST or None)
if form.is_valid() & address_form.is_valid():
instance = form.save(commit=False)
instance.user = request.user.appuser
business = get_object_or_404(models.Business, id=int(request.GET.get('order_business_id')))
instance.business = business
instance.save()
total = 0
for item in items_list:
item_id = 'item_' + str(item.id)
quantity = int(request.POST[item_id])
if quantity > 0:
total += (item.price * quantity)
item_order = models.ItemOrder()
item_order.item = item
item_order.order = instance
item_order.quantity = quantity
item_order.save()
instance.total = total
address = address_form.save(commit=False)
print("heloooooooooooooooooooooooooooooooooooooooo"+request.POST.get('address_raw'))
address.raw = request.POST.get('address_raw')
address.save()
instance.address = address
create_conversation(instance, business, request.user.appuser)
instance.save()
get_order_benefits(instance)
assign_coupons_to_order(request, instance)
use_order_benefits(instance)
managers = models.User.objects.filter(appuser__in=business.managers.all())
notify.send(request.user, recipient_list=list(managers.all()), actor=request.user.appuser,
verb='created new order.', target=instance, nf_type='create')
return redirect('my user order list')
context = {
'items_list': items_list,
'form': form,
'address_form': address_form,
'business': business,
}
return render(request, 'BaseApp/Order/create.html', context)
def map_remove(request, mapid, template='maps/map_remove.html'):
''' Delete a map, and its constituent layers. '''
map_obj = _resolve_map(request, mapid, 'base.delete_resourcebase', _PERMISSION_MSG_VIEW)
if request.method == 'GET':
return render_to_response(template, RequestContext(request, {
"map": map_obj
}))
elif request.method == 'POST':
if getattr(settings, 'SLACK_ENABLED', False):
slack_message = None
try:
from geonode.contrib.slack.utils import build_slack_message_map
slack_message = build_slack_message_map("map_delete", map_obj)
except:
print "Could not build slack message for delete map."
delete_map.delay(object_id=map_obj.id)
# notify map owner that someone have deleted the map
if request.user != map_obj.owner:
recipient = map_obj.owner
notify.send(request.user, recipient=recipient, actor=request.user,
target=map_obj, verb='deleted your map')
try:
from geonode.contrib.slack.utils import send_slack_messages
send_slack_messages(slack_message)
except:
print "Could not send slack message for delete map."
else:
delete_map.delay(object_id=map_obj.id)
# notify map owner that someone have deleted the map
if request.user != map_obj.owner:
recipient = map_obj.owner
notify.send(request.user, recipient=recipient, actor=request.user,
target=map_obj, verb='deleted your map')
return HttpResponseRedirect(reverse("maps_browse"))
def catalog_create(request, business_id):
if str(request.session['business'].id) != business_id:
return redirect('default')
business = get_object_or_404(models.Business, pk=business_id)
form = forms.CatalogForm(request.POST or None, request.FILES or None)
if form.is_valid():
instance = form.save(commit=False)
instance.changed_at = datetime.now()
instance.business = business
instance.save()
followers = models.User.objects.filter(appuser__in=business.followers.all())
if followers:
notify.send(request.user, recipient_list=list(followers), actor=business, verb='created a new catalog.',
target=instance, nf_type='create')
return redirect('catalog list', business_id)
context = {
'business_id': int(business_id),
'form': form,
}
return render(request, 'BaseApp/Catalog/create.html', context)
def create_appointment_select_service_and_date(request):
if request.GET.get('business_id'):
request.session['appointment_business_id'] = request.GET.get('business_id')
if request.GET.get('service_id') and request.GET.get('date'):
request.session['appointment_service_id'] = request.GET.get('service_id')
request.session['appointment_date'] = request.GET.get('date')
return create_appointment_select_time(request)
if request.GET.get('date_time'):
object = request.GET.get('date_time')
date_time = datetime.strptime(object, "%d/%m/%Y %H:%M")
business_id = request.session['appointment_business_id']
business = models.Business.objects.all().get(pk=business_id)
service_id = request.session['appointment_service_id']
service = models.Service.objects.all().get(pk=service_id)
appointment = models.Appointment()
appointment.service = service
appointment.business = business
appointment.date = date_time
appointment.user = request.user.appuser
try:
appointment.total = service.servicediscount.new_price
except:
appointment.total = service.price
appointment.save()
create_conversation(appointment, business, request.user.appuser)
managers = models.User.objects.filter(appuser__in=appointment.business.managers.all())
notify.send(request.user, recipient_list=list(managers.all()), actor=request.user.appuser,
verb='created new appointment.', target=appointment, nf_type='create')
appointment.save()
return redirect('my user appointment list')
service_list = models.Service.objects.all().filter(catalog__business__id=request.session['appointment_business_id'])
context = {
'service_list': service_list,
}
return render(request, 'BaseApp/Appointment/create_1.html', context)
def ticket_benefit_create(request):
form = forms.TicketBenefitForm(request.POST or None)
items = models.Item.objects.filter(catalog__business__id=request.session['business'].id)
services = models.Service.objects.filter(catalog__business__id=request.session['business'].id)
if form.is_valid():
instance = form.save(commit=False)
base_benefit = request.session['BaseBenefit']
base_benefit.business = request.session['business']
base_benefit.save()
instance.benefit = base_benefit
instance.required_punches -= 1
instance.save()
if instance.reward_type == 'item_reward':
selected = request.POST.get('item_checks')
for item in items:
if str(item.id) == selected:
instance.item_reward = item
elif instance.reward_type == 'service_reward':
selected = request.POST.get('service_checks')
for service in services:
if str(service.id) == selected:
instance.service_reward = service
else:
money_reward = request.POST.get('money_reward')
instance.money_reward = money_reward
instance.save()
followers = models.User.objects.filter(appuser__in=base_benefit.business.followers.all())
if followers:
notify.send(request.user, recipient_list=list(followers), actor=base_benefit.business,
verb='created a new ticket benefit.', target=instance, nf_type='create')
return redirect('default')
context = {
'form': form,
'items': items,
'services': services,
}
return render(request, 'BaseApp/BaseBenefit/TicketBenefit/create.html', context)
def post_comment(request, content_type_id, object_id, form_class=CommentForm):
content_type = get_object_or_404(ContentType, pk=content_type_id)
obj = get_object_or_404(content_type.model_class(), pk=object_id)
form = form_class(request.POST, request=request, obj=obj, user=request.user)
if form.is_valid():
comment = form.save()
# notify resource owner that someone have commented on his resource
if request.user != obj.owner:
recipient = obj.owner
notify.send(request.user, recipient=recipient, actor=request.user,
target=obj, verb='commented on your {0}'.format(content_type.name))
commented.send(sender=post_comment, comment=comment, request=request)
if request.is_ajax():
return HttpResponse(json.dumps({
"status": "OK",
"comment": dehydrate_comment(comment),
"html": render_to_string("dialogos/_comment.html", {
"comment": comment
}, context_instance=RequestContext(request))
}), content_type="application/json")
else:
if request.is_ajax():
return HttpResponse(json.dumps({
"status": "ERROR",
"errors": form.errors,
"html": render_to_string("dialogos/_form.html", {
"form": form,
"obj": obj
}, context_instance=RequestContext(request))
}), content_type="application/json")
redirect_to = request.POST.get("next")
# light security check -- make sure redirect_to isn't garbage.
if not redirect_to or " " in redirect_to or redirect_to.startswith("http"):
redirect_to = obj
return redirect(redirect_to)
def setUp(self):
self.no_of_users = 10
# Create recipients
users = []
for i in range(self.no_of_users):
u = User(username='******' % i, email='*****@*****.**' % i)
u.set_password('pwd@user')
users.append(u)
User.objects.bulk_create(users)
# Create actor
actor = User.objects.create(username='******',
email='*****@*****.**')
actor.set_password('pwd@actor')
actor.save()
self.actor = User.objects.get(username="******")
self.recipient = User.objects.get(username='******')
self.recipient_list = User.objects.filter(
username__startswith='u').order_by('id')
# Send notifications to all recipients.
notify.send(User, recipient_list=list(self.recipient_list),
actor=self.actor, verb='wrote a new blog post.')
# Send some more notifications to a specific user.
self.recipient_nf_count = 11
for i in range(10):
notify.send(User, recipient=self.recipient, actor_text='You',
verb='reached level %r' % i)
# Login this recipient
self.assertTrue(self.client.login(username="******",
password="******"))
def map_approve(request, map_pk):
if request.method == 'POST':
form = ResourceApproveForm(request.POST)
if form.is_valid():
try:
map = Map.objects.get(id=map_pk)
except Map.DoesNotExist:
return Http404("requested map does not exists")
else:
group = map.group
if request.user not in group.get_managers():
if request.user != map.owner:
return HttpResponse(
loader.render_to_string(
'401.html', RequestContext(
request, {
'error_message': _("You are not allowed to approve this map.")})), status=401)
# return HttpResponse("you are not allowed to approve this map")
map_submission_activity = MapSubmissionActivity.objects.get(map=map, group=group, iteration=map.current_iteration)
map_audit_activity = MapAuditActivity(map_submission_activity=map_submission_activity)
comment_body = request.POST.get('comment')
comment_subject = request.POST.get('comment_subject')
map.status = 'ACTIVE'
map.last_auditor = request.user
map.save()
permissions = _perms_info_json(map)
perm_dict = json.loads(permissions)
if request.POST.get('view_permission'):
if not 'AnonymousUser' in perm_dict['users']:
perm_dict['users']['AnonymousUser'] = []
perm_dict['users']['AnonymousUser'].append('view_resourcebase')
else:
if not 'view_resourcebase' in perm_dict['users']['AnonymousUser']:
perm_dict['users']['AnonymousUser'].append('view_resourcebase')
if request.POST.get('download_permission'):
if not 'AnonymousUser' in perm_dict['users']:
perm_dict['users']['AnonymousUser'] = []
perm_dict['users']['AnonymousUser'].append('download_resourcebase')
else:
if not 'download_resourcebase' in perm_dict['users']['AnonymousUser']:
perm_dict['users']['AnonymousUser'].append('download_resourcebase')
map.set_permissions(perm_dict)
# notify map owner that someone have approved the map
if request.user != map.owner:
recipient = map.owner
notify.send(request.user, recipient=recipient, actor=request.user,
target=map, verb='approved your map')
map_submission_activity.is_audited = True
map_submission_activity.save()
map_audit_activity.comment_subject = comment_subject
map_audit_activity.comment_body = comment_body
map_audit_activity.result = 'APPROVED'
map_audit_activity.auditor = request.user
map_audit_activity.save()
messages.info(request, 'Approved map succesfully')
return HttpResponseRedirect(reverse('admin-workspace-map'))
else:
messages.info(request, 'Please write an approve comment and try again')
return HttpResponseRedirect(reverse('admin-workspace-map'))
else:
return HttpResponseRedirect(reverse('admin-workspace-map'))
