def getNotifications(request, nbNotif=10, orderBy="-timestamp"):
tampon = nbNotif * 5
if request.user.is_membre_collectif:
salons = Action.objects.filter(
Q(verb__startswith='envoi_salon')).order_by(orderBy)[:tampon]
articles = Action.objects.filter(
Q(verb__startswith='article')).order_by(orderBy)[:tampon]
else:
salons = Action.objects.filter(
Q(verb='envoi_salon')).order_by(orderBy)[:tampon]
articles = Action.objects.filter(
Q(verb='article_nouveau') | Q(verb='article_message')
| Q(verb='article_modifier')).order_by(orderBy)[:tampon]
conversations = (any_stream(request.user).filter(
Q(verb='envoi_salon_prive', )) | Action.objects.filter(
Q(verb='envoi_salon_prive',
description="a envoyé un message privé à " +
request.user.username))).order_by(orderBy)[:nbNotif]
articles = [
art for i, art in enumerate(articles)
if i == 0 or not (art.description == articles[i - 1].description
and art.actor == articles[i - 1].actor)
][:nbNotif]
salons = [
art for i, art in enumerate(salons)
if i == 0 or not (art.description == salons[i - 1].description
and art.actor == salons[i - 1].actor)
][:nbNotif]
inscription = Action.objects.filter(Q(verb__startswith='inscript'))
return salons, articles, conversations, inscription
def get_context_data(self, *args, **kwargs):
context = super(WorkflowDetailView, self).get_context_data(**kwargs)
# stats
self.object.n_tasks = self.object.tasks.count()
self.object.n_done = self.object.tasks.closed().count()
self.object.pct_done = self.object.n_done / (self.object.n_tasks
or 1) * 100.0
context['form'] = self.form
tasks = self.form.filter_queryset(self.object.tasks) \
.select_related('document__language', 'document__language__language')\
.defer('document__document_xml', 'document__search_text', 'document__search_vector')\
.all()
context['tasks'] = tasks
context['has_tasks'] = self.object.n_tasks > 0
context['task_groups'] = Task.task_columns(
['open', 'pending_review', 'assigned'], tasks)
context['possible_tasks'] = self.place.tasks\
.unclosed()\
.exclude(workflows=self.object) \
.select_related('document__language', 'document__language__language') \
.defer('document__document_xml', 'document__search_text', 'document__search_vector')\
.all()
Task.decorate_potential_assignees(tasks, self.country)
context[
'may_close'] = not self.object.closed and self.object.n_tasks == self.object.n_done
context['may_reopen'] = self.object.closed
stream = any_stream(self.object)
context['activity_stream'] = self.coalesce_entries(stream)
return context
def index(request):
if request.user.is_authenticated:
movie_view = {}
celeb_view = {}
event_view = {}
stream = any_stream(request.user)
for str1 in stream:
if str1.verb == "movie_view":
title = MovieData.objects.get(pk=str1.target_object_id).title
movie_view[title] = str1.timestamp
elif str1.verb == "event_view":
title = Event.objects.get(pk=str1.target_object_id).title
event_view[title] = str1.timestamp
elif str1.verb == "celeb_view":
title = Celebs.objects.get(pk=str1.target_object_id).name
celeb_view[title] = str1.timestamp
return render(request, 'watchlist/index.html', {'movie_view':movie_view, 'event_view':event_view, 'celeb_view':celeb_view})
else:
return render(request, 'watchlist/index.html')
def _get_test_object_event(self):
test_object = getattr(self, self._test_event_object_name)
if test_object:
return any_stream(obj=test_object).first()
else:
return Action.objects.first()
def getNotificationsParDate(request, limiter=True, orderBy="-timestamp"):
if request.user.is_membre_collectif:
actions = any_stream(request.user).filter(Q(verb='envoi_salon_prive'))|Action.objects.filter( \
Q(verb='envoi_salon')| Q(verb='envoi_salon_pacteacvi')|
Q(verb__startswith='article')|
Q(verb='envoi_salon_prive', description="a envoyé un message privé à " + request.user.username)|
Q(verb__startswith='inscript') \
).order_by(orderBy)
else:
actions = Action.objects.filter(
Q(verb='envoi_salon') | Q(verb='article_nouveau')
| Q(verb='article_message') | Q(verb='article_modifier')
| Q(verb='envoi_salon_prive',
description="a envoyé un message privé à " +
request.user.username)
| Q(verb__startswith='inscript')).order_by(orderBy)
if limiter:
actions = actions[:100]
actions = [
art for i, art in enumerate(actions)
if i == 0 or not (art.description == actions[i - 1].description
and art.actor == actions[i - 1].actor)
][:50]
return actions
def get_queryset(self):
obj = self.get_object()
AccessControlList.objects.check_access(
obj=obj,
permissions=(permission_events_view, ),
user=self.request.user)
return any_stream(obj=obj)
def get_queryset(self):
obj = self.get_object()
AccessControlList.objects.check_access(
permissions=permission_events_view, user=self.request.user,
obj=obj
)
return any_stream(obj)
def get(self, request, *args, **kwargs):
lead_id = kwargs.get('lead_id')
lead = Lead.objects.get(uid=lead_id)
lead_data, errors = LeadSchema().dump(lead)
feed = [get_json_feed(item) for item in any_stream(lead)]
return Response(data={
'lead': lead_data,
'feed': feed
},
status=status.HTTP_200_OK)
def products(request):
act = JSONActivity()
try:
product_id = request.GET["product_id"]
product = Product.objects.get(id=product_id)
except:
return HttpResponse("Product with id does not exist!", status=400)
actions = any_stream(product)
resp = act.serialize(actions)
return JsonResponse(resp, safe=False)
def _get_test_object_events(self, object_name=None):
test_object = getattr(self, object_name
or self._test_event_object_name)
if test_object:
queryset = any_stream(obj=test_object)
else:
queryset = Action.objects.all()
return queryset.order_by('timestamp')
def _test_delete_comment(self):
"""
Rule: only owner or staff users can delete a comment. Not even coauthors
"""
response_user_A = self.client_user_A.post(
'/api/comment/', {
'story': self.story_A.pk,
'contents': json.dumps(
{'content': 'This is a very nice comment.'})
})
self.assertEqual(response_user_A.status_code, 201)
com = Comment.objects.get(pk=response_user_A.json()['pk'])
# get the number of comments
response_user_A = self.client_user_A.get('/api/comment/')
self.assertEqual(response_user_A.status_code, 200)
count = response_user_A.json()['count']
# try with an anonymoususer
response_anonymous = self.client_anonymous.delete('/api/comment/%s/' %
com.short_url)
self.assertEqual(response_anonymous.status_code, 403)
# try with another user
response_user_B = self.client_user_B.delete('/api/comment/%s/' %
com.short_url)
self.assertEqual(response_user_B.status_code, 404)
# try with the coauthor! Nothing to do either...
response_user_C = self.client_user_C.delete('/api/comment/%s/' %
com.short_url)
self.assertEqual(response_user_C.status_code, 404)
com.refresh_from_db()
self.assertEqual(com.version, com.story.version)
self.assertEqual(com.status, Comment.PRIVATE) # the default is private
# let the user delete its own comments:
response_user_A = self.client_user_A.delete('/api/comment/%s/' %
com.short_url)
self.assertEqual(response_user_A.status_code, 204) #no content
com.refresh_from_db()
self.assertEqual(com.status, Comment.DELETED)
# get the number of comments
response_user_A = self.client_user_A.get('/api/comment/')
self.assertEqual(response_user_A.status_code, 200)
self.assertEqual(response_user_A.json()['count'], count - 1)
# get the latest action!!
action = any_stream(self.user_A).first()
self.assertEqual(action.verb, 'uncommented')
def get_queryset(self):
object = self.get_object()
try:
Permission.check_permissions(
self.request.user, permissions=(permission_events_view, ))
except PermissionDenied:
AccessControlList.objects.check_access(permission_events_view,
self.request.user, object)
return any_stream(object)
def getInfosJourPrecedent(request, nombreDeJours):
from datetime import datetime, timedelta
timestamp_from = datetime.now().date() - timedelta(days=nombreDeJours)
timestamp_to = datetime.now().date() - timedelta(days=nombreDeJours - 1)
if request.user.is_membre_collectif:
articles = Action.objects.filter(
Q(
verb='article_nouveau_permacat',
timestamp__gte=timestamp_from,
timestamp__lte=timestamp_to,
) | Q(
verb='article_nouveau',
timestamp__gte=timestamp_from,
timestamp__lte=timestamp_to,
))
else:
articles = Action.objects.filter(
Q(
verb='article_nouveau',
timestamp__gte=timestamp_from,
timestamp__lte=timestamp_to,
) | Q(
verb='article_modifier',
timestamp__gte=timestamp_from,
timestamp__lte=timestamp_to,
))
conversations = (any_stream(request.user).filter(
Q(verb='envoi_salon_prive', )) | Action.objects.filter(
Q(verb='envoi_salon_prive',
description="a envoyé un message privé à " +
request.user.username)))
articles = [
art for i, art in enumerate(articles)
if i == 0 or not (art.description == articles[i - 1].description
and art.actor == articles[i - 1].actor)
]
conversations = [
art for i, art in enumerate(conversations)
if i == 0 or not (art.description == conversations[i - 1].description
and art.actor == conversations[i - 1].actor)
]
return articles, conversations
def getNotifications(request):
if request.user.is_permacat:
salons = Action.objects.filter(Q(verb='envoi_salon') | Q(verb='envoi_salon_permacat'))[:30]
articles = Action.objects.filter(Q(verb='article_nouveau_permacat') | Q(verb='article_message_permacat')|Q(verb='article_nouveau') | Q(verb='article_message')| Q(verb='article_modifier')| Q(verb='article_modifier_permacat'))[:30]
projets = Action.objects.filter(Q(verb='projet_nouveau_permacat') | Q(verb='projet_message_permacat')|Q(verb='projet_nouveau') | Q(verb='projet_message')| Q(verb='projet_modifier')| Q(verb='projet_modifier_permacat'))[:30]
offres = Action.objects.filter(Q(verb='ajout_offre') | Q(verb='ajout_offre_permacat'))[:30]
else:
salons = Action.objects.filter(Q(verb='envoi_salon') | Q(verb='envoi_salon_permacat'))[:30]
articles = Action.objects.filter(Q(verb='article_nouveau') | Q(verb='article_message')| Q(verb='article_modifier'))[:30]
projets = Action.objects.filter(Q(verb='projet_nouveau') | Q(verb='projet_message')| Q(verb='projet_modifier'))[:30]
offres = Action.objects.filter(Q(verb='ajout_offre'))[:30]
conversations = (any_stream(request.user).filter(Q(verb='envoi_salon_prive',)) | Action.objects.filter(Q(verb='envoi_salon_prive', description="a envoyé un message privé à " + request.user.username) ))[:8]
articles = [art for i, art in enumerate(articles) if i == 0 or not (art.description == articles[i-1].description and art.actor == articles[i-1].actor)][:8]
projets = [art for i, art in enumerate(projets) if i == 0 or not (art.description == projets[i-1].description and art.actor == projets[i-1].actor ) ][:8]
salons = [art for i, art in enumerate(salons) if i == 0 or not (art.description == salons[i-1].description and art.actor == salons[i-1].actor ) ][:8]
return salons, articles, projets, offres, conversations
def get_context_data(self, *args, **kwargs):
context = super(WorkflowDetailView, self).get_context_data(**kwargs)
# stats
self.object.n_tasks = self.object.tasks.count()
self.object.n_done = self.object.tasks.closed().count()
self.object.pct_done = self.object.n_done / (self.object.n_tasks
or 1) * 100.0
context['form'] = self.form
tasks = self.form.filter_queryset(Task.objects.filter(workflows=self.object)) \
.select_related('document__language', 'document__language__language')\
.defer('document__document_xml')\
.all()
context['tasks'] = tasks
context['has_tasks'] = self.object.n_tasks > 0
context['task_groups'] = Task.task_columns(
['open', 'pending_review', 'assigned'], tasks)
context['possible_tasks'] = Task.objects.filter(country=self.country, locality=self.locality)\
.unclosed()\
.exclude(workflows=self.object) \
.select_related('document__language', 'document__language__language') \
.defer('document__document_xml')\
.all()
# warn when submitting task on behalf of another user
Task.decorate_submission_message(tasks, self)
Task.decorate_potential_assignees(tasks, self.country)
Task.decorate_permissions(tasks, self)
context[
'may_close'] = not self.object.closed and self.object.n_tasks == self.object.n_done
context['may_reopen'] = self.object.closed
stream = any_stream(self.object)
context['activity_stream'] = self.coalesce_entries(stream)
return context
def get_context_data(self, *args, **kwargs):
context = super(WorkflowDetailView, self).get_context_data(**kwargs)
tasks = self.object.tasks.all()
context['has_tasks'] = bool(tasks)
context['task_groups'] = Task.task_columns(
['open', 'pending_review', 'assigned'], tasks)
context['possible_tasks'] = self.place.tasks.unclosed().exclude(
pk__in=[t.id for t in self.object.tasks.all()]).all()
# stats
self.object.n_tasks = self.object.tasks.count()
self.object.n_done = self.object.tasks.closed().count()
self.object.pct_done = self.object.n_done / (self.object.n_tasks
or 1) * 100.0
context[
'may_close'] = not self.object.closed and self.object.n_tasks == self.object.n_done
context['may_reopen'] = self.object.closed
stream = any_stream(self.object)
context['activity_stream'] = self.coalesce_entries(stream)
return context
def get_queryset(self):
return any_stream(self.content_object)
def get(self, request):
return render(request, 'core/feed.html', { 'stream' : any_stream(request.user) })
def get_queryset(self):
return any_stream(self.content_object)
def events_list(request,
app_label=None,
module_name=None,
object_id=None,
verb=None):
extra_columns = []
context = {
'extra_columns': extra_columns,
'hide_object': True,
}
if app_label and module_name and object_id:
model = get_model(app_label, module_name)
if not model:
raise Http404
content_object = get_object_or_404(model, pk=object_id)
try:
Permission.objects.check_permissions(request.user,
[PERMISSION_EVENTS_VIEW])
except PermissionDenied:
AccessEntry.objects.check_access(PERMISSION_EVENTS_VIEW,
request.user, content_object)
context.update({
'object_list': any_stream(content_object),
'title': _('Events for: %s') % content_object,
'object': content_object
})
elif verb:
pre_object_list = Action.objects.filter(verb=verb)
try:
Permission.objects.check_permissions(request.user,
[PERMISSION_EVENTS_VIEW])
except PermissionDenied:
# If user doesn't have global permission, get a list of document
# for which he/she does hace access use it to filter the
# provided object_list
object_list = AccessEntry.objects.filter_objects_by_access(
PERMISSION_EVENTS_VIEW,
request.user,
pre_object_list,
related='content_object')
else:
object_list = pre_object_list
context.update({
'title': _('Events of type: %s') % Event.get_label(verb),
'object_list': object_list
})
else:
pre_object_list = Action.objects.all()
try:
Permission.objects.check_permissions(request.user,
[PERMISSION_EVENTS_VIEW])
except PermissionDenied:
# If user doesn't have global permission, get a list of document
# for which he/she does hace access use it to filter the
# provided object_list
object_list = AccessEntry.objects.filter_objects_by_access(
PERMISSION_EVENTS_VIEW,
request.user,
pre_object_list,
related='content_object')
else:
object_list = pre_object_list
context.update({'title': _('Events'), 'object_list': object_list})
if not (app_label and module_name and object_id):
extra_columns.append({
'name':
_('Target'),
'attribute':
encapsulate(lambda entry: event_object_link(entry))
})
return render_to_response('main/generic_list.html',
context,
context_instance=RequestContext(request))
def get_object_list(self):
return any_stream(self.content_object)
def get_object_list(self):
return any_stream(self.content_object)
def include_activity_stream(request):
if request.user.is_authenticated():
activity_stream = any_stream(request.user)
return {'activitystream': activity_stream }
else: return {}
def get_source_queryset(self):
return any_stream(obj=self.object)
def events_list(request, app_label=None, module_name=None, object_id=None, verb=None):
extra_columns = []
context = {
'extra_columns': extra_columns,
'hide_object': True,
}
if app_label and module_name and object_id:
model = get_model(app_label, module_name)
if not model:
raise Http404
content_object = get_object_or_404(model, pk=object_id)
try:
Permission.objects.check_permissions(request.user, [PERMISSION_EVENTS_VIEW])
except PermissionDenied:
AccessEntry.objects.check_access(PERMISSION_EVENTS_VIEW, request.user, content_object)
context.update({
'object_list': any_stream(content_object),
'title': _('Events for: %s') % content_object,
'object': content_object
})
elif verb:
pre_object_list = Action.objects.filter(verb=verb)
try:
Permission.objects.check_permissions(request.user, [PERMISSION_EVENTS_VIEW])
except PermissionDenied:
# If user doesn't have global permission, get a list of document
# for which he/she does hace access use it to filter the
# provided object_list
object_list = AccessEntry.objects.filter_objects_by_access(PERMISSION_EVENTS_VIEW, request.user, pre_object_list, related='content_object')
else:
object_list = pre_object_list
context.update({
'title': _('Events of type: %s') % Event.get_label(verb),
'object_list': object_list
})
else:
pre_object_list = Action.objects.all()
try:
Permission.objects.check_permissions(request.user, [PERMISSION_EVENTS_VIEW])
except PermissionDenied:
# If user doesn't have global permission, get a list of document
# for which he/she does hace access use it to filter the
# provided object_list
object_list = AccessEntry.objects.filter_objects_by_access(PERMISSION_EVENTS_VIEW, request.user, pre_object_list, related='content_object')
else:
object_list = pre_object_list
context.update({
'title': _('Events'),
'object_list': object_list
})
if not (app_label and module_name and object_id):
extra_columns.append(
{
'name': _('Target'),
'attribute': encapsulate(lambda entry: event_object_link(entry))
}
)
return render_to_response('main/generic_list.html', context,
context_instance=RequestContext(request))
