def login(request):
if request.user.is_authenticated():
return redirect('main.views.index')
if request.POST:
# load up the form with data from the POST request
form = LoginForm(request.POST)
if form.is_valid():
user = authenticate(username=form.cleaned_data['email'],
password=form.cleaned_data['password'])
if user is not None:
django_login(request, user)
fingr_user = user_to_fingr(request.user)
notify_all_friends(fingr_user, 'Your friend ' + str(fingr_user.username) + ' has signed in')
if user_to_fingr(user).verified:
notify_all_friends(fingr_user, 'Your friend ' + str(fingr_user.username) + ' has signed in')
# redirect to main page
return redirect('main.views.index')
else:
django_logout(request)
#redirect to index page
return redirect('main.views.index')
else:
form = LoginForm()
return render(request, 'login.html', {'form': form})
def edit_profile(request):
if request.user.is_authenticated():
f_user = user_to_fingr(request.user)
profile_form = FingrUserForm(initial= {'first_name': f_user.first_name ,
'last_name': f_user.last_name,
'visibility': f_user.visibility},)
if request.method == "POST":
profile_form = FingrUserForm( request.POST, request.FILES)
if profile_form.is_valid():
f_user.first_name = profile_form.cleaned_data['first_name']
f_user.last_name = profile_form.cleaned_data['last_name']
f_user.visibility = profile_form.cleaned_data['visibility']
f_user.save()
return render_to_response('updated_profile.html', context_instance = RequestContext(request))
else:
print profile_form.errors
return render_to_response('edit_profile.html', {'profile_form': profile_form, }, context_instance = RequestContext(request))
else:
return render_to_response('need_to_login.html', context_instance = RequestContext(request))
def set_my_marker(request):
if request.method != 'POST':
return HttpResponse(json.dumps({'success': False}))
user = user_to_fingr(request.user)
assert user is not None
latitude = request.POST.get('lat', None)
longitude = request.POST.get('lng', None)
for field in (latitude, longitude):
if field is None:
return HttpResponse(json.dumps({'success': False}))
try:
latitude = float(latitude)
longitude = float(longitude)
except ValueError:
return HttpResponse(json.dumps({'success': False}))
my_location = user.my_location
my_location.latitude = latitude
my_location.longitude = longitude
my_location.save()
return HttpResponse(json.dumps({'success': True}))
def new_static_marker(request):
if request.method != 'POST':
return HttpResponse(json.dumps({'success': False}))
name = request.POST.get('name', None)
latitude = request.POST.get('lat', None)
longitude = request.POST.get('lng', None)
response = {'success': False}
for x in (name, latitude, longitude):
if x is None:
return HttpResponse(json.dumps(response))
try:
latitude = float(latitude)
longitude = float(longitude)
except ValueError:
return HttpResponse(json.dumps(response))
loc = StaticLocation(name=name, latitude=latitude, longitude=longitude)
loc.save()
user = user_to_fingr(request.user)
user.static_locations.add(loc)
response['pk'] = loc.pk
response['success'] = True
return HttpResponse(json.dumps(response))
def search(request):
context = {}
if request.user.is_authenticated():
f_user = user_to_fingr(request.user)
context['authenticated'] = True
# user is already searching
if request.POST:
form = SearchForm(request.POST)
# display found users
if form.is_valid():
# all users
unfiltered = (FingrUser.objects.filter(username__contains=form.cleaned_data['search']) | FingrUser.objects.filter(first_name__contains=form.cleaned_data['search']) | FingrUser.objects.filter(last_name__contains=form.cleaned_data['search']))
# set(chain(...)) joins querysets and uniques them
# http://stackoverflow.com/questions/431628/how-to-combine-2-or-more-querysets-in-a-django-view
# users without extreme privacy
visible = unfiltered.exclude(visibility="None")
friends = {}
for u in visible:
if (u.visibility=="Friends"):
friends = set(chain(friends, visible.filter(friends=f_user)))
all = unfiltered.filter(visibility="All")
context['userlist'] = set(chain(all, friends))
return render(request, 'search.html', context)
else:
return render(request, 'search.html', context)
else:
#context['userlist'] = FingrUser.objects.all()
return render(request, 'search.html', context)
return redirect('main.views.index')
def add_custom_times(request):
if request.user.is_authenticated():
f_user = user_to_fingr(request.user)
form = CustomTimesForm()
if request.method == "POST":
form = CustomTimesForm(request.POST, request.FILES)
if form.is_valid():
if int(form.cleaned_data['start_time']) < int(form.cleaned_data['end_time']):
name = form.cleaned_data['name']
choice_of_day = form.cleaned_data['choice_of_day']
start_time = form.cleaned_data['start_time']
end_time = form.cleaned_data['end_time']
custom_time = Custom_Times(name = name, choice_of_day = choice_of_day, start_time = start_time, end_time = end_time)
custom_time.save()
f_user.profile.custom_times.add(custom_time)
return render_to_response('updated_profile.html', context_instance = RequestContext(request))
form = CustomTimesForm()
c = {'form': form,}
return render_to_response('add_custom_time.html', c, context_instance = RequestContext(request))
def update_static_marker(request):
if request.method != 'POST':
return HttpResponse(json.dumps({'success': False}))
pk = request.POST.get('id', None)
latitude = request.POST.get('lat', None)
longitude = request.POST.get('lng', None)
for field in (pk, latitude, longitude):
if field is None:
return HttpResponse(json.dumps({'success': False}))
try:
pk = int(pk)
latitude = float(latitude)
longitude = float(longitude)
except ValueError:
return HttpResponse(json.dumps({'success': False}))
static_marker_lookup = StaticLocation.objects.filter(pk=pk)
assert len(static_marker_lookup) <= 1
if len(static_marker_lookup) == 1:
static_marker = static_marker_lookup[0]
user = user_to_fingr(request.user)
if user.static_locations.filter(pk=static_marker.pk).count() > 0:
static_marker.latitude = latitude
static_marker.longitude = longitude
static_marker.save()
return HttpResponse(json.dumps({'success': True}))
return HttpResponse(json.dumps({'success': False}))
def set_status(request):
context = {}
if request.POST:
form = StatusForm(request.POST)
if form.is_valid():
choice = form.cleaned_data['available']
user = user_to_fingr(request.user)
if choice == 'ON':
#only notify them if its actually changed
if not user.available:
notify_all_friends(user, 'Your friend ' + str(user.username) + ' is now FREE')
user.available = True
else:
user.available = False
user.save()
else:
form = StatusForm()
if request.user.is_authenticated():
context['authenticated'] = True
context['form'] = form
return render(request, 'status.html', context)
def automatic_is_available(request):
if request.user.is_authenticated():
f_user = user_to_fingr(request.user)
f_user.automatic_availability = True
current_hour = datetime.datetime.now().hour
current_day = datetime.datetime.now().strftime("%A")
f_user.available = True
for course in f_user.profile.courses.all():
for lecture in course.lectures.all():
if(int(lecture.start_time) <= current_hour):
if(int(lecture.end_time) > current_hour ):
if(str(lecture.choice_of_day).lower() in current_day.lower()):
f_user.available = False
for tutorial in course.tutorials.all() :
if(int(tutorial.start_time) <= current_hour):
if(int(tutorial.end_time) > current_hour ):
if(str(lecture.choice_of_day).lower() in current_day.lower()):
f_user.available = False
for lab in course.labs.all() :
if(int(lab.start_time) <= current_hour):
if(int(lab.end_time) > current_hour ):
if(str(lecture.choice_of_day).lower() in current_day.lower()):
f_user.available = False
for custom in f_user.profile.custom_times.all():
if(int(custom.start_time) <= current_hour):
if(int(custom.end_time) > current_hour ):
if(str(custom.choice_of_day).lower() in current_day.lower()):
f_user.available = False
f_user.save()
def set_event_marker(request):
if request.method != 'POST':
return HttpResponse(json.dumps({'success': False}))
user = user_to_fingr(request.user)
assert user is not None
latitude = request.POST.get('lat', None)
longitude = request.POST.get('lng', None)
pk = request.POST.get('id', None)
for field in (latitude, longitude, pk):
if field is None:
return HttpResponse(json.dumps({'success': False}))
try:
latitude = float(latitude)
longitude = float(longitude)
pk = int(pk)
except ValueError:
return HttpResponse(json.dumps({'success': False}))
event = Event.objects.get(pk=pk)
if event.owner != user:
return HttpResponse(json.dumps({'success': False}))
event.longitude = longitude
event.latitude = latitude
event.save()
return HttpResponse(json.dumps({'success': True}))
def process_view(request, view_func, view_args, view_kwargs):
assert hasattr(request,
'user'), 'The UpdateLastActivityMiddleware requires authentication middleware to be installed.'
if request.user.is_authenticated():
user = user_to_fingr(request.user)
if user is not None:
if user.automatic_availability:
automatic_is_available(request)
def delete_friend(request, target_user_pk):
user = user_to_fingr(request.user)
target_user = get_object_or_404(FingrUser, pk=target_user_pk)
user.friends.remove(target_user)
target_user.friends.remove(user)
target_user.save()
user.save()
return render(request, 'available_friends.html')
def index(request):
context = {}
if request.user.is_authenticated():
user = user_to_fingr(request.user)
context['authenticated'] = True
context['userlist'] = FingrUser.objects.all()
context['hasOnlineFriends'] = user.friends_list.filter(available=True).count
return render(request, 'index.html', context)
def get_friends_locations(request):
user = user_to_fingr(request.user)
assert user is not None
response = []
for friend in user.friends_list.all():
loc = model_to_dict(friend.my_location)
loc['name'] = friend.full_name
response.append(loc)
return HttpResponse(json.dumps(response))
def fingr_user_everywhere(request):
dictionary = {}
if request.user:
if request.user.is_authenticated():
user = user_to_fingr(request.user)
if user is not None:
dictionary['fingr_user'] = user
for message in user.messages_list:
if message.type == Message.MESSAGE and message.read == False and message.sentTo == user:
dictionary['newMessage'] = True
return dictionary
def add_courses_automatically(request):
if request.user.is_authenticated():
f_user = user_to_fingr(request.user)
if request.method == "POST":
form = UploadFileForm(request.POST, request.FILES)
automatic_timetable(request.FILES['file'], request)
#print request
return redirect('profile.views.view_profile')
form = UploadFileForm()
return render_to_response('add_courses_auto.html', {'upload_file_form': form, }, context_instance = RequestContext(request))
def message(request, send_to_user):
form = MessageForm()
print (request.get_full_path(), send_to_user)
context = {'valid': True, 'form': form}
if request.user.is_authenticated():
user = user_to_fingr(request.user)
context['authenticated'] = True
target_user = FingrUser.objects.filter(pk=send_to_user)
if len(target_user) > 0:
target_user = target_user[0]
else:
target_user = None
if target_user:
if request.POST:
form = MessageForm(request.POST)
if form.is_valid():
print 'Message Sent'
context['message_sent'] = True
message_specific_friend(user, target_user, form.cleaned_data['message'])
else:
return redirect('main.views.message')
if target_user in user.friends_list:
pass
else:
if target_user == user:
context['feedback'] = 'Wow you must be lonely to send a message to yourself :('
context['valid'] = False
else:
context['feedback'] = "You are sending a message to someone who isn't your friend. They may not get this message"
received = user.messages_list.filter(sentFrom=target_user,type=Message.MESSAGE).order_by('-time')
sent = target_user.messages_list.filter(sentTo=target_user, sentFrom=user, type=Message.MESSAGE).order_by('-time')
user.messages_list.filter(sentTo=user, type=Message.MESSAGE).update(read=True)
conversation_history = sorted(chain(sent, received), key=lambda instance: instance.time, reverse=True)
#conversation_history = received
#get the previous messages
context['conversation'] = conversation_history[0:5]
context['talking_to'] = target_user
else:
context['valid'] = False
context['feedback'] = 'No such user exists'
else:
return redirect('main.views.login')
return render(request, 'message.html', context)
def process_view(request, view_func, view_args, view_kwargs):
assert hasattr(request,
'user'), 'The UpdateLastActivityMiddleware requires authentication middleware to be installed.'
if request.user.is_authenticated():
user = user_to_fingr(request.user)
if user is not None:
num_unread_messages = user.messages_list.filter(type=Message.MESSAGE, read=False).exclude(
sentFrom=user).count()
if num_unread_messages > 0:
messages.success(request,
"<a href='/inbox'>" + str(num_unread_messages) + ' new unread message(s)</a>',
extra_tags='safe')
for message in user.messages_list:
if message.type == Message.NOTIFICATION:
messages.success(request, message.text)
message.delete()
def add_friend(request, target_user_pk):
"""
target_user_pk should be the primary key of the user that we want to add as a friend
"""
user = user_to_fingr(request.user)
target_user = FingrUser.objects.filter(pk=target_user_pk)[0]
if target_user.username != request.user.username:
user.friends.add(target_user)
target_user.friends.add(user)
notify_specific_friend(target_user, user, str(target_user.username) + ' has added you as a friend.')
else:
print "user tried to add themselves"
# ignore a user trying to add themselves
return redirect('main.views.index')
def events(request):
context = {}
user = user_to_fingr(request.user)
if request.method == 'POST':
form = EventForm(request.POST)
if form.is_valid():
currTime = datetime.datetime.now()
good = True
#we need to do some hacky stuff and set the year, because otherwise it might do 1889 which is an error
startTime = form.cleaned_data['timeStart']
endTime = form.cleaned_data['timeEnd']
startTime = startTime.replace(year=currTime.year)
endTime = endTime.replace(year=currTime.year)
#HOW DO I VALIDATE PROPERLY?
if endTime <= startTime:
errors = form._errors.setdefault("timeEnd", ErrorList())
errors.append(u"End time must be after Start time")
good = False
if form.cleaned_data['date'] < currTime.date():
errors = form._errors.setdefault("date", ErrorList())
errors.append(u"Day must be today or in the future")
good = False
if good:
event = Event(title=form.cleaned_data['title'], owner=user, date=form.cleaned_data['date'],
timeStart=startTime, timeEnd=endTime, description=form.cleaned_data['description']
)
event.save()
notify_all_friends(user, "You have been invited to " + user.full_name + "'s event: " + event.title)
else:
form = EventForm()
context['form'] = form
context['userEvents'] = Event.objects.filter(owner=user)
context['friendEvents'] = Event.objects.filter(owner__in=user.friends_list)
return render(request, 'events.html', context)
def get_static_markers(request):
user = user_to_fingr(request.user)
assert user is not None
response = []
# get users' own markers
for loc in user.static_locations.all():
response.append(loc)
# get all friends markers
for friend in user.friends.all():
for marker in friend.static_locations.all():
response.append(marker)
def model_to_dict_wrapper(instance):
d = model_to_dict(instance, fields=['name', 'latitude', 'longitude'])
d['id'] = instance.pk
d['mine'] = (instance in user.static_locations.all())
return d
response = map(model_to_dict_wrapper, response)
return HttpResponse(json.dumps(response))
def get_events(request):
user = user_to_fingr(request.user)
assert user is not None
response = []
for event in Event.objects.filter(owner=user):
e = model_to_dict(event, fields=['title', 'latitude', 'longitude'])
e['owner'] = event.owner.full_name
e['id'] = event.pk
e['draggable'] = True
response.append(e)
for event in Event.objects.filter(owner__in=user.friends_list):
e = model_to_dict(event, fields=['title', 'latitude', 'longitude'])
e['owner'] = event.owner.full_name
e['id'] = event.pk
e['draggable'] = False
response.append(e)
return HttpResponse(json.dumps(response))
def inbox(request):
context = {}
if request.user.is_authenticated():
context['authenticated'] = True
user = user_to_fingr(request.user)
conversations = user.messages_list.filter(type=Message.MESSAGE)
people = set()
for conversation in conversations:
if conversation.sentFrom != user:
people.add(conversation.sentFrom)
if conversation.sentTo != user:
people.add(conversation.sentTo)
context['conversations'] = people
else:
return redirect('main.views.login')
return render(request, 'inbox.html', context)
def edit_course(request):
#This class is used to make empty formset forms required
# See http://stackoverflow.com/questions/2406537/django-formsets-make-first-required/4951032#4951032
class RequiredFormSet(BaseFormSet):
def __init__(self, *args, **kwargs):
super(RequiredFormSet, self).__init__(*args, **kwargs)
for form in self.forms:
form.empty_permitted = False
CourseFormSet = formset_factory(CourseForm, max_num=10, formset=RequiredFormSet)
LectureFormSet = formset_factory(LectureForm, extra = 1, max_num=10, formset=RequiredFormSet)
TutorialFormSet = formset_factory(TutorialForm, max_num=10, formset=RequiredFormSet)
LaboratoryFormSet = formset_factory(LabForm, max_num=10, formset=RequiredFormSet)
DayTimeFormSet = formset_factory(DayTimesForm,max_num=10, formset=RequiredFormSet)
if request.user.is_authenticated():
f_user = user_to_fingr(request.user)
#profile = f_user.profile.objects.get(fingr_user=f_user)
profile = f_user.profile
if request.method == 'POST': # If the form has been submitted...
course_formset = CourseFormSet(request.POST, prefix='course' )
lecture_formset = LectureFormSet(request.POST, prefix='lecture')
#lec_day_time_formset = DayTimeFormSet(request.POST,prefix='lec_day_time')
tutorial_formset = TutorialFormSet(request.POST, prefix='tutorial')
#tut_day_time_formset = DayTimeFormSet(request.POST, prefix='tut_day_time')
laboratory_formset = LaboratoryFormSet(request.POST, prefix='laboratory')
#lab_day_time_formset = DayTimeFormSet(request.POST, prefix='lab_day_time')
if (course_formset.is_valid() and (validate_formset(lecture_formset) or validate_formset(tutorial_formset) or validate_formset(laboratory_formset))):
#course_formset.save()
#lecture_formset.save()
#lec_day_time_formset.save()
#tutorial_formset.save()
#tut_day_time_formset.save()
#laboratory_formset.save()
print "ITS VALIDDASFJASFHSAHFQA"
#print course_formset.getitem(0)
for form in course_formset:
course = Course(course_name = form.cleaned_data['course_name'] , course_code = form.cleaned_data['course_code'])
course.save()
if validate_formset(lecture_formset):
for lec_form in lecture_formset:
# need to figure out a way to compare theses and print an error !!!
if(lec_form.is_valid()):
print "inside lecture formset"
print lec_form.cleaned_data['start_time']
print lec_form.cleaned_data['end_time']
lecture = Lecture(choice_of_day = lec_form.cleaned_data['choice_of_day'],
start_time = lec_form.cleaned_data['start_time'], end_time = lec_form.cleaned_data['end_time'])
lecture.save()
course.lectures.add(lecture)
if validate_formset(tutorial_formset):
for tut_form in tutorial_formset:
if(tut_form.is_valid()):
tut = Tutorial(choice_of_day = tut_form.cleaned_data['choice_of_day'],
start_time = tut_form.cleaned_data['start_time'], end_time = tut_form.cleaned_data['end_time'])
tut.save()
course.tutorials.add(tut)
if validate_formset(laboratory_formset):
for lab_form in laboratory_formset:
if(lab_form.is_valid()):
lab = Labs( choice_of_day = lab_form.cleaned_data['choice_of_day'],
start_time = lab_form.cleaned_data['start_time'], end_time = lab_form.cleaned_data['end_time'])
lab.save()
course.labs.add(lab)
profile.courses.add(course)
profile.save()
# Not in the else.
return render_to_response('add_courses_manually.html', context_instance = RequestContext(request))
else :
print course_formset.errors
print lecture_formset.errors
#lec_day_time_formset.errors
print tutorial_formset.errors
#tut_day_time_formset.errors
print laboratory_formset.errors
#lab_day_time_formset.errors
course_formset = CourseFormSet(prefix='course')
lecture_formset = LectureFormSet(prefix='lecture')
day_time_formset = DayTimeFormSet(prefix='day_time')
tutorial_formset = TutorialFormSet(prefix='tutorial')
laboratory_formset = LaboratoryFormSet(prefix='laboratory')
c = {'course_formset': course_formset,
'lecture_formset': lecture_formset,
'day_time_formset': day_time_formset,
'tutorial_formset': tutorial_formset,
'laboratory_formset': laboratory_formset,
}
return render_to_response('edit_courses.html',c, context_instance = RequestContext(request))
else:
return render_to_response('need_to_login.html', context_instance = RequestContext(request))
def delete_event(request, event_id):
event = Event.objects.get(pk=event_id)
user = user_to_fingr(request.user)
if event.owner == user:
event.delete()
return redirect('main.views.events')
def view_profile(request, target_user_pk):
print "target user" + target_user_pk
if request.user.is_authenticated():
#f_user = FingrUser.objects.filter(pk=target_user_pk)[0]
f_user = get_object_or_404( FingrUser.objects,pk=target_user_pk)
profile = f_user.profile
# Trying to print courses in a graphical way.
#for course in profile.courses.all():
# print course.course_code
# print course.course_name
#
#
#ordered_courses = { }
monday = ""
tuesday = ""
wednesday = ""
thursday = ""
friday = ""
for course in profile.courses.all():
for lecture in course.lectures.all():
if lecture.choice_of_day == "MON":
monday = monday + course.course_code + "\t" +"Lecture" + "\t" + lecture.start_time + "-" + lecture.end_time + "\n"
elif lecture.choice_of_day == "TUE":
tuesday = tuesday + course.course_code + "\t" +"Lecture" + "\t" + lecture.start_time + "-" + lecture.end_time + "\n"
elif lecture.choice_of_day == "WED":
wednesday = wednesday + course.course_code + "\t" +"Lecture" + "\t" + lecture.start_time + "-" + lecture.end_time + "\n"
elif lecture.choice_of_day == "THU":
thursday = thursday + course.course_code + "\t" +"Lecture" + "\t" + lecture.start_time + "-" + lecture.end_time + "\n"
elif lecture.choice_of_day == "FRI":
friday = friday + course.course_code + "\t" +"Lecture" + "\t" + lecture.start_time + "-" + lecture.end_time + "\n"
for tutorial in course.tutorials.all() :
if tutorial.choice_of_day == "MON":
monday = monday + course.course_code + "\t" + "Tutorial" + "\t" + tutorial.start_time + "-" + tutorial.end_time + "\n"
elif tutorial.choice_of_day == "TUE":
tuesday = tuesday + course.course_code + "\t" + "Tutorial" + "\t" + tutorial.start_time + "-" + tutorial.end_time + "\n"
elif tutorial.choice_of_day == "WED":
wednesday = wednesday + course.course_code + "\t" + "Tutorial" + "\t" + tutorial.start_time + "-" + tutorial.end_time + "\n"
elif tutorial.choice_of_day == "THU":
thursday = thursday + course.course_code + "\t" + "Tutorial" + "\t" + tutorial.start_time + "-" + tutorial.end_time + "\n"
elif tutorial.choice_of_day == "FRI":
friday = friday + course.course_code + "\t" + "Tutorial" + "\t" + tutorial.start_time + "-" + tutorial.end_time + "\n"
for lab in course.labs.all() :
if lab.choice_of_day == "MON":
monday = monday + course.course_code + "\t" + "Lab" + "\t" + lab.start_time + "-" + lab.end_time + "\n"
elif lab.choice_of_day == "TUE":
tuesday = tuesday + course.course_code + "\t" + "Lab" + "\t" + lab.start_time + "-" + lab.end_time + "\n"
elif lab.choice_of_day == "WED":
wednesday = wednesday + course.course_code + "\t" + "Lab" + "\t" + lab.start_time + "-" + lab.end_time + "\n"
elif lab.choice_of_day == "THU":
thursday = thursday + course.course_code + "\t" + "Lab" + "\t" + lab.start_time + "-" + lab.end_time + "\n"
elif lab.choice_of_day == "FRI":
friday = friday + course.course_code + "\t" + "Lab" + "\t" + lab.start_time + "-" + lab.end_time + "\n"
for custom_time in profile.custom_times.all():
if custom_time.choice_of_day == "MON":
monday = monday + custom_time.name + "\t" + custom_time.start_time + "-" + custom_time.end_time + "\n"
elif custom_time.choice_of_day == "TUE":
tuesday = tuesday + custom_time.name + "\t" + custom_time.start_time + "-" + custom_time.end_time + "\n"
elif custom_time.choice_of_day == "WED":
wednesday = wednesday + custom_time.name + "\t" + custom_time.start_time + "-" + custom_time.end_time + "\n"
elif custom_time.choice_of_day == "THU":
thursday = thursday + custom_time.name + "\t" + custom_time.start_time + "-" + custom_time.end_time + "\n"
elif custom_time.choice_of_day == "FRI":
friday = friday + custom_time.name + "\t" + custom_time.start_time + "-" + custom_time.end_time + "\n"
monday = monday.strip("\n")
tuesday = tuesday.strip("\n")
wednesday = wednesday.strip("\n")
thursday = thursday.strip("\n")
friday = friday.strip("\n")
monday_dict = monday.split("\n")
tuesday_dict = tuesday.split("\n")
wednesday_dict = wednesday.split("\n")
thursday_dict = thursday.split("\n")
friday_dict = friday.split("\n")
final_monday = []
final_tuesday = []
final_wednesday = []
final_thursday = []
final_friday = []
for sub in monday_dict:
for splitted in sub.split("\t"):
final_monday.append(splitted)
for sub in tuesday_dict:
for splitted in sub.split("\t"):
final_tuesday.append(splitted)
for sub in wednesday_dict:
for splitted in sub.split("\t"):
final_wednesday.append(splitted)
for sub in thursday_dict:
for splitted in sub.split("\t"):
final_thursday.append(splitted)
for sub in friday_dict:
for splitted in sub.split("\t"):
final_friday.append(splitted)
iterator = itertools.count()
iterator2 = itertools.count()
iterator3 = itertools.count()
iterator4 = itertools.count()
iterator5 = itertools.count()
me_f_user = user_to_fingr(request.user)
target_user_pk = int(target_user_pk)
is_friend = False
for friend in me_f_user.friends_list:
if friend.pk == target_user_pk:
is_friend = True
c = {'username': f_user.username,
'email': f_user.email,
'first_name':f_user.first_name,
'last_name': f_user.last_name,
'monday': final_monday,
'tuesday': final_tuesday,
'wednesday': final_wednesday,
'thursday': final_thursday,
'friday': final_friday,
'iterator': iterator,
'iterator2': iterator2,
'iterator3': iterator3,
'iterator4': iterator4,
'iterator5': iterator5,
'target_user_pk': target_user_pk,
'is_friend' : is_friend,
}
return render_to_response('profile.html', c, context_instance = RequestContext(request))
else:
return render_to_response('need_to_login.html')
def automatic_timetable(file, request):
days = {"Mon":0, "Tue":1, "Wed":2, "Thu":3, "Fri":4}
unsw_start_dates = {
'11s1':'28/2/2011',
'11s2':'18/7/2011',
'12s1':'27/2/2012',
'12s2':'16/7/2012',
'13s1':'4/3/2013',
'13s2':'29/7/2013',
'14s1':'3/3/2014',
'14s2':'28/7/2014',
'15s1':'2/3/2015',
'15s2':'27/7/2015',
'16s1':'29/2/2016',
'16s2':'25/7/2016'
}
if request.user.is_authenticated():
f_user = user_to_fingr(request.user)
source = file.read()
f = source.replace('\r', '')
s = BeautifulSoup(f.replace("\n",""))
# gets the year and sem
sem = re.sub(r'.*Semester (\d+) \S\S(\d+).*', u'\\2s\\1', s.find("option", {'selected':'true'}).text)
title = sem + " Timetable"
#
if not re.match(r'\d\ds\d', sem):
current_time = datetime.datetime.now()
sem = '%ds%d' % (current_time.year % 100, 1 if current_time.month < 7 else 2)
courses = [x.contents[0] for x in s.findAll("td", {"class":"sectionHeading"})]
for course in courses:
print course
course_code = str(course).split("-")[0]
course_name = str(course).split("-")[1]
course_code = course_code.strip()
course_name = course_name.strip()
add_course = Course(course_code = course_code, course_name = course_name)
add_course.save()
classes = s.find(text=course).findNext("table").findAll("tr", {"class": re.compile("data")})
ctype, code, day, tim, weeks, place, t = ['' for x in xrange(7)]
for c in classes:
a = [(x.contents[0] if x.contents else "") for x in c.findAll("td", recursive=False)]
print a
g = (t for t in a)
print g
t = g.next()
if t.strip() != " ":
ctype = t
t = g.next()
t= g.next()
if t.strip() not in days:
code = t
day = g.next().strip()
else:
day = t.strip()
tim = g.next()
weeks = g.next()
place = g.next()
t = ' '.join(g.next().findAll(text=True))
if tim.find(" - ") == -1:
continue
start, end = tim.split(" - ")
start = datetime.datetime.strptime(unsw_start_dates[sem] + ' ' + start, "%d/%m/%Y %I:%M%p")
end = datetime.datetime.strptime(unsw_start_dates[sem] + ' ' + end, "%d/%m/%Y %I:%M%p")
start = str(start).split(" ")[1]
end = str(end).split(" ")[1]
start = str(start).split(":")[0]
end = str(end).split(":")[0]
day = day.strip()
day = day.upper()
if(ctype == "Lecture"):
new_lecture = Lecture(choice_of_day = day, start_time = start, end_time = end)
new_lecture.save()
add_course.lectures.add(new_lecture)
elif(ctype == "Tutorial"):
new_tutorial = Tutorial(choice_of_day = day, start_time = start, end_time = end)
new_tutorial.save()
add_course.tutorials.add(new_tutorial)
elif(ctype == "Laboratory"):
new_lab = Labs(choice_of_day = day, start_time = start, end_time = end)
new_lab.save()
add_course.labs.add(new_lab)
f_user.profile.courses.add(add_course)
f_user.profile.save()
def get_my_marker(request):
user = user_to_fingr(request.user)
assert user is not None
return HttpResponse(json.dumps(model_to_dict(user.my_location)))
def view_map(request):
user = user_to_fingr(request.user)
context = {'my_events': Event.objects.filter(owner=user),
'friends_events': Event.objects.filter(owner__in=user.friends_list.all())}
return render(request, 'map.html', context)
def profile(request):
if request.user.is_authenticated():
f_user = user_to_fingr(request.user)
return redirect('profile.views.view_profile', f_user.pk)
