def testGetDocumentOr404(self):
Doc(name=DOC_NAME, text=SAMPLE_TEXT).save()
self.assertTrue(
get_document_or_404(Doc, name=DOC_NAME).name == DOC_NAME)
with self.assertRaisesMessage(Http404,
'No Document matches the given query.'):
get_document_or_404(Doc, name='not_exisitng')
def delete_message(request, group, message_id):
get_document_or_404(GroupMessage, id=message_id).delete()
if request.is_ajax():
objects = paginate(request,
GroupMessage.objects(group=group),
GroupMessage.objects(group=group).count(),
settings.MESSAGES_ON_PAGE)
return direct_to_template(request, 'groups/_comments.html', dict(
group=group,
is_admin=group.is_admin(request.user) or request.user.is_superuser,
objects=objects,
))
else:
return redirect(reverse('groups:group_view', args=[group.id]))
def get_object(self):
"""
*** Inherited from DRF 3 GenericAPIView, swapped get_object_or_404() with get_document_or_404() ***
Returns the object the view is displaying.
You may want to override this if you need to provide non-standard
queryset lookups. Eg if objects are referenced using multiple
keyword arguments in the url conf.
"""
queryset = self.filter_queryset(self.get_queryset())
# Perform the lookup filtering.
lookup_url_kwarg = self.lookup_url_kwarg or self.lookup_field
assert lookup_url_kwarg in self.kwargs, (
'Expected view %s to be called with a URL keyword argument '
'named "%s". Fix your URL conf, or set the `.lookup_field` '
'attribute on the view correctly.' %
(self.__class__.__name__, lookup_url_kwarg)
)
filter_kwargs = {self.lookup_field: self.kwargs[lookup_url_kwarg]}
obj = get_document_or_404(queryset, **filter_kwargs)
# May raise a permission denied
self.check_object_permissions(self.request, obj)
return obj
def group_view(request, id):
group = get_document_or_404(Group, id=id)
is_active = group.is_active(request.user)
is_ajax = request.is_ajax()
if request.POST:
if not is_active:
if is_ajax:
return HttpResponse('')
else:
messages.add_message(request, messages.ERROR,
_('To send a message, you need to join the group.'))
return redirect(reverse('groups:group_view', args=[id]))
form = MessageTextForm(request.POST)
if form.is_valid():
message = GroupMessage(
group=group,
sender=request.user,
text=form.cleaned_data['text'],
)
message.save()
if not is_ajax:
return redirect(reverse('groups:group_view', args=[id]))
elif is_ajax:
return HttpResponse('')
elif not is_ajax:
form = MessageTextForm()
objects = paginate(request,
GroupMessage.objects(group=group),
GroupMessage.objects(group=group).count(),
settings.MESSAGES_ON_PAGE)
if is_ajax:
return direct_to_template(request, 'groups/_comments.html', dict(
group=group,
is_admin=group.is_admin(request.user) or request.user.is_superuser,
objects=objects,
))
else:
admins = []
members = []
for info in GroupUser.objects(group=group, status=GroupUser.STATUS.ACTIVE):
if info.is_admin:
admins.append(info.user)
else:
members.append(info.user)
return direct_to_template(request, 'groups/view.html', dict(
group=group,
admins=admins,
members=members,
is_admin=group.is_admin(request.user) or request.user.is_superuser,
can_view_private=group.public or is_active or request.user.is_superuser,
can_view_conference=is_active or request.user.is_superuser,
can_send_message=is_active,
is_status_request=group.is_request(request.user),
objects=objects,
form=form,
))
def render_dashboard(request, title):
if (not request.user.is_authenticated()):
return login_user(request)
dash = Dashboard.objects.filter(title=title)
if len(dash) == 0:
return redirect(settings.BASE_URL + "/list/")
dashPerms = Dashboard_Permission.objects.filter(dashboard_title=title,
user=request.user.username)
if len(dashPerms) == 0:
return redirect(settings.BASE_URL + "/list/")
template = loader.get_template('dashboard.html')
dashboard = get_document_or_404(Dashboard, pk=title)
topic_names = TopicWindowFunctions.get_topic_windows(dashboard.title)
user_permissions_list = Dashboard_Permission.objects.filter(
dashboard_title=dashboard.title)
list_of_usernames = []
for user_obj in user_permissions_list:
list_of_usernames.append(user_obj.user)
matched_usernames = check_for_active_users(list_of_usernames)
print("connected users: " + str(matched_usernames))
context = RequestContext(
request, {
'dashboard': dashboard,
'topic_names': topic_names,
'connected_users': matched_usernames,
})
return HttpResponse(template.render(context))
def send_invite(request, group, user_id):
user = get_document_or_404(User, id=user_id)
group.add_member(user, status=GroupUser.STATUS.INVITE)
if request.is_ajax():
return HttpResponse('OK')
else:
return redirect(reverse('groups:send_friends_invite', args=[group.id]))
def group_edit(request, id=None):
if id:
group = get_document_or_404(Group, id=id)
is_admin = group.is_admin(request.user) or request.user.is_superuser
if not is_admin:
messages.add_message(request, messages.ERROR,
_('You are not allowed.'))
return redirect(reverse('groups:group_view', args=[id]))
initial = group._data
else:
initial = Group()._data
form = GroupCreationForm(request.POST or None, initial=initial)
if form.is_valid():
if not id:
group = Group()
for k, v in form.cleaned_data.items():
if v or getattr(group, k):
setattr(group, k, v)
group.save()
if not id:
group.add_member(request.user, is_admin=True)
return redirect(reverse('groups:group_view', args=[group.id]))
return direct_to_template(
request, 'groups/group_edit.html',
dict(form=form,
is_new=id is None,
is_public=group.public if id else True,
group=id and group))
def send_invite(request, group, user_id):
user = get_document_or_404(User, id=user_id)
group.add_member(user, status=GroupUser.STATUS.INVITE)
if request.is_ajax():
return HttpResponse('OK')
else:
return redirect(reverse('groups:send_friends_invite', args=[group.id]))
def get_object(self):
"""
*** Inherited from DRF 3 GenericAPIView, swapped get_object_or_404() with get_document_or_404() ***
Returns the object the view is displaying.
You may want to override this if you need to provide non-standard
queryset lookups. Eg if objects are referenced using multiple
keyword arguments in the url conf.
"""
queryset = self.filter_queryset(self.get_queryset())
# Perform the lookup filtering.
lookup_url_kwarg = self.lookup_url_kwarg or self.lookup_field
assert lookup_url_kwarg in self.kwargs, (
'Expected view %s to be called with a URL keyword argument '
'named "%s". Fix your URL conf, or set the `.lookup_field` '
'attribute on the view correctly.' %
(self.__class__.__name__, lookup_url_kwarg))
filter_kwargs = {self.lookup_field: self.kwargs[lookup_url_kwarg]}
obj = get_document_or_404(queryset, **filter_kwargs)
# May raise a permission denied
self.check_object_permissions(self.request, obj)
return obj
def folder_add(request, library, id=None):
tree = get_library(library)
if id:
folder = get_document_or_404(Folder, id=id)
parent = tree.get(folder.id)
if not parent:
raise Http404()
current_folder = parent
else:
current_folder = None
if request.POST:
form = FolderEditForm(request.POST)
if form.is_valid():
folder = Folder(name=form.cleaned_data['name'])
folder.save()
if id:
tree.add(folder, parent)
else:
tree.add(folder)
tree.save()
messages.add_message(request, messages.SUCCESS, _('Folder successfully added'))
return redirect_by_id('media_library:%s_index' % library, id)
else:
form = FolderEditForm()
return direct_to_template(request,
'media_library/folder_edit.html',
dict( breadcrumb='media_library/_%s_breadcrumb.html' % library,
form=form,
current_folder=current_folder ) )
def get_access_to_camera(request, id, is_controlled):
camera = get_document_or_404(Camera, id=id)
if request.POST:
form = AccessCamOrderForm(camera, is_controlled, request.user, request.POST)
if form.is_valid():
tariff = form.cleaned_data['tariff']
try:
if tariff.is_packet:
AccessCamOrder.create_packet_type(
tariff=tariff,
count_packets=form.cleaned_data['count_packets'],
user=request.user,
camera=camera,
)
else:
AccessCamOrder.create_time_type(
tariff=tariff,
user=request.user,
camera=camera,
)
except AccessCamOrder.CanNotAddOrder:
pass
return HttpResponseRedirect(reverse('social:user', args=[camera.owner.id]))
else:
form = AccessCamOrderForm(camera, is_controlled)
return direct_to_template(request, 'billing/get_access_to_camera.html', { 'form': form, 'camera': camera })
def change_view(self, request, collection, object_id=None):
cls, admin = self.verify_collection(collection)
if object_id:
document = get_document_or_404(cls, id=object_id)
form = admin.get_form(request.POST or None, instance=document)
add, change = False, True
else:
document = None
form = admin.get_form(request.POST or None)
add, change = True, False
if form.is_valid():
document = form.save()
msg = _('The %(name)s "%(obj)s" was saved successfully.') % {'name': force_unicode(admin.verbose_name), 'obj': force_unicode(document)}
if '_continue' in request.POST:
redirect_url = reverse('mongoadmin:change', args=(collection, str(document.pk)))
msg += ' ' + _('You may edit it again below.')
elif '_addanother' in request.POST:
redirect_url = reverse('mongoadmin:add', args=(collection,))
msg += ' ' + (_('You may add another %s below.') % force_unicode(admin.verbose_name))
else:
redirect_url = reverse('mongoadmin:changelist', args=(collection,))
messages.info(request, msg)
return HttpResponseRedirect(redirect_url)
return render_to_response('mongoadmin/change_form.html', {
'document': document,
'form': form,
'collection': collection,
'admin': admin,
'add': add,
'change': change,
'title': _('Change %s') % admin.verbose_name
}, context_instance=RequestContext(request))
def view(request, id):
item = get_document_or_404(Ad, id=id)
return direct_to_template(request, 'ads/view.html',
dict(
item=item,
)
)
def show_config(request, config_id):
config = get_document_or_404(Config, id=config_id)
return render_to_response('config/config.html',
{
'config':config,
'page_title': 'View Configuration: %s' % config.title,
}, context_instance=RequestContext(request))
def delete_message(request, group, message_id):
get_document_or_404(GroupMessage, id=message_id).delete()
if request.is_ajax():
objects = paginate(request, GroupMessage.objects(group=group),
GroupMessage.objects(group=group).count(),
settings.MESSAGES_ON_PAGE)
return direct_to_template(
request, 'groups/_comments.html',
dict(
group=group,
is_admin=group.is_admin(request.user)
or request.user.is_superuser,
objects=objects,
))
else:
return redirect(reverse('groups:group_view', args=[group.id]))
def category_posts(request, category_anchor):
"""
The below anchor of Category can contain: #anchor or page (domain/page).
NOTE(DATABASE): We don't interested to use Index to anchor field
because Category collection is very small the performance result is no
significant
"""
is_container = False
anchor_exists = get_document_or_404(models.Category,
anchor__contains=category_anchor.lower())
today = datetime.datetime.now()
# TODO index sort (order_by)
posts = models.Post.objects(categories=anchor_exists, published=True,
created_at__lte=today).order_by('-created_at')
try:
is_container = anchor_exists.is_container
except AttributeError:
pass
if is_container:
posts = posts.first()
return post_view(request, posts.slug)
return render_to_response('posts_by_category.html',
{'posts': posts, 'category': anchor_exists})
def wrapper():
if id:
user = get_document_or_404(User, id=id)
if not request.user.is_superuser and user.id != request.user.id:
return HttpResponseNotFound()
else:
user = request.user
context = profile_form(request, user)
if not context:
return
answer = user_form(request, user)
if not answer:
return
context.update(answer)
dating = dating_form(request, user)
if not dating:
return
context.update(dating)
camera = user.get_camera()
if camera or request.user.is_superuser:
answer = cam_form(request, user, camera)
if not answer:
return
context.update(answer)
if answer["camera"]:
answer = screen_form(request, user.get_camera())
if not answer:
return
context.update(answer)
context.update({"user": user})
return context
def get_access_to_camera(request, id, is_controlled):
camera = get_document_or_404(Camera, id=id)
if request.POST:
form = AccessCamOrderForm(camera, is_controlled, request.user,
request.POST)
if form.is_valid():
tariff = form.cleaned_data['tariff']
try:
if tariff.is_packet:
AccessCamOrder.create_packet_type(
tariff=tariff,
count_packets=form.cleaned_data['count_packets'],
user=request.user,
camera=camera,
)
else:
AccessCamOrder.create_time_type(
tariff=tariff,
user=request.user,
camera=camera,
)
except AccessCamOrder.CanNotAddOrder:
pass
return HttpResponseRedirect(
reverse('social:user', args=[camera.owner.id]))
else:
form = AccessCamOrderForm(camera, is_controlled)
return direct_to_template(request, 'billing/get_access_to_camera.html', {
'form': form,
'camera': camera
})
def get_category(self):
category_slug = self.kwargs.get('category_slug')
if category_slug:
return get_document_or_404(
Category,
slug=category_slug)
def image_delete(request, id):
library = get_library(LIBRARY_TYPE_IMAGE)
image = get_document_or_404(File, id=id)
library.remove_file(image)
messages.add_message(request, messages.SUCCESS,
_('Image successfully removed'))
return redirect('media_library:image_index')
def video_delete(request, id):
library = get_library(LIBRARY_TYPE_VIDEO)
video = get_document_or_404(File, id=id)
library.remove_file(video)
messages.add_message(request, messages.SUCCESS,
_('Video successfully removed'))
return redirect('media_library:video_index')
def edit(request, id=None):
if id:
item = get_document_or_404(AdminBlog, id=id)
initial = item._data
else:
item = None
initial = {}
form = AdminBlogForm(request.POST or None, initial=initial)
if form.is_valid():
if not item:
item = AdminBlog()
for k, v in form.cleaned_data.items():
if k.startswith("_"):
continue
if hasattr(item, k):
setattr(item, k, v)
item.author = request.user
item.save()
return redirect("admin_blog:list")
return direct_to_template(request, "admin_blog/edit.html", dict(form=form, is_new=id is None))
def tag_edit(request, id=None):
if id:
tag = get_document_or_404(CameraTag, id=id)
initial = tag._data
else:
tag = None
initial = {}
form = CameraTagForm(request.POST or None, initial=initial)
if form.is_valid():
if not tag:
tag = CameraTag()
for k, v in form.cleaned_data.items():
if k.startswith('_'):
continue
if hasattr(tag, k):
setattr(tag, k, v)
tag.save()
return HttpResponseRedirect(reverse('cam:tag_list'))
return direct_to_template(request, 'cam/tag_edit.html',
dict(form=form, is_new=id is None)
)
def password_reset_done(request):
""" Make new password to user by email
"""
if request.method == "POST":
form = forms.PasswordConfirm(request.POST, )
if form.is_valid():
new_password = form.cleaned_data["new_password2"]
email = request.session.get('email', False)
user = get_document_or_404(models.User, email=email)
user.set_password(new_password)
user.save()
auth_user = authenticate(username=user.username, password=new_password)
if auth_user is not None:
if auth_user.is_active:
login(request, auth_user)
return redirect(reverse("dashboard"))
else:
pass # account disabled
else:
return HttpResponse('Invalid login (username or password)')
else:
form = forms.PasswordConfirm()
return render(request, "password_reset_form.html", dict(form=form))
def user(request, user_id=None):
page_user = get_document_or_404(User, id=user_id)
if page_user == request.user:
return redirect("social:home")
invitee_count = Invite.invitee_count(page_user)
is_friend = not request.user.friends.can_add(page_user)
camera = page_user.get_camera()
data = {
"camera": camera,
"invitee_count": invitee_count,
"page_user": page_user,
"profile": page_user.profile.for_html(),
"settings": settings,
"show_friend_button": not is_friend,
}
if camera:
data.update(
{
"billing": camera.billing(request.user, request.session),
"show_bookmark_button": camera.can_bookmark_add(request.user),
"show_view_access_link": camera.is_view_enabled
and camera.is_view_paid
and camera.is_view_public
or is_friend,
"show_manage_access_link": camera.is_management_enabled
and camera.is_managed
and camera.is_management_paid
and (camera.is_management_public or is_friend),
}
)
return direct_to_template(request, "social/home.html", data)
def get(self, request, *args, **kwargs):
spot_slug = kwargs['spot_slug']
s = get_document_or_404(Spot, slug=spot_slug)
# take care of service-specific information
# in the future I think it should be taken care of
# in the form, not in the view. maybe override constructor
for service in s._data['services']:
if service.__class__ is ServiceFood:
s._data['service_food'] = True
s._data['food_category'] = service.category
s._data['food_delivery'] = service.delivery
s._data['food_take_out'] = service.take_out
elif service.__class__ is ServiceBar:
s._data['service_bar'] = True
s._data['bar_category'] = service.category
elif service.__class__ is ServiceCoffee:
s._data['service_coffee'] = True
s._data['coffee_board_games'] = service.board_games
elif service.__class__ is ServiceClub:
s._data['service_club'] = True
s._data['club_coat_check'] = service.coat_check
s._data['club_face_control'] = service.face_control
if s._data.get('location'):
s._data['longtitude'] = s._data['location'][0]
s._data['latitude'] = s._data['location'][1]
form = SpotForm(initial=s._data)
return render(request, self.template_name, {
'form': form,
'spot_slug': spot_slug
})
def user_picture(request, username):
path = get_document_or_404(User, username = username).picture
if not path:
path = '{0}img/user-avatar.jpg'.format(STATIC_URL)
url = 'http://{0}{1}'.format(request.META['HTTP_HOST'], path)
#return HttpResponse(urlopen(url).read(), mimetype="image/jpg")
return HttpResponseRedirect(url)
def post(self, request, *args, **kwargs):
spot = get_document_or_404(Spot, slug=kwargs['spot_slug'])
if request.POST.get('action') == 'like' and not request.user.likes_spot(spot):
if request.user.dislikes_spot(spot):
Dislike.objects(user=request.user, spot=spot).first().delete()
request.user.remove_dislike(spot)
request.user.likes.append(spot)
request.user.save()
Like(user=request.user, spot=spot).save()
return self.render_json_response({'action': 'like'})
elif request.POST.get('action') == 'dislike' and not request.user.dislikes_spot(spot):
if request.user.likes_spot(spot):
Like.objects(user=request.user, spot=spot).first().delete()
request.user.remove_like(spot)
request.user.dislikes.append(spot)
request.user.save()
Dislike(user=request.user, spot=spot).save()
return self.render_json_response({'action': 'dislike'})
elif request.POST.get('action') == 'neutral':
if request.user.likes_spot(spot):
Like.objects(user=request.user, spot=spot).first().delete()
request.user.remove_like(spot)
else:
Dislike.objects(user=request.user, spot=spot).first().delete()
request.user.remove_dislike(spot)
request.user.save()
return self.render_json_response({'action': 'neutral'})
raise Http404
def wrapper():
if id:
user = get_document_or_404(User, id=id)
if not request.user.is_superuser and user.id != request.user.id:
return HttpResponseNotFound()
else:
user = request.user
context = profile_form(request, user)
if not context:
return
if request.user.is_superuser:
answer = user_form(request, user)
if not answer:
return
context.update(answer)
camera = user.get_camera()
if camera or request.user.is_superuser:
answer = cam_form(request, user, camera)
if not answer:
return
context.update(answer)
if answer['camera']:
answer = screen_form(request, user.get_camera())
if not answer:
return
context.update(answer)
context.update({'user': user})
return context
def captcha_image(request, key):
store = get_document_or_404(CaptchaStore, hashkey=key)
text = store.challenge
if settings.CAPTCHA_FONT_PATH.lower().strip().endswith('ttf'):
font = ImageFont.truetype(settings.CAPTCHA_FONT_PATH, settings.CAPTCHA_FONT_SIZE)
else:
font = ImageFont.load(settings.CAPTCHA_FONT_PATH)
size = font.getsize(text)
size = (size[0] * 2, int(size[1] * 1.2))
image = Image.new('RGB', size, settings.CAPTCHA_BACKGROUND_COLOR)
try:
PIL_VERSION = int(NON_DIGITS_RX.sub('', Image.VERSION))
except:
PIL_VERSION = 116
xpos = 2
charlist = []
for char in text:
if char in settings.CAPTCHA_PUNCTUATION and len(charlist) >= 1:
charlist[-1] += char
else:
charlist.append(char)
for char in charlist:
fgimage = Image.new('RGB', size, settings.CAPTCHA_FOREGROUND_COLOR)
charimage = Image.new('L', font.getsize(' %s ' % char), '#000000')
chardraw = ImageDraw.Draw(charimage)
chardraw.text((0, 0), ' %s ' % char, font=font, fill='#ffffff')
if settings.CAPTCHA_LETTER_ROTATION:
if PIL_VERSION >= 116:
charimage = charimage.rotate(random.randrange(*settings.CAPTCHA_LETTER_ROTATION), expand=0, resample=Image.BICUBIC)
else:
charimage = charimage.rotate(random.randrange(*settings.CAPTCHA_LETTER_ROTATION), resample=Image.BICUBIC)
charimage = charimage.crop(charimage.getbbox())
maskimage = Image.new('L', size)
maskimage.paste(charimage, (xpos, 4, xpos + charimage.size[0], 4 + charimage.size[1]))
size = maskimage.size
image = Image.composite(fgimage, image, maskimage)
xpos = xpos + 2 + charimage.size[0]
image = image.crop((0, 0, xpos + 1, size[1]))
draw = ImageDraw.Draw(image)
for f in settings.noise_functions():
draw = f(draw, image)
for f in settings.filter_functions():
image = f(image)
out = StringIO()
image.save(out, "PNG")
out.seek(0)
response = HttpResponse(content_type='image/png')
response.write(out.read())
response['Content-length'] = out.tell()
return response
def ombudsman_picture(request, slug):
path = get_document_or_404(OmbudsmanOffice, slug = slug).picture
if not path:
path = '{0}img/ombudsman-avatar.jpg'.format(STATIC_URL)
url = 'http://{0}{1}'.format(request.META['HTTP_HOST'], path)
#return HttpResponse(urlopen(url).read(), mimetype="image/jpg")
return HttpResponseRedirect(url)
def note_edit(request, note_id=None):
fields = ('title', 'text', 'is_public')
if note_id:
note = get_document_or_404(Note, id=note_id, author=request.user)
initial = {}
for field in fields:
initial[field] = getattr(note, field)
else:
note = None
initial = {}
form = NoteForm(request.POST or None, initial=initial)
if form.is_valid():
note = note or Note(author=request.user)
for field in fields:
setattr(note, field, form.cleaned_data[field])
note.save()
return HttpResponseRedirect(reverse('notes:note_list'))
return direct_to_template(request, 'notes/note_edit.html',
{ 'form': form, 'create': not note })
def change_view(self, request, collection, object_id=None):
cls, admin = self.verify_collection(collection)
if object_id:
document = get_document_or_404(cls, id=object_id)
form = admin.get_form(request.POST or None, instance=document)
add, change = False, True
else:
document = None
form = admin.get_form(request.POST or None)
add, change = True, False
if form.is_valid():
document = form.save()
msg = _('The %(name)s "%(obj)s" was saved successfully.') % {'name': force_unicode(admin.verbose_name), 'obj': force_unicode(document)}
if '_continue' in request.POST:
redirect_url = reverse('mongoadmin:change', args=(collection, str(document.pk)))
msg += ' ' + _('You may edit it again below.')
elif '_addanother' in request.POST:
redirect_url = reverse('mongoadmin:add', args=(collection,))
msg += ' ' + (_('You may add another %s below.') % force_unicode(admin.verbose_name))
else:
redirect_url = reverse('mongoadmin:changelist', args=(collection,))
messages.info(request, msg)
return HttpResponseRedirect(redirect_url)
return render_to_response('mongoadmin/change_form.html', {
'document': document,
'form': form,
'collection': collection,
'admin': admin,
'add': add,
'change': change,
'title': _('Change %s') % admin.verbose_name
}, context_instance=RequestContext(request))
def get_forum(self, *args, **kwargs):
id = self.kwargs.get('id')
object = get_document_or_404(
Forum,
id=int(id),
)
return object
def render_dashboard(request, title):
if (not request.user.is_authenticated()):
return login_user(request)
dash = Dashboard.objects.filter(title=title)
if len(dash) == 0:
return redirect(settings.BASE_URL + "/list/")
dashPerms = Dashboard_Permission.objects.filter(dashboard_title=title, user=request.user.username)
if len(dashPerms)==0:
return redirect(settings.BASE_URL + "/list/")
template = loader.get_template('dashboard.html')
dashboard = get_document_or_404(Dashboard, pk=title)
topic_names = TopicWindowFunctions.get_topic_windows(dashboard.title)
user_permissions_list = Dashboard_Permission.objects.filter(dashboard_title=dashboard.title)
list_of_usernames = []
for user_obj in user_permissions_list:
list_of_usernames.append(user_obj.user)
matched_usernames = check_for_active_users(list_of_usernames)
print("connected users: " + str(matched_usernames))
context = RequestContext(request, {
'dashboard': dashboard,
'topic_names': topic_names,
'connected_users': matched_usernames,
})
return HttpResponse(template.render(context))
def show_device(request, device_id=None):
device = get_document_or_404(Device, device_id=device_id)
return render_to_response('device/device.html',
{
'device':device,
'page_title': 'View Device: %s' % device.device_id,
}, context_instance=RequestContext(request))
def folder_edit(request, library, id):
tree = get_library(library)
folder = get_document_or_404(Folder, id=id)
current_folder = tree.get(folder.id)
if not current_folder:
raise Http404()
if request.POST:
form = FolderEditForm(request.POST, initial=folder._data)
if form.is_valid():
tree.rename(folder, form.cleaned_data['name'])
current_folder.name = folder.name
tree.save()
messages.add_message(request, messages.SUCCESS, _('Folder successfully saved'))
return redirect_by_id('media_library:%s_index' % library, id)
else:
form = FolderEditForm(initial=folder._data)
return direct_to_template(request,
'media_library/folder_edit.html',
dict( breadcrumb='media_library/_%s_breadcrumb.html' % library,
form=form,
current_folder=current_folder,
is_edit=True ) )
def view_message_by_user(request, user_id, action=''):
by_user = get_document_or_404(User, id=user_id)
owner = request.user
template = 'by_user.html'
if action == 'sent':
messages = Message.objects(sender=owner,
recipient=by_user,
sender_delete=None)
template = 'by_user_sent.html'
elif action == 'inbox':
messages = Message.objects(recipient=request.user,
sender=by_user,
recipient_delete=None)
template = 'by_user_inbox.html'
else:
messages = Message.objects(
Q(sender=owner, recipient=by_user, sender_delete=None) |
Q(sender=by_user, recipient=owner, recipient_delete=None),
)
objects = paginate(request,
messages,
messages.count(),
10)
return direct_to_template(request, 'user_messages/%s' % template,
{ 'objects': objects,
'by_user': by_user,
'action': action,
})
def type_edit(request, id=None):
if id:
type = get_document_or_404(CameraType, id=id)
initial = type._data
else:
type = None
initial = {}
form = CameraTypeForm(request.POST or None, initial=initial)
if form.is_valid():
if not type:
type = CameraType()
for k, v in form.cleaned_data.items():
if k.startswith('_'):
continue
if hasattr(type, k):
setattr(type, k, v)
type.save()
#return HttpResponseRedirect(reverse('cam:type_edit', kwargs=dict(id=type.id)))
return HttpResponseRedirect(reverse('cam:type_list'))
return direct_to_template(request, 'cam/type_edit.html',
dict(form=form, is_new=id is None)
)
def group_edit(request, id=None):
if id:
group = get_document_or_404(Group, id=id)
is_admin = group.is_admin(request.user) or request.user.is_superuser
if not is_admin:
messages.add_message(request, messages.ERROR, _('You are not allowed.'))
return redirect(reverse('groups:group_view', args=[id]))
initial = group._data
else:
initial = Group()._data
form = GroupCreationForm(request.POST or None, initial=initial)
if form.is_valid():
if not id:
group = Group()
for k, v in form.cleaned_data.items():
if v or getattr(group, k):
setattr(group, k, v)
group.save()
if not id:
group.add_member(request.user, is_admin=True)
return redirect(reverse('groups:group_view', args=[group.id]))
return direct_to_template(request, 'groups/group_edit.html', dict(form=form,
is_new=id is None,
is_public=group.public if id else True,
group=id and group))
def edit(request, id=None):
if id:
item = get_document_or_404(AdminBlog, id=id)
initial = item._data
else:
item = None
initial = {}
form = AdminBlogForm(request.POST or None, initial=initial)
if form.is_valid():
if not item:
item = AdminBlog()
for k, v in form.cleaned_data.items():
if k.startswith('_'):
continue
if hasattr(item, k):
setattr(item, k, v)
item.author = request.user
item.save()
return redirect('admin_blog:list')
return direct_to_template(request, 'admin_blog/edit.html',
dict(
form=form,
is_new=id is None
)
)
def user(request, user_id=None):
page_user = get_document_or_404(User, id=user_id)
if page_user == request.user:
return redirect('social:home')
invitee_count = Invite.invitee_count(page_user)
is_friend = not request.user.friends.can_add(page_user)
camera = page_user.get_camera()
data = {
'camera': camera,
'invitee_count': invitee_count,
'page_user': page_user,
'profile': page_user.profile.for_html(),
'settings': settings,
'show_friend_button': not is_friend,
}
if camera:
data.update({
'billing':
camera.billing(request.user, request.session),
'show_bookmark_button':
camera.can_bookmark_add(request.user),
'show_view_access_link':
camera.is_view_enabled and camera.is_view_paid
and camera.is_view_public or is_friend,
'show_manage_access_link':
camera.is_management_enabled and camera.is_managed
and camera.is_management_paid
and (camera.is_management_public or is_friend),
})
return direct_to_template(request, 'social/home.html', data)
def create_group(request, domainid):
class TeacherGroupCreationForm(DocumentForm):
class Meta:
document = Group
fields = ['code', 'abbr', 'title', 'description']
domain = get_document_or_404(Domain,
owner=request.user.pkstr,
pk=domainid)
if request.method == "POST":
form = TeacherGroupCreationForm(request.POST)
if form.is_valid():
group = form.save(commit=False)
group.domain = 'tea'
group.source = 'man'
group.owner = request.user.pkstr
group.save()
groupstudents = GroupStudents(gp=group, owner=request.user.pkstr,
datestart=domain.datestart,
dateend=domain.dateend)
groupstudents.save()
domain.groups.append(groupstudents)
domain.save()
return HttpResponseRedirect(
reverse(edit_group, kwargs={'domainid': domainid,
'groupid': groupstudents.pkstr}))
else:
form = TeacherGroupCreationForm()
return render(request, "group/teacher/create_group.html",
{'form': form, 'domain': domain})
def note_edit(request, note_id=None):
fields = ('title', 'text', 'is_public')
if note_id:
note = get_document_or_404(Note, id=note_id, author=request.user)
initial = {}
for field in fields:
initial[field] = getattr(note, field)
else:
note = None
initial = {}
form = NoteForm(request.POST or None, initial=initial)
if form.is_valid():
note = note or Note(author=request.user)
for field in fields:
setattr(note, field, form.cleaned_data[field])
note.save()
return HttpResponseRedirect(reverse('notes:note_list'))
return direct_to_template(request, 'notes/note_edit.html', {
'form': form,
'create': not note
})
def cam_manage(request, id, command):
if command not in AVAILABLE_COMMANDS:
return HttpResponseNotFound()
cam = get_document_or_404(Camera, id=id)
cam = Camera()
return HttpResponse()
def get_request_url(method, version, appkey):
#get method
method = get_document_or_404(Method, name=method)
#get appkey
appkey = get_document_or_404(Appkey, name=appkey)
if method.url.has_key(version):
uri = method.url[version]
else:
raise Exception('no url found')
#get server's ip and host
server = method.server
# combine ip port uri
return "http://%s:%s/%s"%(server.ip, server.port, uri)
def view_message(request, message_id):
message = get_document_or_404(Message, id=message_id)
user = request.user
_message_acl_check(message, user)
if message.recipient.id == request.user.id and not message.is_read:
message.set_readed()
return direct_to_template(request, 'user_messages/message.html',
{'msg': message})
def _edit_photo(self, pk):
album = self.get_album()
photo = get_document_or_404(album.photos, pk=pk)
photo.comment = self.request.POST.get('comment')
try:
photo.save()
except ValidationError, e:
return {'error': "Comentário inválido"}
def remove_member(request, group, user_id):
user = get_document_or_404(User, id=user_id)
if group.can_remove_member(user):
group.remove_member(user)
else:
messages.add_message(
request, messages.ERROR,
_('You can not leave the group. Give the administrator rights to another party.'
))
return redirect(reverse('groups:members_manage', args=[group.id]))
def shortUrl(request, id):
dataviz = get_document_or_404(DataVisualization, id=id)
if not dataviz.short_url:
mydict = {"url": get_shorturl(request, id)}
else:
mydict = {"url": "short_url"}
response = Response(mydict["url"])
return response
def group_leave(request, id):
group = get_document_or_404(Group, id=id)
if group.can_remove_member(request.user):
group.remove_member(request.user)
else:
messages.add_message(
request, messages.ERROR,
_('You can not leave the group. Give the administrator rights to another party.'
))
return redirect(reverse('groups:group_view', args=[id]))
def connect(request, socket, context, channel):
logger.info("Subscribed to channel: " + channel + " with session id: " +
str(socket.socket.session.session_id))
document = get_document_or_404(Document, id=channel[3:])
if document["text"] != None:
logger.info("Document content: " + document["text"])
message = {}
message["text"] = document["text"]
message["action"] = "doc"
socket.send(message)
def group_conference(request, id):
group = get_document_or_404(Group, id=id)
is_active = group.is_active(request.user)
if not (is_active or request.user.is_superuser):
return redirect(reverse('groups:group_view', args=[id]))
return direct_to_template(
request, 'groups/group_conference.html',
dict(
group=group,
is_admin=group.is_admin(request.user) or request.user.is_superuser,
))
def type_delete(request, id):
type = get_document_or_404(GroupType, id=id)
if Group.objects(type=type).count():
messages.add_message(request, messages.ERROR,
_('You can not delete this group type.'))
else:
type.delete()
messages.add_message(request, messages.SUCCESS,
_('Group type deleted.'))
return redirect('groups:type_list')
def wrapper(request, id, *args, **kwargs):
group = get_document_or_404(Group, id=id)
is_admin = group.is_admin(request.user) or request.user.is_superuser
if not is_admin:
if request.is_ajax():
return HttpResponse(_('You are not allowed.'))
else:
messages.add_message(request, messages.ERROR,
_('You are not allowed.'))
return redirect(reverse('groups:group_view', args=[id]))
return func(request, group, *args, **kwargs)
def get_object(self, queryset=None):
"""
Get a document instance for read/update/delete requests.
"""
query_key = self.lookup_url_kwarg or self.lookup_field
query_kwargs = {query_key: self.kwargs[query_key]}
queryset = self.get_queryset()
obj = get_document_or_404(queryset, **query_kwargs)
self.check_object_permissions(self.request, obj)
return obj
def file_view(request, theme_id, file_name):
theme = get_document_or_404(Theme, id=theme_id)
file = theme.files[file_name]
if not file:
raise Http404()
response = HttpResponse(file.file.read(),
content_type=file.file.content_type)
response['Last-Modified'] = file.file.upload_date
return response
def cam_bookmarks(request, id=None):
if id:
user = get_document_or_404(User, id=id)
else:
user = request.user
try:
bookmarks = CameraBookmarks.objects.get(user=user)
except CameraBookmarks.DoesNotExist:
cameras = None
else:
cameras = bookmarks.cameras
return direct_to_template(request, 'cam/bookmarks.html', {'cameras': cameras})
