def createCode(request, roomid):
newRoom = Room(code=roomid)
if isExists(roomid):
return HttpResponse("Error: Room exists")
else:
newRoom.save()
return HttpResponse("Room created")
def _save_room(cd):
room = Room()
room.id = cd['id'] or None
room.number = cd['number']
room.description = cd['description']
room.syndic = cd['syndic']
room.save()
return room
def test_name(self):
k = Room.objects.filter(name__startswith='Blue')
self.assertEqual(k.count(), 1)
p = Room(name='Magenta', capacity=1)
p.save()
self.assertEqual(Room.objects.count(), 4)
p.delete()
self.assertEqual(Room.objects.count(), 3)
def test_description(self):
k = Room.objects.filter(description__contains='Nice')
self.assertEqual(k.count(), 1)
p = Room(name='a', capacity=1, description='Not nice')
p.save()
self.assertEqual(Room.objects.count(), 4)
p.delete()
self.assertEqual(Room.objects.count(), 3)
def register(self, password):
room = Room()
room.password = password
try:
room.save()
except:
return None, False
return room.id, True
def handlefbrequestcallback(request):
fp = open( 'tmp.3.log', 'w' )
print >> fp, request
request_str = ( request.GET.get('request') )
request_to = ( request.GET.get('to') )
#request_from = ( request.GET.get('from') )
request_id = ( request.GET.get('id') )
request_from = request.session['fb_id']
#if request_to:
# request_to = int(request_to.encode('ascii'))
#if request_from:
# request_from = int(request_from.encode('ascii'))
#if request_id:
# request_id = int(request_id.encode('ascii'))
print >> fp, "request id", request_id
print >> fp, "request string", request_str
print >> fp, "request to", request_to
print >> fp, "request from", request_from
print >> fp, "request fb id", request.session['fb_id']
try:
m_to = Member.objects.get(fb_id=request_to)
except:
# need to make member
m_to = Member(fb_id=request_to)
try:
m_from = Member.objects.get(fb_id=request_from)
except:
# need to make member
m_from = Member(fb_id=request_from)
# name is set
gamename = "%s_%s_%s" % ( request_from, request_to, time.asctime(time.gmtime()) )
r = Room(name=gamename)
r.fb_request_id = request_id
r.save()
g = Game(room=r)
# game name and room name duplicated
g.name = gamename
g.save()
p = Player(game=g,turn=0)
p.member = m_from
p.save()
# TODO assumes two player game - generalize
p = Player(game=g,turn=1)
p.member = m_to
p.save()
#return HttpResponseRedirect('requestpage.html')
return HttpResponseRedirect( reverse('lupalo.views.lupalo') ) # Redirect after POST
def createRoom(request):
if request.method == "POST":
req = json.loads(request.body)
master = Trainer.objects.get(name=req['trainer'])
new_room = Room(master=master)
new_room.save()
response_data = {}
response_data['msg'] = 'success'
response_data['channel'] = new_room.id
return HttpResponse(json.dumps(response_data), content_type="application/json")
def create_room(request):
if request.method == "POST":
form = RoomModelForm(request.POST)
if form.is_valid():
data = form.cleaned_data
room_inst = Room(**data)
room_inst.save()
form = RoomModelForm()
return render(request, "app1/create_room.html", {"form": form})
def create_room(request, extra_context={}):
"""
View for creating a room. Uses a clever combination of PollForm, RoomForm and ChoiceFormSet to achieve
3-way model creation:
- PollForm allows the user to specify the question
- ChoiceFormSet allows the user to specify an arbitrary number of "choices" to go with the question
(each one represented by its own DB object)
- RoomForm gives more advanced "tweaks" for the room, for example:
- period length (how long each period lasts, default is 30)
- join threshold (the amount of time that a room is in lock mode before a poll begins)
"""
if request.method == "POST":
# if the user has submitted the form, get the data from all three
poll_form = PollForm(request.POST, request.FILES)
choice_formset = ChoiceFormSet(request.POST, request.FILES)
room_form = RoomForm(request.POST, request.FILES)
if poll_form.is_valid() and choice_formset.is_valid() and room_form.is_valid():
# if all 3 forms are valid, create a new question object and save it
q = Question(text=poll_form.cleaned_data['question'])
q.save()
# create a new poll object that points to the question, and save it
p = Poll(question=q)
p.save()
# for every choice the user has inputted
for form in choice_formset.forms:
# create a new choice object, and point it at the question created earlier
c = Choice(question=q, text=form.cleaned_data['choice'])
c.save()
# finally, create the room itself, pointing to the question object, with the creator of the
# currently logged in user, and the period length & join threshold as specified in the form
# data.
r = Room(question=q, opened_by=request.user, controller=request.user,
period_length=room_form.cleaned_data['period_length'],
join_threshold=room_form.cleaned_data['join_threshold'])
r.save()
# redirect the user to their newly created room
return HttpResponseRedirect(r.get_absolute_url())
else:
# if the user has not submitted the form (i.e. wishes to fill the form in)
# then initialise the 3 forms with no data
poll_form = PollForm()
choice_formset = ChoiceFormSet()
room_form = RoomForm()
# put the forms into a context dictionary (and update that with any extra context we have been given)
data = {'poll_form': poll_form, 'choice_formset': choice_formset, 'room_form': room_form}
data.update(extra_context)
# render the page
return render_to_response('rooms/room_form.html', data, context_instance=RequestContext(request))
def submitRoom(request):
if request.method == "POST":
f = RoomForm(request.POST)
if f.is_valid():
newRoom = Room(name=request.POST['name'], info=request.POST['info'])
newRoom.save()
return HttpResponseRedirect(reverse('juakstore:roomDetail', args=(newRoom.id,)))
else:
return render(request, 'juakstore/room_add.html', {'form' : f})
else:
return HttpResponseRedirect(reverse('juakstore:roomCreate'))
def makerobogame(request):
fb_id = ROBOT1
request.session['fb_id'] = fb_id
# make robot player 1
try:
m_from = Member.objects.get( fb_id=ROBOT1 )
except Member.DoesNotExist:
m_from = Member(fb_id=ROBOT1)
m_from.user_name = 'Robo1'
m_from.fb_first_name = 'Robo1'
m_from.fb_last_name = 'Robo1'
m_from.save()
# make robot player 2
try:
m_to = Member.objects.get( fb_id=ROBOT2 )
except Member.DoesNotExist:
m_to = Member(fb_id=ROBOT2)
m_to.user_name = 'Robo2'
m_to.fb_first_name = 'Robo2'
m_to.fb_last_name = 'Robo2'
m_to.save()
# name is set
request_from = 'Robo1'
request_to = 'Robo2'
gamename = "%s_%s_%s" % ( request_from, request_to, time.asctime(time.gmtime()) )
r = Room(name=gamename)
r.fb_request_id = ROBOREQUEST
r.save()
g = Game(room=r)
# game name and room name duplicated
g.name = gamename
g.save()
p = Player(member=m_from) # player in game, link to member
p.game=g # game
p.turn=0 # static order of player in game
p.save()
request.session['player_id'] = p.turn
# TODO assumes two player game - generalize
p = Player( member = m_to )
p.game=g
p.turn=1
p.save()
return HttpResponse( simplejson.dumps( { "gamename": gamename } ), mimetype='application/javascript' )
def optionnal_room(sender, **kwargs):
reservation = kwargs.pop('instance')
if not isinstance(reservation, Reservation):
return True
if not reservation.room:
try:
room = Room._default_manager.get(name='default')
except Room.DoesNotExist:
room = Room(name='default', slug='default')
room.save()
reservation.room = room
return True
def optionnal_room(sender, **kwargs):
reservation = kwargs.pop('instance')
if not isinstance(reservation, Reservation):
return True
if not reservation.room:
try:
room = Room._default_manager.get(name='default')
except Room.DoesNotExist:
room = Room(name='default', slug='default')
room.save()
reservation.room = room
return True
def assign_room(request):
if request.POST:
user = request.POST['user']
rn = request.POST['rno']
sd = request.POST['sd']
ed = request.POST['ed']
r = Room(user_id=user,
r_id=uuid.uuid4(),
room_no=rn,
start_date=sd,
end_date=ed,
available=False)
r.save()
return render_to_response('roomcreatesuccess.html')
def test_get_messages(self, *args, **kwargs):
username, password = self.username, self.userpwd
# login user
client = Client()
client.login(username=username, password=password)
# creates a room
room = Room()
room.save()
# message queue empty: check last_message_id
response = client.get('/chat/get_latest_msg_id/?room_id=%d' % room.id)
json_response = json.loads(response.content)
last_msg_id = json_response['id']
self.assertEquals(last_msg_id, -1)
# posts a message
post_response = client.post('/chat/send_message/', {
'room_id': room.pk,
'message': 'ABCD'
},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEquals(post_response.status_code, 200)
json_response = json.loads(post_response.content)
timestamp = json_response['timestamp']
# gets list of messages
response = client.get(
'/chat/get_messages/?room_id=%d&latest_message_id=%d' %
(room.id, last_msg_id),
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEquals(response.status_code, 200)
json_response = json.loads(response.content)
expected_json = [{
u'message_id': 1,
u'username': u'john',
u'date': timestamp,
u'content': u'ABCD',
}]
self.assertEquals(expected_json, json_response)
# check last_message_id
response = client.get('/chat/get_latest_msg_id/?room_id=%d' % room.id)
json_response = json.loads(response.content)
last_msg_id = json_response['id']
self.assertEquals(last_msg_id, 1)
def test_get_messages(self, *args, **kwargs):
username, password = self.username, self.userpwd
# login user
client = Client()
client.login(username=username, password=password)
# creates a room
room = Room()
room.save()
# message queue empty: check last_message_id
response = client.get('/chat/get_latest_msg_id/?room_id=%d' % room.id)
json_response = json.loads(response.content)
last_msg_id = json_response['id']
self.assertEquals(last_msg_id, -1)
# posts a message
post_response = client.post('/chat/send_message/',
{'room_id': room.pk,
'message': 'ABCD'},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEquals(post_response.status_code, 200)
json_response = json.loads(post_response.content)
timestamp = json_response['timestamp']
# gets list of messages
response = client.get(
'/chat/get_messages/?room_id=%d&latest_message_id=%d' % (
room.id, last_msg_id),
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEquals(response.status_code, 200)
json_response = json.loads(response.content)
expected_json = [{u'message_id': 1,
u'username': u'john',
u'date': timestamp,
u'content': u'ABCD', }]
self.assertEquals(expected_json, json_response)
# check last_message_id
response = client.get('/chat/get_latest_msg_id/?room_id=%d' % room.id)
json_response = json.loads(response.content)
last_msg_id = json_response['id']
self.assertEquals(last_msg_id, 1)
def test_anonymous_access(self):
anon_room = Room(
allow_anonymous_access=True,
name="Anonymous Room",
slug="anonymous-room")
login_req_room = Room(
allow_anonymous_access=False,
name="Login required room",
slug="login-required-room")
anon_room.save()
login_req_room.save()
client = Client()
response = client.get(login_req_room.get_absolute_url())
# a login view may not have been implemented, so assertRedirects fails
self.assertEquals(response.status_code, 302)
url = response['Location']
expected_url = get_login_url(login_req_room.get_absolute_url())
e_scheme, e_netloc, e_path, e_query, e_fragment = urlparse.urlsplit(
expected_url)
if not (e_scheme or e_netloc):
expected_url = urlparse.urlunsplit(('http', 'testserver', e_path,
e_query, e_fragment))
self.assertEquals(url, expected_url)
response = client.get(
anon_room.get_absolute_url(),
follow=True)
# assert redirect
self.assertRedirects(
response,
'http://testserver/chat/setguestname/?room_slug=anonymous-room')
# post guestname
guestname_posted = client.post(
response.redirect_chain[0][0],
{'guest_name': 'guest',
'room_slug': 'anonymous-room'},
follow=True)
self.assertRedirects(
guestname_posted,
anon_room.get_absolute_url()
)
def room_new():
room = Room()
if request.method == 'POST':
form = RoomForm(request.form, obj=room)
if form.validate():
try:
form.populate_obj(room)
validate_room(room)
room.save()
flash('Yes, quarto cadastrado com sucesso.', 'success')
return redirect(url_for('rooms.room_index'))
except IntegrityError:
flash('Oops, este quarto já foi cadastrado.', 'warning')
except AttributeError as e:
flash(str(e), 'warning')
else:
form = RoomForm(obj=room)
return render_template('rooms/new.html', form=form)
def add_room(room):
decks = []
current_numbers = []
for deckname in room['decks']:
deck = Deck.objects(Q(name=deckname)).first()
cards = deck.cards
random.shuffle(cards)
if len(cards) > 1:
decks.append(cards)
else:
l = []
l.append(cards)
decks.append(l)
current_numbers.append(0)
time = datetime.datetime.utcnow
new_room = Room(name=room['id'],
decks=decks,
current_numbers=current_numbers,
last_update=time)
new_room.save()
log.info('Created game room with id: ' + str(new_room['id']))
delete_old_rooms()
def reset(request):
Room.objects.all().delete()
r = Room(name='testroom')
r.save()
Game.objects.all().delete()
g = Game(name='testgame',room=r)
g.save()
Player.objects.all().delete()
p = Player.objects.all()
print "Total number of players: %d" % len(p)
Member.objects.all().delete()
print "Hello"
m = Member(user_name='Cliff')
m.save()
m = Member(user_name='Eve')
m.save()
return HttpResponseRedirect( reverse('lupalo.views.login') ) # Redirect after POST
def test_anonymous_access(self):
anon_room = Room(allow_anonymous_access=True,
name="Anonymous Room",
slug="anonymous-room")
login_req_room = Room(allow_anonymous_access=False,
name="Login required room",
slug="login-required-room")
anon_room.save()
login_req_room.save()
client = Client()
response = client.get(login_req_room.get_absolute_url())
# a login view may not have been implemented, so assertRedirects fails
self.assertEquals(response.status_code, 302)
url = response['Location']
expected_url = get_login_url(login_req_room.get_absolute_url())
e_scheme, e_netloc, e_path, e_query, e_fragment = urlparse.urlsplit(
expected_url)
if not (e_scheme or e_netloc):
expected_url = urlparse.urlunsplit(
('http', 'testserver', e_path, e_query, e_fragment))
self.assertEquals(url, expected_url)
response = client.get(anon_room.get_absolute_url(), follow=True)
# assert redirect
self.assertRedirects(
response,
'http://testserver/chat/setguestname/?room_slug=anonymous-room')
# post guestname
guestname_posted = client.post(response.redirect_chain[0][0], {
'guest_name': 'guest',
'room_slug': 'anonymous-room'
},
follow=True)
self.assertRedirects(guestname_posted, anon_room.get_absolute_url())
def test_chatview_attributes(self):
"""Asserts new items are added to ChatView instance
when a new room is created, and these items are removed
when a room is deleted
"""
new_room = Room(name="New room", slug="new-room")
new_room.save()
chatview = ChatView()
self.assertIn(new_room.id, chatview.new_message_events)
self.assertIn(new_room.id, chatview.messages)
self.assertIn(new_room.id, chatview.connected_users)
self.assertIn(new_room.id, chatview.counters)
self.assertIn(new_room.id, chatview.new_connected_user_event)
# works without a post_delete handler: somewhere the Django models
# collector gets rid of these items (awkward, not documented feat)
new_room.delete()
self.assertNotIn(new_room.id, chatview.new_message_events)
self.assertNotIn(new_room.id, chatview.messages)
self.assertNotIn(new_room.id, chatview.connected_users)
self.assertNotIn(new_room.id, chatview.counters)
self.assertNotIn(new_room.id, chatview.new_connected_user_event)
def open_room(request):
roomid = request.REQUEST.get('id', '')
idurl = request.REQUEST.get('idurl', '')
name = request.REQUEST.get('name', contactsdb.get_correspondent_nickname(idurl))
if roomid:
try:
roomid = int(roomid)
except:
lg.exc()
return Http404('incorrect Room ID')
try:
ThisRoom = get_object_or_404(Room, id=roomid)
except:
ThisRoom = Room(id=roomid,
idurl=idurl,
name=name)
ThisRoom.save()
# myname = settings.getNickName() or my_id.getIDName()
RoomMember.objects.create_member(idurl=my_id.getLocalID(),
# name=nameurl.GetName(my_id.getLocalID()),
room=ThisRoom)
return HttpResponseRedirect('/chat/room/%d' % ThisRoom.id)
if idurl:
try:
ThisRoom = get_object_or_404(Room, idurl=idurl)
except:
ThisRoom = Room(idurl=idurl,
name=name)
ThisRoom.save()
RoomMember.objects.create_member(idurl=my_id.getLocalID(),
# name=nameurl.GetName(my_id.getLocalID()),
room=ThisRoom)
return HttpResponseRedirect('/chat/room/%d' % ThisRoom.id)
return Http404('need to provide a room info')
def create(request):
import random
alpha = (
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H",
"I",
"J",
"K",
"L",
"M",
"N",
"O",
"P",
"Q",
"R",
"S",
"T",
"U",
"V",
"W",
"X",
"Y",
"Z",
)
code = ''.join([random.choice(alpha) for _ in range(4)])
while isExists(code):
code = ''.join([random.choice(alpha) for _ in range(4)])
newRoom = Room(code=code)
newRoom.save()
return HttpResponse("Creating room. Code " + code)
def open_room(request):
roomid = request.REQUEST.get('id', '')
idurl = request.REQUEST.get('idurl', '')
name = request.REQUEST.get('name',
contactsdb.get_correspondent_nickname(idurl))
if roomid:
try:
roomid = int(roomid)
except:
lg.exc()
raise Http404('incorrect Room ID')
try:
ThisRoom = get_object_or_404(Room, id=roomid)
except:
ThisRoom = Room(id=roomid, idurl=idurl, name=name)
ThisRoom.save()
# myname = settings.getNickName() or my_id.getIDName()
RoomMember.objects.create_member(
idurl=my_id.getLocalID(),
# name=nameurl.GetName(my_id.getLocalID()),
room=ThisRoom)
return HttpResponseRedirect('/chat/room/%d' % ThisRoom.id)
if idurl:
try:
ThisRoom = get_object_or_404(Room, idurl=idurl)
except:
ThisRoom = Room(idurl=idurl, name=name)
ThisRoom.save()
RoomMember.objects.create_member(
idurl=my_id.getLocalID(),
# name=nameurl.GetName(my_id.getLocalID()),
room=ThisRoom)
return HttpResponseRedirect('/chat/room/%d' % ThisRoom.id)
raise Http404('need to provide a room info')
def test_chatview_attributes(self):
"""Asserts new items are added to ChatView instance
when a new room is created, and these items are removed
when a room is deleted
"""
new_room = Room(name="New room",
slug="new-room")
new_room.save()
chatview = ChatView()
self.assertIn(new_room.id, chatview.new_message_events)
self.assertIn(new_room.id, chatview.messages)
self.assertIn(new_room.id, chatview.connected_users)
self.assertIn(new_room.id, chatview.counters)
self.assertIn(new_room.id, chatview.new_connected_user_event)
# works without a post_delete handler: somewhere the Django models
# collector gets rid of these items (awkward, not documented feat)
new_room.delete()
self.assertNotIn(new_room.id, chatview.new_message_events)
self.assertNotIn(new_room.id, chatview.messages)
self.assertNotIn(new_room.id, chatview.connected_users)
self.assertNotIn(new_room.id, chatview.counters)
self.assertNotIn(new_room.id, chatview.new_connected_user_event)
rooms = {}
students = {}
parser = argparse.ArgumentParser()
parser.add_argument('students', type=str)
parser.add_argument('rooms', type=str)
parser.add_argument('serializer', type=str, help='Serializer type')
parser.add_argument('host', type=str, help='Database host')
parser.add_argument('user', type=str, help='Username')
parser.add_argument('password', type=str, help='User Password')
args = parser.parse_args()
config = {
'host': args.host,
'user': args.user,
'password': args.password,
}
Room.serializer = serializer_type[args.serializer]()
rooms = read_objects(args.rooms, Room)
students = read_objects(args.students, Student)
join(rooms, students)
Room.save(rooms.values())
with mysql.connector.connect(**config) as connection:
rooms_dao = RoomDAO(connection)
students_dao = StudentDAO(connection)
rooms_dao.insert(rooms)
students_dao.insert(students)
print(rooms_dao.rooms_list_with_student_count())
print(rooms_dao.top_5_rooms_with_min_avg_age_of_students())
print(rooms_dao.top_5_rooms_with_max_students_age_diff())
print(rooms_dao.rooms_with_males_and_females())
students_dao.create_index()
def handlefbrequestcallback(request):
fp = open( 'tmp.3.log', 'w' )
print >> fp, request
request_str = ( request.GET.get('request') )
request_to = ( request.GET.get('to') )
request_id = ( request.GET.get('id') )
request_from = request.session['fb_id']
print >> fp, "request id", request_id
print >> fp, "request string", request_str
print >> fp, "request to", request_to
print >> fp, "request from", request_from
print >> fp, "request fb id", request.session['fb_id']
instance = UserSocialAuth.objects.filter(provider='facebook',user=request.user.id).order_by('-id')[0]
graph = facebook.GraphAPI(instance.tokens["access_token"])
try:
profile = graph.get_object("me")
except:
logout(request)
return HttpResponseRedirect( reverse('lupalo.views.lupalo') ) # Redirect after POST
try:
m_to = Member.objects.get(fb_id=request_to)
except:
# need to make member
m_to = Member(fb_id=request_to)
# play against robot
if request_to == 'auto':
m_to.fb_first_name = 'auto'
m_to.fb_last_name = 'auto'
else:
profile = graph.get_object( str(request_to) )
m_to.fb_first_name = profile['first_name']
m_to.fb_last_name = profile['last_name']
m_to.save()
if m_to.fb_first_name == None or m_to.fb_last_name == None:
profile = graph.get_object( str(request_to) )
m_to.fb_first_name = profile['first_name']
m_to.fb_last_name = profile['last_name']
m_to.save()
try:
m_from = Member.objects.get(fb_id=request_from)
except:
# need to make member
m_from = Member(fb_id=request_from)
profile = graph.get_object( str(request_from) )
m_from.fb_first_name = profile['first_name']
m_from.fb_last_name = profile['last_name']
m_from.save()
if m_from.fb_first_name == None or m_from.fb_last_name == None:
profile = graph.get_object( str(request_from) )
m_from.fb_first_name = profile['first_name']
m_from.fb_last_name = profile['last_name']
m_from.save()
# name is set
gamename = "%s_%s_%s" % ( request_from, request_to, time.asctime(time.gmtime()) )
print >> fp, "gamename", gamename
r = Room(name=gamename)
r.fb_request_id = request_id
r.save()
g = Game(room=r)
# game name and room name duplicated
g.name = gamename
g.save()
p = Player(member=m_from)
p.game=g
p.turn=0
p.save()
# TODO assumes two player game - generalize
p = Player( member = m_to )
p.game=g
p.turn=1
p.save()
#return HttpResponseRedirect('requestpage.html')
return HttpResponseRedirect( reverse('lupalo.views.lupalo') ) # Redirect after POST
def create_room(request, extra_context={}):
"""
View for creating a room. Uses a clever combination of PollForm, RoomForm and ChoiceFormSet to achieve
3-way model creation:
- PollForm allows the user to specify the question
- ChoiceFormSet allows the user to specify an arbitrary number of "choices" to go with the question
(each one represented by its own DB object)
- RoomForm gives more advanced "tweaks" for the room, for example:
- period length (how long each period lasts, default is 30)
- join threshold (the amount of time that a room is in lock mode before a poll begins)
"""
if request.method == "POST":
# if the user has submitted the form, get the data from all three
poll_form = PollForm(request.POST, request.FILES)
choice_formset = ChoiceFormSet(request.POST, request.FILES)
room_form = RoomForm(request.POST, request.FILES)
if poll_form.is_valid() and choice_formset.is_valid(
) and room_form.is_valid():
# if all 3 forms are valid, create a new question object and save it
q = Question(text=poll_form.cleaned_data['question'])
q.save()
# create a new poll object that points to the question, and save it
p = Poll(question=q)
p.save()
# for every choice the user has inputted
for form in choice_formset.forms:
# create a new choice object, and point it at the question created earlier
c = Choice(question=q, text=form.cleaned_data['choice'])
c.save()
# finally, create the room itself, pointing to the question object, with the creator of the
# currently logged in user, and the period length & join threshold as specified in the form
# data.
r = Room(question=q,
opened_by=request.user,
controller=request.user,
period_length=room_form.cleaned_data['period_length'],
join_threshold=room_form.cleaned_data['join_threshold'])
r.save()
# redirect the user to their newly created room
return HttpResponseRedirect(r.get_absolute_url())
else:
# if the user has not submitted the form (i.e. wishes to fill the form in)
# then initialise the 3 forms with no data
poll_form = PollForm()
choice_formset = ChoiceFormSet()
room_form = RoomForm()
# put the forms into a context dictionary (and update that with any extra context we have been given)
data = {
'poll_form': poll_form,
'choice_formset': choice_formset,
'room_form': room_form
}
data.update(extra_context)
# render the page
return render_to_response('rooms/room_form.html',
data,
context_instance=RequestContext(request))
def loggedin(request,**kwargs):
fp = open( 'tmp.2.log', 'w' )
try:
request_ids = request.session['fbrequests']
print >> fp, request_ids
print >> fp, "====================================="
except:
pass
print >> fp, request.method
print >> fp, request.user.first_name
print >> fp, request.user.last_name
print >> fp, request.user.username
print >> fp, request.user.id
print >> fp, request.user
if SOCIALAUTH_ON:
print >> fp,'A',[ x for x in UserSocialAuth.objects.filter(user=request.user.id).all()]
print >> fp,'B',[ x for x in UserSocialAuth.objects.all()]
print >> fp,'C',[ x for x in UserSocialAuth.objects.filter(provider='facebook',user=request.user.id).order_by('-id')]
instance = UserSocialAuth.objects.filter(provider='facebook',user=request.user.id).order_by('-id')[0]
#instance = UserSocialAuth.objects.filter(provider='facebook').get(user=request.user.id).order_by('-id')[0]
print >> fp, instance
print >> fp, instance.tokens
graph = facebook.GraphAPI(instance.tokens["access_token"])
try:
profile = graph.get_object("me")
except:
logout(request)
return HttpResponseRedirect( reverse('lupalo.views.lupalo') ) # Redirect after POST
friends = graph.get_connections("me", "friends")
print >> fp, profile
print >> fp, profile['id']
fb_id = profile['id']
print >> fp, friends
else:
fb_id = ROBOT1
request.session['fb_id'] = fb_id
print >> fp, "fb_id", fb_id
#graph.put_object("me","apprequests",message="Lup",redirect_uri="http://www.lupalo.com/foo/login/facebook")
#graph.put_object("me","apprequests",to="100004397774234",message="Lup",redirect_uri="http://www.lupalo.com/foo/login/facebook")
# TODO check if member exists with the same fb id
try:
#m = Member.objects.get(user_name=request.user.id)
m = Member.objects.get( fb_id=fp_id )
except Member.DoesNotExist:
m = None
if m == None:
try:
m = Member.objects.get( fb_id=request.session['fb_id'] )
m.user_name = profile['name']
m.fb_first_name = profile['first_name']
m.fb_last_name = profile['last_name']
m.save()
except Member.DoesNotExist:
m = None
return HttpResponseRedirect( reverse('lupalo.views.lupalo') ) # Redirect after POST
#return HttpResponseRedirect(reverse('lupalo.views.requestpage'))
if True:
#if request.method == 'POST': # If the form has been submitted...
#form = ContactForm(request.POST) # A form bound to the POST data
#print >> fp, "validating"
#print >> fp, form.is_valid()
#print >> fp, form.errors
#if form.is_valid():
if True:
#user = form.cleaned_data['user']
#user = request.user.id
user = request.user.username
t = time.gmtime()
name = time.asctime(t)
gamename = time.asctime(t)
#gamename = form.cleaned_data['room']
#newgame = form.cleaned_data['newgame']
newgame = True
print >> fp, "New Game", newgame
if newgame == True:
#Room.objects.all().delete()
r = Room(name=name)
r.save()
Game.objects.all().delete()
g = Game(name=name,room=r)
g.save()
r = Room(name=gamename)
r.save()
g = Game(name=name,room=r)
g.save()
else:
r = Room(name=gamename)
g = Game(name=name,room=r)
m = Member.objects.get( fb_id=request.session['fb_id'] )
game = Game.objects.all()
#g = game[0]
request.session['game_id'] = g.id
# TODO get room id from game
#r = g.room
# TODO get player id from room
#players = Player.objects.get(game=g)
try:
players = get_list_or_404(Player, game=g)
except:
players = None
if players:
turn = len(players)
else:
turn = 0
p = Player(game=g,turn=turn)
p.member = m
p.save()
print >> fp, "Player turn:", p.turn
request.session['player_id'] = p.turn
return HttpResponseRedirect( reverse('lupalo.views.lupalo') ) # Redirect after POST
#return render(request, 'polls/login.html', {
# 'form': form,
#})
else:
form = ContactForm() # An unbound form
fp.close()
#m = Member.objects.get(user_name=request.POST['username'])
#request.session['member_id'] = m.id
return render(request, 'foyer.html', {
'form': form, 'user':request.user.first_name
})
def Room1(request):
p = Student.objects.filter(StudentID=request.user)
c = Course.objects.all()
for item in c:
temp = item.TimeRange.split('~')
i = int(temp[0])
j = int(temp[1])
for counter in range(i, j + 1):
if item.TXX.encode('utf-8') == '第1,2节':
form = Room(
Semester='2015秋季学期',
Week='第' + str(counter) + '周',
Date=item.Week,
District=item.District,
Num=item.Num,
ClassID=item.ClassID,
T12=True,
)
if not Room.objects.filter(Semester = '2015秋季学期',Week = '第'+ str(counter) +'周',\
Date = item.Week, District = item.District, Num = item.Num,\
ClassID = item.ClassID, T12 = True):
if Room.objects.filter(Semester = '2015秋季学期',Week = '第'+ str(counter) +'周',\
Date = item.Week, District = item.District, Num = item.Num,\
ClassID = item.ClassID, T12 = False):
dd = Room.objects.get(Semester = '2015秋季学期',Week = '第'+ str(counter) +'周',\
Date = item.Week, District = item.District, Num = item.Num,\
ClassID = item.ClassID, T12 = False)
dd.T12 = True
dd.save()
else:
form.save()
if item.TXX.encode('utf-8') == '第3,4节':
form = Room(
Semester='2015秋季学期',
Week='第' + str(counter) + '周',
Date=item.Week,
District=item.District,
Num=item.Num,
ClassID=item.ClassID,
T34=True,
)
if not Room.objects.filter(Semester = '2015秋季学期',Week = '第'+ str(counter) +'周',\
Date = item.Week, District = item.District, Num = item.Num,\
ClassID = item.ClassID, T34 = True):
if Room.objects.filter(Semester = '2015秋季学期',Week = '第'+ str(counter) +'周',\
Date = item.Week, District = item.District, Num = item.Num,\
ClassID = item.ClassID, T34 = False):
dd = Room.objects.get(Semester = '2015秋季学期',Week = '第'+ str(counter) +'周',\
Date = item.Week, District = item.District, Num = item.Num,\
ClassID = item.ClassID, T34 = False)
dd.T34 = True
dd.save()
else:
form.save()
if item.TXX.encode('utf-8') == '第5,6节':
form = Room(
Semester='2015秋季学期',
Week='第' + str(counter) + '周',
Date=item.Week,
District=item.District,
Num=item.Num,
ClassID=item.ClassID,
T56=True,
)
if not Room.objects.filter(Semester = '2015秋季学期',Week = '第'+ str(counter) +'周',\
Date = item.Week, District = item.District, Num = item.Num,\
ClassID = item.ClassID, T56 = True):
if Room.objects.filter(Semester = '2015秋季学期',Week = '第'+ str(counter) +'周',\
Date = item.Week, District = item.District, Num = item.Num,\
ClassID = item.ClassID, T56 = False):
dd = Room.objects.get(Semester = '2015秋季学期',Week = '第'+ str(counter) +'周',\
Date = item.Week, District = item.District, Num = item.Num,\
ClassID = item.ClassID, T56 = False)
dd.T56 = True
dd.save()
else:
form.save()
if item.TXX.encode('utf-8') == '第7,8节':
form = Room(
Semester='2015秋季学期',
Week='第' + str(counter) + '周',
Date=item.Week,
District=item.District,
Num=item.Num,
ClassID=item.ClassID,
T78=True,
)
if not Room.objects.filter(Semester = '2015秋季学期',Week = '第'+ str(counter) +'周',\
Date = item.Week, District = item.District, Num = item.Num,\
ClassID = item.ClassID, T78 = True):
if Room.objects.filter(Semester = '2015秋季学期',Week = '第'+ str(counter) +'周',\
Date = item.Week, District = item.District, Num = item.Num,\
ClassID = item.ClassID, T78 = False):
dd = Room.objects.get(Semester = '2015秋季学期',Week = '第'+ str(counter) +'周',\
Date = item.Week, District = item.District, Num = item.Num,\
ClassID = item.ClassID, T78 = False)
dd.T78 = True
dd.save()
else:
form.save()
if item.TXX.encode('utf-8') == '第9,10节':
form = Room(
Semester='2015秋季学期',
Week='第' + str(counter) + '周',
Date=item.Week,
District=item.District,
Num=item.Num,
ClassID=item.ClassID,
T910=True,
)
if not Room.objects.filter(Semester = '2015秋季学期',Week = '第'+ str(counter) +'周',\
Date = item.Week, District = item.District, Num = item.Num,\
ClassID = item.ClassID, T910 = True):
if Room.objects.filter(Semester = '2015秋季学期',Week = '第'+ str(counter) +'周',\
Date = item.Week, District = item.District, Num = item.Num,\
ClassID = item.ClassID, T910 = False):
dd = Room.objects.get(Semester = '2015秋季学期',Week = '第'+ str(counter) +'周',\
Date = item.Week, District = item.District, Num = item.Num,\
ClassID = item.ClassID, T910 = False)
dd.T910 = True
dd.save()
else:
form.save()
ob = Room.objects.all()
if request.POST:
obj = request.POST
ob = ob.filter(Semester=obj['Semester'],Week=obj['ZhouCi'],\
Date=obj['XingQi'],District=obj['District'],Num=obj['LouYu'])
return render_to_response('room1.html',{'p': p,'ob': ob,'S':obj['Semester'],\
'ZC':obj['ZhouCi'],\
'DA':obj['XingQi'],'Dis':obj['District'],\
'LY':obj['LouYu']})
else:
return render_to_response('room1.html', {'p': p})
def test_capacity(self):
p = Room(name='a', capacity=5)
p.save()
self.assertEqual(Room.objects.count(), 4)
p.delete()
self.assertEqual(Room.objects.count(), 3)
