def forum(request, asset_id):
errors = []
# check that the asset ID exists
# if not a 404 will be thrown
the_asset = get_object_or_404(Asset, pk=asset_id)
# ok, so asset exists
# now check that this user is allowed to view the forum subjects for this asset
my_id = request.user
if check_user_linked_to_asset(my_id, asset_id):
# user is linked so fill up the subjects object
subjects = Subject.objects.all().filter(asset_id=asset_id)
else:
# prepare the error message
errors.append("You are not authorised to view this Forum")
# set these to empty
the_asset = []
subjects = []
return render(request, 'forum.html', {
'subjects': subjects,
'asset': the_asset,
'errors': errors
})
def asset_detail(request, asset_id):
the_asset = []
errors = []
asset_form = []
#check asset exists
the_asset = get_object_or_404(Asset, pk=asset_id)
# check if the user is allowed to view this asset
my_id = request.user
is_linked = check_user_linked_to_asset(request.user, asset_id)
if is_linked == False:
errors.append("You do not have permission to view this page")
is_an_owner = assets_extras.is_user_also_owner(request.user, asset_id)
if is_an_owner == False:
errors.append("Access restricted")
return render(request, "assets/asset_detail.html", {
"asset": the_asset,
"errors": errors
})
def post_detail(request, asset_id, id):
errors = []
show_edit = False # defaults to False
# this view is of one post
# need to check user is authorised to view it
# and if they are the AUTHOR, they will see an edit button
# first check does the post exist?
if blog_post_exists(asset_id, id) == False:
errors.append("This page does not exist")
post = []
the_asset = []
else:
# it does exist
post = Post.objects.get(id=id, asset_ID_id=asset_id)
the_asset = get_object_or_404(Asset, pk=asset_id)
# but now check that this user is allowed to view posts for this asset
my_id = request.user
if check_user_linked_to_asset(my_id, asset_id) == False:
# prepare the error message
errors.append("You are not authorised to view this Post")
# set these to empty
the_asset = []
post = []
else:
# it can be viewed so update the counter
post.num_views += 1
post.save()
#is this person the author?
if check_user_linked_to_blog_post(my_id, asset_id, id):
show_edit = True
return render(
request, "postdetail.html", {
'post': post,
'asset': the_asset,
'errors': errors,
'asset_id': asset_id,
'post_id': id,
'show_edit': show_edit
})
def delete_post(request, asset_id, subject_id, thread_id, post_id):
errors = []
post = get_object_or_404(Post, pk=post_id)
thread = get_object_or_404(Thread, pk=thread_id)
subject = get_object_or_404(Subject, pk=subject_id)
the_asset = get_object_or_404(Asset, pk=asset_id)
my_id = request.user
if check_user_linked_to_asset(my_id, asset_id) == False:
errors.append("You are not authorised to view to this Forum")
post = []
thread = []
subject = []
the_asset = []
elif check_subject_exists(asset_id, subject_id) == False:
errors.append("Sorry this Subject does not exist in this Forum")
post = []
thread = []
subject = []
the_asset = []
elif check_thread_exists(subject_id, thread_id) == False:
errors.append("Thread does not exist")
post = []
thread = []
subject = []
the_asset = []
elif check_user_linked_to_forum_post(my_id, post_id) == False:
errors.append("You are not authorised to edit this Post")
post = []
thread = []
subject = []
the_asset = []
else:
post.delete()
messages.success(request, "This Post has been deleted")
return redirect(
reverse('thread',
kwargs={
"asset_id": asset_id,
"subject_id": subject_id,
"thread_id": thread_id
}))
def new_blog_post(request, asset_id):
errors = []
the_asset = get_object_or_404(Asset, pk=asset_id)
form = []
content_error = ""
# asset exists, now check user
my_id = request.user
if check_user_linked_to_asset(my_id, asset_id) == False:
# user is linked so fill up the posts object
errors.append("You are not authorised to post on this Blog")
the_asset = []
else:
# check POST or GET
if request.method == "POST":
form = BlogPostForm(request.POST, request.FILES)
if form.is_valid():
# before saving check the content of the content field
if len(form.cleaned_data['content']) == 0:
# check if content is blank. HTML Field has to be set to required == False
# so that the form can submit (to do with the browser trying to focus on the element and not seeing it
# so it's possible that it's blank
form = BlogPostForm(request.POST)
content_error = "Please don't save your new post without some content!"
else:
post = form.save(commit=False)
post.author = request.user
post.published_date = timezone.now()
post.asset_ID_id = asset_id
post.save()
return redirect(post_detail, asset_id, post.pk)
else:
form = BlogPostForm()
args = {
'errors': errors,
'asset': the_asset,
'form': form,
'content_error': content_error
}
args.update(csrf(request))
return render(request, 'blogpostform.html', args)
def asset_detail(request, asset_id):
the_asset = get_object_or_404(Asset, pk=asset_id)
errors = []
# check if the user is allowed to view this asset
my_id = request.user
if check_user_linked_to_asset(my_id, asset_id) == False:
the_asset = []
errors.append("You are not authorised to view this page")
return render(request, "asset_detail.html", {
"asset": the_asset,
"errors": errors
})
def post_list(request, asset_id):
# this view will return the posts for the given asset_id
# posts will be ordered by most recent first and
# only posts with pub date from current date or before
errors = []
# check that the asset ID exists
# if not a 404 will be thrown
the_asset = get_object_or_404(Asset, pk=asset_id)
# ok, so asset exists
# now check that this user is allowed to view posts for this asset
my_id = request.user
#if check_user_linked_to_asset(my_id, asset_id):
if check_user_linked_to_asset(my_id, asset_id):
# user is linked so fill up the posts object
posts = Post.objects.filter(
asset_ID=asset_id,
published_date__lte=timezone.now()).order_by('-published_date')
else:
# prepare the error message
errors.append("You are not authorised to view this Blog")
# set these to empty
the_asset = []
posts = []
# save this current asset_id in sessions
# over-writing what's save already
request.session['current_asset_id'] = asset_id
num_linked_assets = request.session['linked_assets']
j = json.loads(num_linked_assets)
return render(
request, "blogposts.html", {
'posts': posts,
'asset': the_asset,
'errors': errors,
'num_linked_assets': j
})
def delete_blog_post(request, asset_id, id):
errors = []
content_error = ""
form = []
the_asset = []
# first check does the post exist?
if blog_post_exists(asset_id, id) == False:
errors.append("This page does not exist")
else:
# it does exist
post = Post.objects.get(id=id, asset_ID_id=asset_id)
the_asset = get_object_or_404(Asset, pk=asset_id)
# but now check that this user is allowed to view posts for this asset
my_id = request.user
if check_user_linked_to_asset(my_id, asset_id) == False:
# prepare the error message
errors.append("You are not authorised to delete this Post")
# set these to empty
the_asset = []
# and finally check if the user is the one who CREATED this post
# only they should be allowed to delete (or the staff)
if check_user_linked_to_blog_post(my_id, asset_id, id) == False:
if not request.user.is_staff:
messages.error(request,
"You are not authorised to delete this Post")
# set these to empty
the_asset = []
return redirect(post_detail, asset_id, id)
post.delete()
messages.success(request, "This Blog entry has been deleted")
return redirect(reverse('post_list', kwargs={"asset_id": asset_id}))
def asset_exception_detail2(request,
asset_id,
the_year=0,
the_month=0,
the_day=0):
the_asset = get_object_or_404(Asset, id=asset_id)
errors = []
user_ok = False
the_year = 2020
the_month = 6
the_day = 17
if check_user_linked_to_asset(request.user, asset_id):
if assets_extras.is_user_also_owner(request.user, asset_id):
user_ok = True
else:
errors.append("Restricted Access")
messages.add_message(request, messages.ERROR, "Restricted Access")
user_ok = False
else:
errors.append("You are not authorised to view this page")
messages.add_message(request, messages.ERROR,
"You are not authorised to view this page")
user_ok = False
if user_ok:
True
return render(request, "assets/asset_exception_date.html", {
"the_asset": the_asset,
"errors": errors,
'user_ok': user_ok
})
def thread(request, asset_id, subject_id, thread_id):
# this view shows the one thread only
errors = []
content_error = ""
thread = get_object_or_404(Thread, pk=thread_id)
subject = get_object_or_404(Subject, pk=subject_id)
the_asset = get_object_or_404(Asset, pk=asset_id)
my_id = request.user
if check_user_linked_to_asset(my_id, asset_id) == False:
errors.append("You are not authorised to view to this Forum")
thread = []
subject = []
the_asset = []
if check_subject_exists(asset_id, subject_id) == False:
errors.append("Sorry this Subject does not exist in this Forum")
thread = []
subject = []
the_asset = []
if check_thread_exists(subject_id, thread_id) == False:
errors.append("Thread does not exist")
thread = []
subject = []
the_asset = []
else:
# it can be viewed so update the counter
thread.num_views += 1
thread.save()
args = {
'thread': thread,
'errors': errors,
'subject': subject,
'asset': the_asset,
}
args.update(csrf(request))
return render(request, 'thread.html', args)
def threads(request, asset_id, subject_id):
# this view shows all threads for a given subject
errors = []
subject = get_object_or_404(Subject, pk=subject_id)
the_asset = get_object_or_404(Asset, pk=asset_id)
my_id = request.user
if check_user_linked_to_asset(my_id, asset_id) == False:
errors.append("You are not authorised to view this Forum")
subject = []
the_asset = []
if check_subject_exists(asset_id, subject_id) == False:
errors.append("Sorry this Subject does not exist in this Forum")
subject = []
the_asset = []
return render(request, "threads.html", {
'subject': subject,
'asset': the_asset,
'errors': errors
})
def booking_detail_BEFORE_FORMS(request, booking_id, new=""):
the_booking = get_object_or_404(Booking, pk=booking_id)
errors = []
asset = []
booking_detail = []
if new != "new":
new = ""
# get the asset id (from the booking)
asset_id = the_booking.asset_ID_id
# anyone linked to the Asset can view the booking
# but only the requestor can edit the booking (once it is a Confirmed Booking)
# only the Owner can edit the booking (while it is in Pending mode)
my_id = request.user
if check_user_linked_to_asset(my_id, asset_id):
# check the status of the overall booking
booking_pending = is_booking_pending(booking_id)
booking_confirmed = is_booking_confirmed(booking_id)
asset = Asset.objects.get(pk=asset_id)
booking_detail = BookingDetail.objects.select_related().filter(
booking_id_id=booking_id).order_by("booking_date")
else:
errors.append("You are not authorised to view this booking")
return render(
request, "booking_detail.html", {
"booking": the_booking,
"booking_detail": booking_detail,
"asset": asset,
"errors": errors,
"new": new
})
def edit_blog_post(request, asset_id, id):
errors = []
content_error = ""
form = []
the_asset = []
# first check does the post exist?
if blog_post_exists(asset_id, id) == False:
errors.append("This page does not exist")
else:
# it does exist
post = Post.objects.get(id=id, asset_ID_id=asset_id)
the_asset = get_object_or_404(Asset, pk=asset_id)
# but now check that this user is allowed to view posts for this asset
my_id = request.user
if check_user_linked_to_asset(my_id, asset_id) == False:
# prepare the error message
errors.append("You are not authorised to edit this Post")
# set these to empty
the_asset = []
# and finally check if the user is the one who CREATED this post
# only they should be allowed to edit (or the staff)
if check_user_linked_to_blog_post(
my_id, asset_id,
id) == False and request.user.is_staff == False:
errors.append("You are not authorised to edit this Post")
# set these to empty
the_asset = []
if request.method == "POST":
form = BlogPostForm(request.POST, request.FILES, instance=post)
if form.is_valid():
if len(form.cleaned_data['content']) == 0:
# check if content is blank. HTML Field has to be set to required == False
# so that the form can submit (to do with the browser trying to focus on the element and not seeing it
# so it's possible that it's blank
post = Post.objects.get(id=id, asset_ID_id=asset_id)
form = BlogPostForm(instance=post)
content_error = "Please don't save a your post without some content!"
else:
post = form.save(commit=False)
post.author = request.user
post.last_edited_date = timezone.now()
post.asset_ID_id = asset_id
post.save()
return redirect(post_detail, asset_id, post.pk)
else:
form = BlogPostForm(instance=post)
args = {
'errors': errors,
'asset': the_asset,
'form': form,
'content_error': content_error
}
args.update(csrf(request))
return render(request, 'blogpostform.html', args)
def delete_a_member(request, asset_id, member_id):
code_message = ""
errors = []
#check asset exists
the_asset = get_object_or_404(Asset, id=asset_id)
#check if the current user is the same as the member_id
#no one can delete a user/mapping except the user themselves
#owners can 'deactivate' members only
if not member_id == request.user.id:
code_message = "You are not authorised to do this"
messages.add_message(request, messages.ERROR, code_message)
errors.append("You are not authorised to do this")
else:
#check if the member id is linked to this asset
member_linked = check_user_linked_to_asset(member_id, asset_id)
if member_linked:
the_member = Asset_User_Mapping.objects.get(asset_ID=asset_id,
user_ID=member_id)
if request.method == "POST":
#user has confirmed
the_member.delete()
#delete all bookings for that user
Booking.objects.filter(
asset_ID=asset_id,
requested_by_user_ID=member_id).delete()
messages.add_message(
request, messages.SUCCESS, "You have been removed from " +
the_asset.asset_display_name)
return redirect('my_details')
else:
return render(request,
"assets/asset_user_mapping_confirm_delete.html",
{
"asset_mapping": the_member,
"asset": the_asset
})
else:
code_message = "This is not a valid membership ID"
messages.add_message(request, messages.ERROR, code_message)
return render(request, "assets/asset_user_mapping_detail.html",
{"asset": the_asset})
return render(request, "assets/asset_user_mapping_detail.html", {
"asset": the_asset,
"errors": errors
})
def edit_post(request, asset_id, subject_id, thread_id, post_id):
# this sends user to the post_form.html mentioned in the new_post view (for editing)
# and to thread.html for viewing after editing
errors = []
content_error = ""
post = get_object_or_404(Post, pk=post_id)
thread = get_object_or_404(Thread, pk=thread_id)
subject = get_object_or_404(Subject, pk=subject_id)
the_asset = get_object_or_404(Asset, pk=asset_id)
form = PostForm(instance=post)
my_id = request.user
if check_user_linked_to_asset(my_id, asset_id) == False:
errors.append("You are not authorised to view to this Forum")
post = []
thread = []
subject = []
the_asset = []
elif check_subject_exists(asset_id, subject_id) == False:
errors.append("Sorry this Subject does not exist in this Forum")
post = []
thread = []
subject = []
the_asset = []
elif check_thread_exists(subject_id, thread_id) == False:
errors.append("Thread does not exist")
post = []
thread = []
subject = []
the_asset = []
elif check_user_linked_to_forum_post(my_id, post_id) == False:
if not request.user.is_staff:
errors.append("You are not authorised to edit this Post")
post = []
thread = []
subject = []
the_asset = []
if request.method == "POST":
form = PostForm(request.POST, instance=post)
if form.is_valid():
# before saving check the content of the comment field
if len(form.cleaned_data['comment']) == 0:
post = get_object_or_404(Post, pk=post_id)
form = PostForm(instance=post)
content_error = "Please don't save a blank post!"
else:
form.save()
messages.success(request, "This Post has been updated")
return redirect(
reverse('thread',
kwargs={
"asset_id": asset_id,
"subject_id": subject_id,
"thread_id": thread.pk
}))
else:
form = PostForm(instance=post)
args = {
'thread':
thread,
'errors':
errors,
'subject':
subject,
'asset':
the_asset,
'form':
form,
'form_action':
reverse('edit_post',
kwargs={
'asset_id': asset_id,
"subject_id": subject_id,
"thread_id": thread_id,
"post_id": post_id
}),
'button_text':
"Update Post",
'content_error':
content_error,
}
args.update(csrf(request))
return render(request, 'post_form.html', args)
def new_post(request, asset_id, subject_id, thread_id):
# this view allows the user to add a post to a thread
errors = []
content_error = ""
thread = get_object_or_404(Thread, pk=thread_id)
subject = get_object_or_404(Subject, pk=subject_id)
the_asset = get_object_or_404(Asset, pk=asset_id)
# set this here so that it is assigned
form = PostForm()
my_id = request.user
if check_user_linked_to_asset(my_id, asset_id) == False:
errors.append("You are not authorised to view to this Forum")
thread = []
subject = []
the_asset = []
elif check_subject_exists(asset_id, subject_id) == False:
errors.append("Sorry this Subject does not exist in this Forum")
thread = []
subject = []
the_asset = []
elif check_thread_exists(subject_id, thread_id) == False:
errors.append("Thread does not exist")
thread = []
subject = []
the_asset = []
else:
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
# before saving check the content of the comment field
if len(form.cleaned_data['comment']) == 0:
form = PostForm(request.POST)
content_error = "Please don't save a blank post!"
else:
post = form.save(False)
post.thread = thread
post.user = request.user
post.save()
messages.success(
request,
"Your post has been added to %s" % thread.name)
return redirect(
reverse('thread',
kwargs={
"asset_id": asset_id,
"subject_id": subject_id,
"thread_id": thread.pk
}))
else:
form = PostForm()
args = {
'thread':
thread,
'errors':
errors,
'subject':
subject,
'asset':
the_asset,
'form':
form,
'form_action':
reverse('new_post',
kwargs={
"asset_id": asset_id,
"subject_id": subject_id,
"thread_id": thread.id
}),
'button_text':
"Update Post",
'content_error':
content_error,
}
args.update(csrf(request))
return render(request, 'post_form.html', args)
def asset_exception_detail(request, asset_id):
# this function is called when user wants to add or edit an exception on the date provided
# the exception date (year, month, day) should be in the session
# if not then send the user back to re-select
the_asset = []
the_exception = []
errors = []
asset_exception_form = []
user_ok = False
the_values = ""
exception_date = ""
is_a_weekday = False
#check asset exists
the_asset = get_object_or_404(Asset, pk=asset_id)
# check if the user is allowed to view this asset
my_id = request.user
if check_user_linked_to_asset(request.user, asset_id):
if assets_extras.is_user_also_owner(request.user, asset_id):
user_ok = True
else:
errors.append("Access restricted")
user_ok = False
else:
errors.append("You do not have permission to view this page")
user_ok = False
if user_ok:
#sessions variables must exist
#variables from the session
if 'exception_year_cal' in request.session:
year = (request.session['exception_year_cal'])
if 'exception_month_cal' in request.session:
month = (request.session['exception_month_cal'])
if 'exception_day_cal' in request.session:
day = (request.session['exception_day_cal'])
try:
#create the datetime object from the given parameters
the_values = "%s - %s - %s" % (year, month, day)
exception_date = datetime.date(int(year), int(month), int(day))
show_date_format = exception_date.strftime("%A, %d %B")
is_a_weekday = booking_extras.is_date_a_weekday(exception_date)
except:
code_message = "There was a problem with the date. Please re-select from the calendar and try again." + the_values
messages.add_message(request, messages.ERROR, code_message)
return redirect(
reverse_lazy('venue_calendar_admin',
kwargs={"asset_id": the_asset.id}))
else:
#check if the exception exists
exception_record = assets_extras.get_exception_record(
the_asset.id, exception_date)
if request.method == "POST":
if exception_record:
#include initial data so new content can be checked
#against existing bookings
form = AssetExceptionForm(request.POST,
initial=exception_record)
else:
#no initial data so brand new exception
form = AssetExceptionForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
pass
else:
if exception_record:
form = AssetExceptionForm(inital=exception_record)
else:
form = AssetExceptionForm(
initial={
'the_date': show_date_format,
'day': day,
'year': year,
'month': month
})
return render(
request, "assets/asset_exception_date.html", {
"asset": the_asset,
"errors": errors,
"user_ok": user_ok,
"form": form,
"the_date": show_date_format,
"is_a_weekday": is_a_weekday
})
def new_thread(request, asset_id, subject_id):
errors = []
content_error = ""
subject = get_object_or_404(Subject, pk=subject_id)
the_asset = get_object_or_404(Asset, pk=asset_id)
my_id = request.user
if check_user_linked_to_asset(my_id, asset_id) == False:
errors.append("You are not authorised to add to this Forum")
subject = []
the_asset = []
elif check_subject_exists(asset_id, subject_id) == False:
errors.append("Sorry this Subject does not exist in this Forum")
subject = []
the_asset = []
else:
if request.method == "POST":
thread_form = ThreadForm(request.POST)
post_form = PostForm(request.POST)
if thread_form.is_valid() and post_form.is_valid():
# before saving check the content of the comment field
if len(post_form.cleaned_data['comment']) == 0:
thread_form = ThreadForm(request.POST)
post_form = PostForm(request.POST)
content_error = "Please don't save your new thread without posting a starting comment!"
else:
thread = thread_form.save(False)
thread.subject = subject
thread.user = request.user
thread.save()
post = post_form.save(False)
post.user = request.user
post.thread = thread
post.save()
messages.success(request, "Thanks for your new Thread")
return redirect(
reverse('thread',
kwargs={
"asset_id": asset_id,
"subject_id": subject_id,
"thread_id": thread.pk
}))
else:
thread_form = ThreadForm()
post_form = PostForm(request.POST)
args = {
'thread_form': thread_form,
'post_form': post_form,
'subject': subject,
'asset': the_asset,
'errors': errors,
'content_error': content_error
}
args.update(csrf(request))
return render(request, 'thread_form.html', args)
def make_a_booking(request, asset_id):
the_asset = get_object_or_404(Asset, pk=asset_id)
errors = []
owner_date_object = []
total_days_requested = 0
booking_form = []
my_id = request.user
if check_user_linked_to_asset(my_id, asset_id):
user_ok = True
else:
user_ok = False
errors.append("You are not authorised to view this page")
if request.method == "POST":
new_booking_form = BookingForm(request.POST)
if new_booking_form.is_valid():
# check if the user has a stripe_id registered and if not point them to register their credit card
if is_user_stripe_registered(my_id):
# save it in memory while getting the addition info need to save it to the database
new_booking = new_booking_form.save(False)
# get additional info
new_booking.asset_ID_id = asset_id
new_booking.requested_by_user_ID = request.user
# then save
new_booking.save()
# now, using the new_booking.pk, save each of the dates in BookingDetail
new_id = new_booking.pk
start_date = request.POST['start_date']
start_date = datetime.datetime.strptime(
start_date, '%m/%d/%Y').date()
end_date = request.POST['end_date']
end_date = datetime.datetime.strptime(end_date,
'%m/%d/%Y').date()
owner_date_object = get_owners_and_dates(
asset_id, start_date, end_date)
print "object count is %s" % len(owner_date_object)
for item in owner_date_object:
owner_id = item.owner_id
print "ownerId: %s" % owner_id
print "current user: %s" % request.user.id
print "the Detail: %s" % item.date_span_available_detail
for available_date in item.date_span_available_detail:
booking_date = available_date
# check if the owner is booking one of their own dates
# if so, then set immediately to is_confirmed == True
if owner_id == request.user.id:
new_record = BookingDetail(
booking_date=booking_date,
slot_owner_id_id=owner_id,
booking_id_id=new_id,
is_approved=True,
date_approved=timezone.now())
else:
new_record = BookingDetail(
booking_date=booking_date,
slot_owner_id_id=owner_id,
booking_id_id=new_id,
is_pending=True)
new_record.save()
new = "new"
# messages.success(request, "New Booking created, thanks")
return redirect(
reverse('booking_detail',
kwargs={
"booking_id": new_booking.pk,
"new": new
}))
else:
request.session['asset_id_for_stripe'] = asset_id
request.session['start_date_for_stripe'] = request.POST[
'start_date']
request.session['end_date_for_stripe'] = request.POST[
'end_date']
return redirect(reverse('register_stripe'))
else:
#request.method is GET,
#check which stage of get
if 'start_date' in request.GET:
new_booking_form = BookingForm(request.GET)
if new_booking_form.is_valid():
start_date = request.GET['start_date']
start_date = datetime.datetime.strptime(
start_date, '%m/%d/%Y').date()
if 'end_date' in request.GET:
end_date = request.GET['end_date']
end_date = datetime.datetime.strptime(
end_date, '%m/%d/%Y').date()
if end_date.toordinal() - start_date.toordinal() < 0:
errors.append(
'Your end date is earlier than your start date - please correct!'
)
new_booking_form = BookingForm(request.GET)
elif end_date.toordinal() == start_date.toordinal():
errors.append(
'Your start and end dates are the same - please correct!'
)
new_booking_form = BookingForm(request.GET)
elif end_date.toordinal() - start_date.toordinal() > 60:
errors.append(
'You cannot request more than 60 days at a time!')
new_booking_form = BookingForm(request.GET)
else:
# dates are fine (unless I programme more validation) so now continue with
# displaying the ownership for the date range!
print "Data to function: %s %s %s" % (asset_id, start_date,
end_date)
owner_date_object = get_owners_and_dates(
asset_id, start_date, end_date)
new_booking_form = BookingForm(request.GET)
else:
new_booking_form = BookingForm(request.GET)
else:
# this is first time so just display the form
new_booking_form = BookingForm()
args = {
'booking_form': new_booking_form,
'the_asset': the_asset,
'errors': errors,
'owner_date_object': owner_date_object,
'user_ok': user_ok,
}
args.update(csrf(request))
return render(request, "new_booking.html", args)
def all_asset_bookings(request,
asset_id,
user_id=0,
time_period="all",
status="all",
owner_id=0):
# this function returns all the bookings for an asset
# can provide optional arg with the user id which will return bookings for a particular user only
# can provide optional arg to return bookings of a particular time period only (future or past)
# based on the inputs, the page_desc is decided
page_desc = ""
the_asset = get_object_or_404(Asset, pk=asset_id)
this_user_only = False
time_range = ""
errors = []
the_owner = 0
my_page_display = False
if request.user.id == int(user_id):
this_user_only = True
my_page_display = True
time_range = time_period
if time_range != "future" and time_range != "past":
time_range = ""
if len(time_range) > 0:
page_desc = "%s %s" % (page_desc, time_range.capitalize())
if status == "pending":
is_pending = True
is_confirmed = False
page_desc = "%s %s" % (page_desc, "Pending Requests")
elif status == "confirming":
is_confirmed = False
is_pending = False
page_desc = "%s %s" % (page_desc, "Requests to be Confirmed")
elif status == "confirmed":
is_confirmed = True
is_pending = False
page_desc = "%s %s" % (page_desc, "Confirmed Bookings")
else:
is_confirmed = ""
is_pending = ""
page_desc = "%s %s" % (page_desc, "Bookings")
if owner_id > 0:
# an owner_id has been supplied
# check if this user is linked to this owner
if check_user_linked_to_owner(request.user, owner_id, asset_id):
the_owner = owner_id
the_owner_display_name = get_owner_name_for_user_id_and_asset(
asset_id, user_id, first_name_only=True)
page_desc = "%s %s %s" % (page_desc, "to be approved by ",
the_owner_display_name)
my_page_display = False
else:
the_owner = 0
my_id = request.user
if check_user_linked_to_asset(my_id, asset_id):
# optional userID
if this_user_only:
all_bookings = get_bookings(asset_id=asset_id,
user_id=request.user.id,
time_period=time_range,
pending=is_pending,
confirming=is_confirmed,
owner_id=the_owner)
else:
all_bookings = get_bookings(asset_id=asset_id,
time_period=time_range,
pending=is_pending,
confirming=is_confirmed,
owner_id=the_owner)
else:
the_asset = []
all_bookings = []
errors.append("You are not authorised to view this Bookings page")
return render(
request, "all_bookings.html", {
"asset": the_asset,
"bookings": all_bookings,
"errors": errors,
"return_page_user": my_page_display,
"page_name": page_desc
})
def my_bookings(request, **kwargs):
#set all initial values regardless of kwargs
#start with who has requested this page
#all bookings returned are requested by this user
#it doesn't matter if the user is the owner - they will see what all other members see
#(if they are the owner they can view it through my_venue_bookings view to get special owner view)
my_id = request.user.id
booking_requested_by = 0
errors = []
booking_id = 0
booked_date = ""
asset_id = 0
the_asset = []
time_period = "future" #assume future always unless provided
future_bookings = []
past_bookings = []
num_bookings_future = 0
num_bookings_past = 0
# get all bookings for the request.user
if 'booking_id' in kwargs:
booking_id = kwargs['booking_id']
booked_date = get_booking_date(booking_id)
# used in query - search for all bookings for this particular asset/venue
# checks the id of the person who called this query to make sure they are linked to it
if 'asset_id' in kwargs:
asset_id = kwargs['asset_id']
#does asset exist?
the_asset = get_object_or_404(Asset, id=asset_id)
#is the requestor linked to this asset?
is_linked = check_user_linked_to_asset(my_id, asset_id)
#is the requestor activated?
is_activated = check_user_activated(my_id, asset_id)
if not is_linked:
errors.append("You are not authorised to view this Bookings page")
if not is_activated:
errors.append("Account deactivated")
else:
errors.append("Please provide the Venue details")
if not errors:
# used in query - search for all bookings past or future from now
# time period can be either: 'past' or 'future'
if 'time_period' in kwargs:
time_period = kwargs['time_period']
if len(errors) == 0:
# if no time_period is provided then this view must return two record sets (past AND future)
# if time_period is 'past' or 'future', then this view returns just one record set
if time_period == "future":
# this is all FUTURE bookings (>=today and >current time)
future_bookings = get_bookings(user_id=my_id,
time_period=time_period,
asset_id=asset_id)
num_bookings_future = len(future_bookings)
elif time_period == "past":
# this is all PAST bookings (<=today and <current_time)
past_bookings = get_bookings(user_id=my_id,
time_period=time_period,
asset_id=asset_id)
num_bookings_past = len(past_bookings)
else:
#this is ALL bookings (but still in separate past/future objects)
future_bookings = get_bookings(user_id=my_id,
time_period="future",
asset_id=asset_id)
num_bookings_future = len(future_bookings)
past_bookings = get_bookings(user_id=my_id,
time_period="past",
asset_id=asset_id)
num_bookings_past = len(past_bookings)
return render(
request, "booking/bookings.html", {
"future_bookings": future_bookings,
"num_bookings_future": num_bookings_future,
"past_bookings": past_bookings,
"num_bookings_past": num_bookings_past,
"booking_id_to_highlight": booking_id,
"booked_date_to_highlight": booked_date,
"the_asset": the_asset,
"errors": errors
})
def booking_detail(request, booking_id, new=""):
# this view shows the booking in detail, a list of all the dates in the booking
# with a summary on top
# depending on the booking status and the user who is viewing, the view can return
# a formset which allows the user to edit the booking or returns just a record set for display
the_booking = get_object_or_404(Booking, pk=booking_id)
errors = []
asset = []
booking_detail = []
# this 'new' is here to indicate that we got to this page from entering a NEW BOOKING REQUEST
# it will determine the link to show
if new != "new":
new = ""
# set these to False to start with
booking_pending = False
booking_confirmed = False
user_is_requestor = False
user_is_owner = False
booking_in_future = False
include_delete_booking_button = False
# set the formsets to empty to start with
formset_owner = []
formset_requestor_to_confirm = []
formset_requestor_confirmed_or_pending = []
# get the asset id (from the booking)
asset_id = the_booking.asset_ID_id
# anyone linked to the Asset can view the booking
# but only the requestor can edit the booking (once it is a Confirmed Booking)
# only the Owner can edit the booking (while it is in Pending mode)
my_id = request.user
if check_user_linked_to_asset(my_id, asset_id):
asset = Asset.objects.get(pk=asset_id)
#this booking_detail will get returned if no editing is needed on this booking
booking_detail = BookingDetail.objects.select_related().filter(
booking_id_id=booking_id).order_by("booking_date")
# check the status of the overall booking
booking_pending = is_booking_pending(booking_id)
booking_confirmed = is_booking_confirmed(booking_id)
# check if this is a future booking
# if not, then display page without any forms regardless of who is looking at it
if get_booking_end_date(booking_id) > datetime.date.today():
booking_in_future = True
# check the status of the user_id
# are they the original requestor or an owner of this asset?
is_requestor = get_booking_requestor(booking_id, return_id=True)
if is_requestor == request.user.id:
user_is_requestor = True
user_is_owner = check_if_user_is_an_owner(my_id, asset_id)
# depending on the above checks, show the booking detail with different formsets
if (user_is_owner or user_is_requestor) and booking_in_future:
# REQUESTOR OR OWNER AND FUTURE BOOKING
# so check further
if user_is_requestor:
# USER IS REQUESTOR
print "User is the Requestor"
if booking_confirmed or booking_pending:
print "booking is confirmed or pending"
# the form only needs to give the Requestor the option to delete individual dates when it is a
# confirmed booking or a pending booking
# also gives option to delete the ENTIRE booking
include_delete_booking_button = True
BookingDetailFormSet = modelformset_factory(
BookingDetail,
form=
BookingDetailForm_for_Requestor_Confirmed_or_Pending,
max_num=1,
can_delete=True)
booking_detail_for_requestor = BookingDetail.objects.select_related(
).filter(booking_id_id=booking_id,
booking_id__requested_by_user_ID=request.user.id
).order_by("booking_date")
formset_requestor_confirmed_or_pending = BookingDetailFormSet(
queryset=booking_detail_for_requestor)
if request.method == 'POST':
formset_requestor_confirmed_or_pending = BookingDetailFormSet(
request.POST,
request.FILES,
queryset=booking_detail_for_requestor)
delete_count = len(
formset_requestor_confirmed_or_pending.
deleted_forms)
form_count = len(
formset_requestor_confirmed_or_pending)
if delete_count > 0:
if delete_count == form_count:
print "all dates are to be deleted"
# then this is the full booking to be delete, so just call the delete_booking view
return redirect(
reverse('delete_booking',
kwargs={"booking_id": booking_id}))
else:
print "some dates are to be deleted"
# don't save to db yet have to check if dates are still consecutive
instances = formset_requestor_confirmed_or_pending.save(
commit=False)
# it's ok to delete the dates set to delete
for obj in formset_requestor_confirmed_or_pending.deleted_objects:
obj.delete()
# run code to break up the booking into separate consecutive date bookings IF IT IS REQUIRED
num_extra_bookings = make_the_split(booking_id)
if num_extra_bookings > 0:
messages.success(
request,
"This Booking (ref %s) has been split into %s Bookings with consecutive dates ranges"
% (booking_id, num_extra_bookings + 1))
return redirect(
reverse('all_asset_bookings',
kwargs={
"asset_id": asset_id,
"user_id": request.user.id
}))
else:
if delete_count > 1:
messages.success(
request,
"%s dates have been removed from this booking."
% delete_count)
else:
messages.success(
request,
"%s date has been removed from this booking."
% delete_count)
return redirect(
reverse(
'booking_detail',
kwargs={"booking_id": booking_id}))
else:
# nothing was sent for the form to delete so send it right back
print formset_requestor_confirmed_or_pending.errors
messages.error(
request,
"Want to amend the booking? Please set Remove to 'Yes' on each date you want to remove."
)
formset_requestor_confirmed_or_pending = BookingDetailFormSet(
queryset=booking_detail_for_requestor)
elif booking_confirmed == False:
# the booking is not confirmed but is it also not pending, so this means that the user needs to
# look at the approved/denied dates and CONFIRM the booking
# they do this by selecting either delete, or confirm on each date that is set to 'Approved'
# and the MUST select 'Delete' for all dates that are set to 'Denied'
# they can also delete the ENTIRE BOOKING
print "booking is not confirmed yet"
BookingDetailFormSet = modelformset_factory(
BookingDetail,
form=BookingDetailForm_for_Requestor_to_Confirm,
max_num=1,
can_delete=True)
booking_detail_for_requestor = BookingDetail.objects.select_related(
).filter(booking_id_id=booking_id,
booking_id__requested_by_user_ID=request.user.id
).order_by("booking_date")
formset_requestor_to_confirm = BookingDetailFormSet(
queryset=booking_detail_for_requestor)
include_delete_booking_button = True
if request.method == 'POST':
formset_requestor_to_confirm = BookingDetailFormSet(
request.POST,
request.FILES,
queryset=booking_detail_for_requestor)
if formset_requestor_to_confirm.is_valid():
print "it is valid"
# don't save to db yet
total_forms = len(formset_requestor_to_confirm)
instances = formset_requestor_to_confirm.save(
commit=False)
delete_count = len(
formset_requestor_to_confirm.deleted_forms)
form_count = total_forms
print "TOTAL FORMS %s" % total_forms
print "DELETED INSTANCES %s" % delete_count
is_confirmed_count = 0
for instance in instances:
confirmed = instance.is_confirmed
if confirmed:
is_confirmed_count += 1
print "Confirmed: %s Deleted: %s Form Count: %s" % (
is_confirmed_count, delete_count, form_count)
if is_confirmed_count + delete_count == form_count:
# it's ok to update the instance now
# had to wait until now because I was updating is_approved in the instance
# and it was affecting the form if the code had to return because of count not matching
is_confirmed_count = 0
for instance in instances:
confirmed = instance.is_confirmed
if confirmed:
is_confirmed_count += 1
instance.date_confirmed = timezone.now(
)
# update this in the table to False
instance.is_approved = 0
print "confirmed count after ok: %s" % is_confirmed_count
# it's ok to delete the dates set to delete
for obj in formset_requestor_to_confirm.deleted_objects:
obj.delete()
# and update the other dates
formset_requestor_to_confirm.save()
# run code to break up the booking into separate consecutive date bookings IF IT IS REQUIRED
num_extra_bookings = make_the_split(booking_id)
if num_extra_bookings > 0:
messages.success(
request,
"Thank you for confirming this booking. Just so you are aware, this Booking (ref %s) has been split into %s Bookings with consecutive date ranges"
% (booking_id, num_extra_bookings + 1))
return redirect(
reverse('all_asset_bookings',
kwargs={
"asset_id": asset_id,
"user_id": request.user.id
}))
else:
messages.success(
request,
"Thank you for confirming this booking."
)
return redirect(
reverse(
'booking_detail',
kwargs={"booking_id": booking_id}))
else:
messages.error(
request,
"Oops! To confirm your Booking, all dates (approved or denied) have to be set to 'Yes'"
)
formset_requestor_to_confirm = []
formset_requestor_to_confirm = BookingDetailFormSet(
queryset=booking_detail_for_requestor)
else:
print formset_requestor_to_confirm.errors
messages.error(
request,
"Oops! Form not valid. Please check that 'Confirm' is selected for all Approved date and 'Remove' is selected for each Denied date"
)
formset_requestor_to_confirm = BookingDetailFormSet(
queryset=booking_detail_for_requestor)
else:
#user is the owner
print "The user is the owner of some (or all) dates in the booking"
if booking_pending:
BookingDetailFormSet = modelformset_factory(
BookingDetail,
form=BookingDetailForm_for_Owner,
max_num=1)
booking_detail_for_owner = BookingDetail.objects.select_related(
).filter(booking_id_id=booking_id,
slot_owner_id_id=request.user.id).order_by(
"booking_date")
formset_owner = BookingDetailFormSet(
queryset=booking_detail_for_owner)
if request.method == 'POST':
formset_owner = BookingDetailFormSet(
request.POST,
request.FILES,
queryset=booking_detail_for_owner)
if formset_owner.is_valid():
print "it is valid"
# don't save to db yet
instances = formset_owner.save(commit=False)
total_forms = len(formset_owner)
is_approved_count = 0
is_denied_count = 0
both_count = 0
form_count = total_forms
for instance in instances:
approved = instance.is_approved
if approved:
is_approved_count += 1
instance.date_approved = timezone.now()
denied = instance.is_denied
if denied:
is_denied_count += 1
instance.date_denied = timezone.now()
if approved and denied:
both_count += 1
print "Approved: %s Denied: %s Form Count: %s" % (
is_approved_count, is_denied_count, form_count)
if (is_approved_count + is_denied_count
== form_count) and both_count == 0:
formset_owner.save()
messages.success(
request,
"Thank you for updating these dates.")
return redirect(
reverse('booking_detail',
kwargs={"booking_id": booking_id}))
else:
messages.error(
request,
"Oops! Please check that (only one of) 'Approved' or 'Denied' is set to Yes for each date requested"
)
formset_owner = BookingDetailFormSet(
queryset=booking_detail_for_owner)
else:
print formset_owner.errors
messages.error(
request,
"Oops! Please check that (only one of) 'Approved' or 'Denied' is set to Yes for each date requested"
)
formset_owner = BookingDetailFormSet(
queryset=booking_detail_for_owner)
else:
errors.append("You are not authorised to view this booking")
args = {
'booking': the_booking,
'booking_detail': booking_detail,
'asset': asset,
'errors': errors,
'new': new,
'formset_owner': formset_owner,
'formset_requestor_confirmed_or_pending':
formset_requestor_confirmed_or_pending,
'formset_requestor_to_confirm': formset_requestor_to_confirm,
'include_delete_booking_button': include_delete_booking_button,
}
args.update(csrf(request))
return render(request, "booking_detail.html", args)
def review_a_booking(request, asset_id):
bookingform = BookingForm()
user_ok = False
the_asset = get_object_or_404(Asset, id=asset_id)
#check user is linked to the asset provided
if check_user_linked_to_asset(request.user, asset_id):
#is the requestor activated?
if check_user_activated(request.user, asset_id):
user_ok = True
else:
user_ok = False
messages.add_message(request, messages.ERROR,
"Account Deactivated")
else:
user_ok = False
messages.add_message(request, messages.ERROR,
"You are not authorised to view this page")
if user_ok:
#sessions variables must exist
#variables from the session
if 'selected_day_cal' in request.session:
day = (request.session['selected_day_cal'])
if 'selected_month_cal' in request.session:
month = (request.session['selected_month_cal'])
if 'selected_year_cal' in request.session:
year = (request.session['selected_year_cal'])
if 'selected_hour_cal' in request.session:
hour = (request.session['selected_hour_cal'])
if 'selected_minute_cal' in request.session:
minute = (request.session['selected_minute_cal'])
try:
the_values = "%s - %s - %s - %s - %s" % (year, month, day, hour,
minute)
url_date = datetime.datetime(int(year), int(month), int(day),
int(hour), int(minute))
except:
clear_date_and_time_from_session
code_message = "There was a problem with the date, please re-select from the booking calendar " + the_values
messages.add_message(request, messages.ERROR, code_message)
return redirect(
reverse_lazy('make_a_booking',
kwargs={"asset_id": the_asset.id}))
else:
show_date_format = url_date.strftime("%A, %d %B")
show_time_format = url_date.strftime("%H:%M")
if request.method == "POST":
form = BookingForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
hour = int(cd['hour'])
minute = int(cd['minute'])
day = int(cd['day'])
month = int(cd['month'])
year = int(cd['year'])
url_date = datetime.datetime(year, month, day, hour,
minute)
the_request_date = datetime.datetime(year, month, day)
the_request_time = datetime.time(hour, minute)
#check things about the date first here before saving
#the date has already been checked before being saved to the session
#check if the time-slot is still available (could be a delay with confirming the booking)
new_booking = Booking(
requested_by_user_ID=request.user,
asset_ID=the_asset,
requested_date=the_request_date,
requested_start_time=the_request_time)
try:
new_booking.save()
new_id = new_booking.pk
#redirect to bookings page
clear_date_and_time_from_session
#send email to user
user_email = request.user.email
current_site = get_current_site(request)
domain = current_site.domain
delete_link = "%s/%s/%s/" % (domain, "booking/delete",
new_id)
message_body = "Here are the details of your recent booking: " + show_date_format + " at " + show_time_format
message_body += " To delete this booking at any time, click <a href='" + delete_link + "'>here</a>"
con = get_connection()
send_mail("Count Me In = booking",
message_body,
"*****@*****.**",
['*****@*****.**', user_email],
connection=con)
return redirect(
reverse_lazy('my_bookings',
kwargs={
"asset_id": the_asset.id,
"booking_id": new_id
}))
except IntegrityError as code_message:
code_message = "You have already booked that particular time slot, please choose another"
messages.add_message(request, messages.ERROR,
code_message)
clear_date_and_time_from_session
#redirect to bookings page
return redirect(
reverse_lazy('make_a_booking',
kwargs={"asset_id": the_asset.id}))
else:
print(form.errors)
#form not valid
else:
bookingform = BookingForm(
initial={
'requested_date': show_date_format,
'requested_start_time': show_time_format,
'hour': hour,
'minute': minute,
'day': day,
'year': year,
'month': month
})
return render(
request, "booking/confirm_booking.html", {
"asset": the_asset,
'bookingform': bookingform,
'request_date': show_date_format,
'request_time': show_time_format,
"user_ok": user_ok
})
def member_detail_edit(request, asset_id, member_id):
#to edit a member, must be the owner of the asset
#check asset exists
the_asset = get_object_or_404(Asset, pk=asset_id)
errors = []
the_member_form = []
the_member_detail = []
initial_data = ""
# check if the user is allowed to view this asset
my_id = request.user
is_an_owner = assets_extras.is_user_also_owner(my_id, asset_id)
if is_an_owner == False:
messages.add_message(request, messages.ERROR,
"You are not authorised to view this page")
errors.append("You are not authorised to view this page")
else:
#check validity of the member they want to edit
is_linked = check_user_linked_to_asset(member_id, asset_id)
if is_linked == False:
messages.add_message(request, messages.ERROR,
"That is not a valid Member ID")
errors.append("That is not a valid Member ID")
else:
the_member_detail = Asset_User_Mapping.objects.get(
asset_ID=asset_id, user_ID=member_id)
initial_data = {
'is_activated': the_member_detail.is_activated,
'is_owner': the_member_detail.is_owner,
'asset_membership_ID': the_member_detail.asset_membership_ID,
'asset_swipe_ID': the_member_detail.asset_swipe_ID,
'admin_notes': the_member_detail.admin_notes
}
#for validation after form is POSTED, will need to know if the user_id submitting is the same as the member_id
if my_id == the_member_detail.user_ID:
owner_user_same_person = True
else:
owner_user_same_person = False
if len(errors) == 0: #no errors
if request.method == "POST":
form = AssetMemberForm(request.POST, initial=initial_data)
if form.is_valid():
cd = form.cleaned_data
is_staff = cd['is_owner']
is_activated = cd['is_activated']
membership_ID = cd['asset_membership_ID']
swipe_ID = cd['asset_swipe_ID']
notes = cd['admin_notes']
if form.has_changed():
if ('is_owner' in form.changed_data
or 'is_activated' in form.changed_data
) and owner_user_same_person:
# check that the current user hasn't changed their own is_staff status to False
# if they have send back a warning (or else they will not be able to view the Owner pages)
code_message = "You cannot edit your own staff status. Another staff member must do this on your behalf."
messages.add_message(request, messages.WARNING,
code_message)
return redirect(
reverse_lazy('member_detail',
kwargs={"asset_id": asset_id}))
elif is_staff and not is_activated:
code_message = "To deactivate a staff member, you must first remove their staff status"
messages.add_message(request, messages.WARNING,
code_message)
errors.append(code_message)
return redirect(
reverse_lazy('member_detail',
kwargs={"asset_id": asset_id}))
else:
try:
Asset_User_Mapping.objects.filter(
user_ID=member_id,
asset_ID=asset_id).update(
is_owner=is_staff,
is_activated=is_activated,
asset_membership_ID=membership_ID,
asset_swipe_ID=swipe_ID,
admin_notes=notes)
code_message = "Member " + the_member_detail.user_ID.first_name + " " + the_member_detail.user_ID.last_name + " has been edited"
messages.add_message(request, messages.INFO,
code_message)
#send back to Membership page
return redirect(
reverse_lazy('member_detail',
kwargs={"asset_id":
asset_id}))
except Error:
code_message = "There was a problem, can you please try that again?"
messages.add_message(request, messages.ERROR,
code_message)
return redirect(
reverse_lazy('member_detail',
kwargs={"asset_id": asset_id}))
else:
print(form.errors)
else: #not POST
the_member_form = AssetMemberForm(initial=initial_data)
else: #there are errors
the_member_form = []
return render(
request, "assets/asset_user_mapping_detail_edit.html", {
"asset": the_asset,
"form": the_member_form,
"member": the_member_detail,
"errors": errors
})
def venue_calendar_admin(request, asset_id):
the_asset = get_object_or_404(Asset, id=asset_id)
errors = []
user_ok = False
cal_data = {}
dates_to_show = set()
if check_user_linked_to_asset(request.user, asset_id):
if is_user_also_owner(request.user, asset_id):
user_ok = True
else:
errors.append("Restricted Access")
messages.add_message(request, messages.ERROR, "Restricted Access")
user_ok = False
else:
errors.append("You are not authorised to view this page")
messages.add_message(request, messages.ERROR,
"You are not authorised to view this page")
user_ok = False
if user_ok:
#remove any selected dates/times from the session in case they exist already
#empty session variables
booking_extras.clear_exception_date_from_session
# each day there are bookings, the calendar shows "Bookings <the number>"
# and a link with "add an exception"
# if the date is already in the exception table, the link will say "edit exception" (or something like that)
# unlike the calendar for users (make_a_booking view), there are no modals on this calendar - each item on the date will be a separate link
# create the object that the calendar needs (cal_data)
# this is a series of dates and links
#distict query below is not allowed in sqlite3 so will get individual dates by populating a set() which can only have unique values
#dates_to_show = Bookings.objects.all().filter(asset_ID = the_asset.id, requested_date__gte=datetime.date.today()).order_by('requested_date').distinct('asset_ID', 'requested_date')
#there will be multiple bookings per date so to get individual dates put into a set()
all_future_bookings = Booking.objects.all().filter(
asset_ID=the_asset.id, requested_date__gte=datetime.date.today())
if all_future_bookings:
for item in all_future_bookings:
# print(item.requested_date)
dates_to_show.add(item.requested_date)
if dates_to_show:
for item in dates_to_show:
num_future_bookings = get_total_bookings_venue(
the_asset.id, selected_date=item)
todays_date = datetime.date(datetime.datetime.now().year,
datetime.datetime.now().month,
datetime.datetime.now().day)
is_exception_date = assets_extras.is_date_in_exception_table(
the_asset.id, item)
entry_date_str = item.strftime("%m-%d-%Y")
if is_exception_date:
click_link = onclick = 'UpdateExceptionDate(this," + str(entry_date.day) + "," + the_asset.id + ")'
href_link = "%s%s/" % ("/asset/exception/", asset_id)
exception_link = "<a style='background-color:#f44336; font-size:12px;border-radius: 25px;padding:4px 6px 4px 6px;' href='" + href_link + "'>View Exception Details</a>"
else:
exception_link = ""
if num_future_bookings == 1:
text_desc = "Booking"
else:
text_desc = "Bookings"
cal_data[
entry_date_str] = "<div>%s %s</div> <div>%s</div>" % (
num_future_bookings, text_desc, exception_link)
print(cal_data)
else:
#no dates to show, so empty calendar!
messages.add_message(request, messages.INFO,
"Click on any date to add an exception")
return render(
request, "booking/booking_calendar_venue.html", {
"the_asset": the_asset,
"errors": errors,
"cal_data": cal_data,
'user_ok': user_ok
})
def make_a_booking(request, asset_id):
clear_date_and_time_from_session
user_ok = False
the_asset = get_object_or_404(Asset, id=asset_id)
errors = []
asset_booking_dates = []
asset_booking_dates_times = []
cal_data = {}
the_modals = []
year = datetime.date.today().year
month = datetime.date.today().month
month_name = calendar.month_name[month]
if check_user_linked_to_asset(request.user, asset_id):
#is the requestor activated?
if check_user_activated(request.user, asset_id):
user_ok = True
#remove any selected dates/times from the session in case they exist already
#empty session variables
request.session['selected_year_cal'] = []
request.session['selected_month_cal'] = []
request.session['selected_day_cal'] = []
request.session['selected_hour_cal'] = []
request.session['selected_minute_cal'] = []
else:
user_ok = False
messages.add_message(request, messages.ERROR,
"Account deactivated")
else:
user_ok = False
errors.append("You are not authorised to view this page")
messages.add_message(request, messages.ERROR,
"You are not authorised to view this page")
if user_ok:
time_period_to_display = get_display_time_period_for_booking(asset_id)
#create the object that the calendar needs (cal_data)
#this is a series of dates and links
#also create the MODAL object (the_modals)
#this is the set of booking links that will pop up when the user clicks on the calendar date
#both of these need to only show the dates that the venue has set
#so this could be 5, 6 or 7 day weeks (and not EVERY DAY)
#so cal_dat and the_modals may not have consecutive dates
asset_booking_dates = get_asset_booking_dates_for_display(asset_id)
for entry_date in asset_booking_dates:
#------prepare the cal_data------#
entry_date_index = asset_booking_dates.index(entry_date)
entry_date_str = entry_date.strftime("%m-%d-%Y")
#------prepare the cal_data end------#
#------prepare the_modals start------#
header_message = "Available times on " + entry_date.strftime(
"%A %d %b")
the_modal_start = "<div class='modal fade bs-example-modal-lg' id='myTimeModal" + str(
entry_date_index) + "' role='dialog'>"
the_modal_start += "<div class='modal-dialog modal-lg'>"
the_modal_start += "<div class= 'modal-content'>"
the_modal_start += "<div class= 'modal-header'>"
the_modal_start += "<h3 class='modal-title'>" + header_message + "</h3>"
the_modal_start += "<button type='button' class='close' data-dismiss='modal'>×</button>"
the_modal_start += "</div>"
the_modal_start += "<div class='modal-body'>"
asset_booking_dates_times = get_asset_booking_time_links(
asset_id, entry_date)
num_items = len(asset_booking_dates_times)
#only run the rest of this function if there are times provided
#(someone could be looking at the site after-hours)
if num_items > 0:
the_modal_middle = ""
the_count = 0
for item in asset_booking_dates_times:
#print ("%s: %s" % ("the", item))
#need to display all the items except last one
#last time-slot should be closing time, so it can't be booked
the_count += 1
if the_count < num_items:
# print ("%s:%s" %(item.hour, item.minute))
display_time = datetime.datetime.strftime(
item, "%H:%M")
extend_url = "review/"
#if fully booked, don't include a link ***STILL TO CODE MH ***
if time_slot_fully_booked(asset_id, entry_date, item):
the_modal_middle += "%s%s%s" % (
"<type='button' onclick='alert('This slot is fully booked')' class='btn-dark btn-sm' disabled='disabled' href='#'>",
display_time, "</button>")
else:
the_modal_middle += "%s%s%s" % (
"<a type='button' onclick='updateDateAndTime(this,"
+ str(entry_date.day) +
")' class='button button-dark button-circle btn-lg' href='review/'>",
display_time, "</a>")
the_modal_end = "</div>"
the_modal_end += "<div class='modal-footer'>"
the_modal_end += "<button type='button' class='btn btn-default' data-dismiss='modal'>Close</button>"
the_modal_end += "</div></div></div></div>"
the_modal = the_modal_start + the_modal_middle + the_modal_end
the_modals.append({"detail": the_modal})
#------prepare the modal end------#
#------populate the cal_data------#
the_first_slot = "%s" % (datetime.datetime.strftime(
asset_booking_dates_times[0], "%H:%M"))
the_last_slot = "%s" % (datetime.datetime.strftime(
asset_booking_dates_times[len(asset_booking_dates_times) -
1], "%H:%M"))
opening_times_for_display = "%s to %s" % (the_first_slot,
the_last_slot)
# issue with button on calendar in large view if date is TODAY - model doesn't open (3rd party code)
# so changing entry text for TODAY only to an <a> tag and styling like a button
# all other dates work
if entry_date_index == 0:
entry_message = "<a style='background-color:#f44336; font-size:16px;border-radius: 25px;padding:8px 12px 8px 12px;' data-toggle='modal' data-target='#myTimeModal" + str(
entry_date_index
) + "'>" + opening_times_for_display + "</a>"
else:
entry_message = "<button type='button' style='border-radius: 25px;'class='btn btn-primary' data-toggle='modal' data-target='#myTimeModal" + str(
entry_date_index
) + "'>" + opening_times_for_display + "</button>"
#populate cal_data
cal_data[entry_date_str] = entry_message
#------populate the cal_data end--#
args = {
'the_asset': the_asset,
'errors': errors,
'user_ok': user_ok,
'cal_data': cal_data,
'the_modals': the_modals
}
#args.update(csrf(request))
return render(request, "booking/new_booking.html", args)
def print_bookings(request, **kwargs):
asset_id = 0
my_id = request.user.id
is_owner = False
is_linked = False
time_period = "future"
selected_date = ""
year = 0
month = 0
day = 0
#prepare the query
if 'the_year' in kwargs:
year = kwargs['the_year']
print(year)
if 'the_month' in kwargs:
month = kwargs['the_month']
print(month)
if 'the_day' in kwargs:
day = kwargs['the_day']
print(day)
check = year + month + day
print(check)
if check > 0:
selected_date = datetime.date(year, month, day)
time_period = ""
print("date is:")
print(selected_date)
#prepare the query
if 'asset_id' in kwargs:
asset_id = kwargs['asset_id']
#prepare the query
if 'time_period' in kwargs:
time_period = kwargs['time_period']
#can only print if an owner
is_owner = is_user_also_owner(my_id, asset_id)
#is the requestor linked to this asset?
is_linked = check_user_linked_to_asset(my_id, asset_id)
#format file name
now = datetime.datetime.now()
format_now_date = now.strftime("%d-%b-%y")
format_now_time_in_file = now.strftime("%H:%M:%S")
format_now_time_filename = now.strftime("_%H%M%S")
format_file_name = "bookings_as_of_" + format_now_date + format_now_time_filename + ".csv"
if is_owner and is_linked:
the_output = get_bookings(asset_id=asset_id,
time_period=time_period,
selected_date=selected_date)
response = HttpResponse(content_type='text/csv')
response[
'Content-Disposition'] = 'attachment; filename=' + format_file_name
writer = csv.writer(response)
writer.writerow([
'Venue', 'Booking Date', ' Booking Time', 'First Name', 'Surname',
'Membership Number', 'Swipe ID'
])
for item in the_output:
if not type(item.requested_date) is datetime.date:
print("its not a date")
format_date = item.requested_date.strftime("%d-%b-%y")
format_time = item.requested_start_time.strftime("%H:%M")
user_membership_ID = assets_extras.get_membership_id(
item.requested_by_user_ID, item.asset_ID)
user_swipe_ID = assets_extras.get_swipe_id(
item.requested_by_user_ID, item.asset_ID)
writer.writerow([
item.asset_ID.asset_display_name, format_date, format_time,
item.requested_by_user_ID.first_name,
item.requested_by_user_ID.last_name, user_membership_ID,
user_swipe_ID
])
writer.writerow([])
writer.writerow([])
writer.writerow(['Printed:', format_now_date])
writer.writerow(['At:', format_now_time_in_file])
return response
def profile(request):
invitecodeform = InviteCodeForm()
code_message = ""
if request.method == "POST":
form = InviteCodeForm(request.POST)
if form.is_valid():
# hard-coding the actions here for purposes of testing the concept of using an invitation code
cd = form.cleaned_data
the_date = timezone.now().strftime("%Y-%m-%d %H:%M:%S")
if cd['invitecode'] == "11111":
# check if the code has been used
if check_user_linked_to_asset(request.user, 1) == False:
new_mapping = Asset_User_Mapping(user_ID=request.user,
asset_ID_id=1,
date_activated=the_date,
is_owner=0,
is_activated=True,
inviter_id=13)
new_mapping.save()
else:
code_message = "You have already used that code"
elif cd['invitecode'] == "22222":
if check_user_linked_to_asset(request.user, 2) == False:
new_mapping = Asset_User_Mapping(user_ID=request.user,
asset_ID_id=2,
date_activated=the_date,
is_owner=0,
is_activated=True,
inviter_id=21)
new_mapping.save()
else:
code_message = "You have already used that code"
elif cd['invitecode'] == "33333":
if check_user_linked_to_asset(request.user, 3) == False:
new_mapping = Asset_User_Mapping(user_ID=request.user,
asset_ID_id=3,
date_activated=the_date,
is_owner=0,
is_activated=True,
inviter_id=19)
new_mapping.save()
else:
code_message = "You have already used that code"
else:
code_message = "Code not recognised"
else:
invitecodeform = InviteCodeForm()
# set session values to be used until user logs out
# store the asset ids they are linked to
# create empty session list
request.session['linked_assets'] = []
linked_asset_count = Asset.objects.all().filter(
asset_users=request.user).count()
# want to store a list in the session
# http://stackoverflow.com/questions/6720121/serializing-result-of-a-queryset-with-json-raises-error
class LinkedAssets(object):
def __init__(self, asset_id):
self.asset_id = asset_id
def serialize(self):
return self.__dict__
if linked_asset_count > 0:
# fill the linked_assets session list
linked_assets = serializers.serialize(
'json',
Asset.objects.all().filter(asset_users=request.user),
fields=('id,'))
request.session['linked_assets'] = linked_assets
assets = Asset_User_Mapping.objects.all().filter(user_ID=request.user)
return render(
request, 'profile.html', {
'assets': assets,
'invitecodeform': invitecodeform,
'code_message': code_message
})
def profile(request,**kwargs):
#'invite_code' will be in kwargs if the user has
#requested to be linked to an asset via a URL (they are redirected to this view)
if 'invite_code' in kwargs:
invite = kwargs['invite_code']
else:
invite=0
invitecodeform = InviteCodeForm()
code_message = ""
if request.method == "POST":
form = InviteCodeForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
the_code = cd['invitecode']
the_date = timezone.now().strftime("%Y-%m-%d %H:%M:%S")
#check if the invitecode is in the Asset table
#return the AssetID if it is
the_venue = get_asset_from_invite_code(the_code)
if the_venue:
#check if the venue has been activated
the_venue_activated = is_asset_activated(the_venue.id)
if the_venue_activated:
the_venue_id = the_venue.id
the_venue_name = the_venue.asset_display_name
#check if the user is already linked to this asset
if check_user_linked_to_asset(request.user,the_venue_id) == False:
new_mapping = Asset_User_Mapping(user_ID=request.user,asset_ID=the_venue,is_owner=0,invite_code_used=the_code)
new_mapping.save()
code_message = "You have just been counted in to " + the_venue_name + "!"
messages.add_message(request, messages.SUCCESS, code_message)
else:
code_message = "You are already a Member of " + the_venue_name + "!"
messages.add_message(request, messages.ERROR, code_message)
else:
code_message = "This is not a active code. Please confirm the code with your Gym."
messages.add_message(request, messages.ERROR, code_message)
else:
code_message = "This is not a valid code. Please check and try again."
messages.add_message(request, messages.ERROR, code_message)
elif invite:
#user has entered a VALID invite_code via the url, so add them to this asset (if they are not already linked to it)
#return the AssetID if it is
the_venue = get_asset_from_invite_code(invite)
if the_venue:
#check if the venue has been activated
the_venue_activated = is_asset_activated(the_venue.id)
if the_venue_activated:
the_venue_id = the_venue.id
the_venue_name = the_venue.asset_display_name
#check if the user is already linked to this asset
if check_user_linked_to_asset(request.user,the_venue_id) == False:
new_mapping = Asset_User_Mapping(user_ID=request.user,asset_ID=the_venue,is_owner=0,invite_code_used=invite)
new_mapping.save()
code_message = "You have just been counted in to " + the_venue_name + "!"
messages.add_message(request, messages.SUCCESS, code_message)
else:
code_message = "You are already a Member of " + the_venue_name + "!"
messages.add_message(request, messages.ERROR, code_message)
else:
code_message = "This is not a active code. Please confirm the code with your Gym."
messages.add_message(request, messages.ERROR, code_message)
else:
code_message = "This is not a valid code. Please check and try again."
messages.add_message(request, messages.ERROR, code_message)
else:
invitecodeform = InviteCodeForm()
# set session values to be used until user logs out
# store the asset ids they are linked to
# create empty session list
request.session['linked_assets']=[]
linked_asset_count = Asset.objects.all().filter(asset_users=request.user).count()
# want to store a list in the session
# http://stackoverflow.com/questions/6720121/serializing-result-of-a-queryset-with-json-raises-error
class LinkedAssets(object):
def __init__(self,asset_id):
self.asset_id = asset_id
def serialize(self):
return self.__dict__
if linked_asset_count > 0:
# fill the linked_assets session list
linked_assets = serializers.serialize('json',Asset.objects.all().filter(asset_users = request.user), fields=('id,'))
request.session['linked_assets'] = linked_assets
assets = Asset_User_Mapping.objects.all().filter(user_ID=request.user, asset_ID_id__is_activated=True)
return render(request, 'home/profile.html',
{'assets': assets, 'invitecodeform': invitecodeform, 'code_message': code_message})
