def create_board(request):
bingo_board = _get_user_bingo_board(request)
game = bingo_board.game if bingo_board is not None else None
user = request.user
if bingo_board:
Game.objects.filter(id=bingo_board.game.id).update(
last_used=times.now())
return redirect(reverse(bingo, kwargs={
'board_id': bingo_board.board_id}))
elif request.POST:
create_form = CreateForm(
request.POST,
prefix="create",
game=game)
if create_form.is_valid():
with transaction.atomic():
ip = request.META['REMOTE_ADDR']
password = create_form.cleaned_data.get('password')
game_description = create_form.cleaned_data.get(
'description', '')
game = get_game(
site=get_current_site(request),
description=game_description,
create=True)
Game.objects.filter(id=game.id).update(
last_used=times.now())
# if the user is logged in, associate the board with
# the user, and ignore the password
# (so no other user can claim the board)
user = user if user.is_authenticated() else None
if user:
password = None
bingo_board = BingoBoard(
game=game, user=user, ip=ip, password=password)
bingo_board.save()
if USE_SSE:
_publish_num_users(game.site.id, game.num_users(),
game.num_active_users())
return redirect(reverse(bingo, kwargs={
'board_id': bingo_board.board_id}))
else:
reclaim_form = ReclaimForm(prefix="reclaim")
return render(
request,
"bingo/reclaim_board.html",
{
'reclaim_form': reclaim_form,
'create_form': create_form,
}
)
else:
return redirect(reverse(main))
def create_project(request):
if request.method == "POST":
form = CreateForm(request.POST)
if form.is_valid():
name = form.cleaned_data["project_name"]
lat_lng = form.cleaned_data["location"]
pnt = Point(lat_lng["lng"], lat_lng["lat"])
model_proj = Project.objects.create(name=name, starting_point=pnt, owner=request.user)
return HttpResponseRedirect('/project/%s/' % model_proj.id)
else:
form = CreateForm()
return render_to_response('create_project.html', {"form": form, "user": request.user}, context_instance=RequestContext(request))
def create_board(request):
bingo_board = _get_user_bingo_board(request)
game = bingo_board.game if bingo_board is not None else None
user = request.user
if bingo_board:
Game.objects.filter(id=bingo_board.game.id).update(
last_used=times.now())
return redirect(
reverse(bingo, kwargs={'board_id': bingo_board.board_id}))
elif request.POST:
create_form = CreateForm(request.POST, prefix="create", game=game)
if create_form.is_valid():
with transaction.atomic():
ip = request.META['REMOTE_ADDR']
password = create_form.cleaned_data.get('password')
game_description = create_form.cleaned_data.get(
'description', '')
game = get_game(site=get_current_site(request),
description=game_description,
create=True)
Game.objects.filter(id=game.id).update(last_used=times.now())
# if the user is logged in, associate the board with
# the user, and ignore the password
# (so no other user can claim the board)
user = user if user.is_authenticated() else None
if user:
password = None
bingo_board = BingoBoard(game=game,
user=user,
ip=ip,
password=password)
bingo_board.save()
if USE_SSE:
_publish_num_users(game.site.id, game.num_users(),
game.num_active_users())
return redirect(
reverse(bingo, kwargs={'board_id': bingo_board.board_id}))
else:
reclaim_form = ReclaimForm(prefix="reclaim")
return render(request, "bingo/reclaim_board.html", {
'reclaim_form': reclaim_form,
'create_form': create_form,
})
else:
return redirect(reverse(main))
def Contact_Create(request):
if request.POST:
form = CreateForm(request.POST)
if form.is_valid():
a = form.save()
messages.add_message(request, messages.SUCCESS, "You Data was added")
return HttpResponseRedirect('/users/all')
else:
form = CreateForm()
args = {}
args.update(csrf(request))
args['form'] = form
return render_to_response('create_list.html', args)
def post(self, request):
create_form = CreateForm(request.POST)
if not create_form.is_valid():
msg = 'Please fill the form correctly and try again!'
context = {'form': create_form, 'msg': msg, 'color': 'yellow'}
return render(request, 'users/new.html', context)
else:
if not (create_form.cleaned_data['password1']
and create_form.cleaned_data['password2'] and
(create_form.cleaned_data['password2']
== create_form.cleaned_data['password1'])):
context = {
'form': create_form,
'msg': "Password fields do not match!",
'color': 'yellow'
}
return render(request, 'users/new.html', context)
pre_saved_user = create_form.save(commit=False)
pre_saved_user.set_password(create_form.cleaned_data['password2'])
pre_saved_user.save()
new_wallet = Wallet.objects.create(user=pre_saved_user)
new_wallet.save()
pre_saved_user.wallet_address = new_wallet.wallet_address
pre_saved_user.save()
request.session.flush()
return redirect('/users/login/')
def create(request, tid):
template = get_object_or_404(Template, id=tid)
fields = template.fields.all()
form = CreateForm()
if request.method == "POST":
form = CreateForm(request.POST)
if form.is_valid():
graph = form.save(commit=False)
graph.template = template
graph.owner = Member.objects.get(user=request.user)
graph.save()
for field in fields:
onto = request.POST.get(field.fname, "")
mapping = Mapping.objects.create(field=field, onto=onto)
graph.mappings.add(mapping)
graph.save()
return HttpResponseRedirect("/graph/result/%d" % graph.id)
return render(request, "create_graph.html", {"form": form, "fields": fields})
def create(request, tid):
template = get_object_or_404(Template, id=tid)
fields = template.fields.all()
form = CreateForm()
if request.method == 'POST':
form = CreateForm(request.POST)
if form.is_valid():
graph = form.save(commit=False)
graph.template = template
graph.owner = Member.objects.get(user=request.user)
graph.save()
for field in fields:
onto = request.POST.get(field.fname, '')
mapping = Mapping.objects.create(field=field, onto=onto)
graph.mappings.add(mapping)
graph.save()
return HttpResponseRedirect('/graph/result/%d' % graph.id)
return render(request, 'create_graph.html', {'form': form, 'fields': fields})
def post(self, request):
userinstance = stories(author=request.user)
form = CreateForm(
request.POST or None,
request.FILES,
instance=userinstance,
)
if form.is_valid():
form.save(commit=True)
title = form.cleaned_data['title']
'''description = form.cleaned_data['description']
content = form.cleaned_data['content']'''
send_mail(
subject="blog created!!",
message="congrats your post: " + title +
" has been published successfully",
from_email="*****@*****.**",
recipient_list=[request.user.email],
fail_silently=False,
auth_user=settings.EMAIL_HOST_USER,
auth_password=settings.EMAIL_HOST_PASSWORD,
)
return redirect('/stories/')
def post(self, request):
if not request.user.is_authenticated():
return render(request, 'unauthorised.html')
form = CreateForm(request.POST)
if form.is_valid():
this = form.cleaned_data
q_con = Contest.objects.filter(code=this.get('contest'))
q_user = User.objects.filter(username=this.get('to'))
if len(q_con) == 0:
return render(
request, 'create_challenge.html', {
'form':
form,
'error':
'Contest Code is incorrect,Please make sure the contest is still active'
})
if len(q_user) == 0:
return render(
request, 'create_challenge.html', {
'form': CreateForm(),
'error': 'No User with that username found.'
})
try:
con = q_con[0]
ch = Challenge.objects.create(frm=request.user.username,
to=this.get('to'),
contest=con.code,
expire=con.end,
time=datetime.now())
except (InternalError, IntegrityError):
return render(
request, 'create_challenge.html', {
'form': form,
'error': 'Internal Server Error 500, Please try again.'
})
#Create a New Notification
try:
notif = Notification.objects.create(
user=this.get('to'),
title='You have been challenged by ' +
request.user.username)
except (InternalError):
return render(
request, 'create_challenge.html', {
'form': form,
'error': 'Internal Server Error 500, Please try again.'
})
return render(request, 'created_challenge.html', {
'challenge': ch,
'contest': con
})
else:
return render(request, 'create_challenge.html', {
'form': CreateForm(),
'error': 'Invalid Form Data'
})
def create(request):
if request.method == 'POST':
form = CreateForm(request.POST)
if form.is_valid() :
startYear = form.cleaned_data['startYear']
startMonth = form.cleaned_data['startMonth']
startDay = form.cleaned_data['startDay']
startHour = form.cleaned_data['startHour']
startMinute = form.cleaned_data['startMinute']
toursNumber = form.cleaned_data['toursNumber']
lenWriteWords = form.cleaned_data['lenWriteWords']
lenWatchResult = form.cleaned_data['lenWatchResult']
lenChecking = form.cleaned_data['lenChecking']
lenWaitWords = form.cleaned_data['lenWaitWords']
lenCountStatisticsWords = 10
lenCountResult = 10
lenGame = lenWriteWords + lenWaitWords + lenCountStatisticsWords + lenChecking + lenCountResult + lenWatchResult
info = form.cleaned_data['info']
start = datetime.datetime(startYear, startMonth, startDay, startHour, startMinute)
newGame = DataGame(start = start, toursNumber = toursNumber, lenWriteWords = lenWriteWords, lenWatchResult = lenWatchResult, lenChecking = lenChecking, lenWaitWords = lenWaitWords)
newGame.save()
delta = datetime.timedelta(minutes=info)
action = Tasks(taskTime = start - delta, action = "info", gameID = newGame, tourID = -1)
action.save()
listToChain = []
for i in range(toursNumber):
delta = datetime.timedelta(seconds = i*(lenGame))
countdownTime = start + delta - datetime.datetime.today() - datetime.timedelta(seconds = 1)
task_choice_titles.apply_async((Tasks(gameID = newGame, tourID = i),), countdown = countdownTime.seconds)
#listToChain.append(task_choice_titles.subtask((Tasks(gameID = newGame, tourID = i),), countdown = countdownTime.seconds))
action = Tasks(taskTime = start + delta, action = "tour", gameID = newGame, tourID = i)
action.save()
delta = datetime.timedelta(seconds = i*(lenGame) + lenWriteWords)
action = Tasks(taskTime = start + delta, action = "sendWords", gameID = newGame, tourID = i)
action.save()
delta = datetime.timedelta(seconds = i*(lenGame) + lenWriteWords + lenWaitWords)
countdownTime = start + delta - datetime.datetime.today()
task_count_statistics_words.apply_async((Tasks(gameID = newGame, tourID = i),), countdown = countdownTime.seconds)
action = Tasks(taskTime = start + delta, action = "countStatisticsWords", gameID = newGame, tourID = i)
action.save()
delta = datetime.timedelta(seconds = i*(lenGame) + lenWriteWords + lenWaitWords + lenCountStatisticsWords)
action = Tasks(taskTime = start + delta, action = "check", gameID = newGame, tourID = i)
action.save()
delta = datetime.timedelta(seconds = i*(lenGame) + lenWriteWords + lenWaitWords + lenCountStatisticsWords + lenChecking)
countdownTime = start + delta - datetime.datetime.today()
task_count_result.apply_async((Tasks(gameID = newGame, tourID = i),), countdown = countdownTime.seconds)
action = Tasks(taskTime = start + delta, action = "countResult", gameID = newGame, tourID = i)
action.save()
delta = datetime.timedelta(seconds = i*(lenGame) + lenWriteWords + lenWaitWords + lenCountStatisticsWords +lenChecking + lenCountResult)
action = Tasks(taskTime = start + delta, action = "watchResult", gameID = newGame, tourID = i)
action.save()
delta = datetime.timedelta(seconds = toursNumber*(lenGame))
countdownTime = start + delta - datetime.datetime.today() - datetime.timedelta(seconds = 1)
task_count_final_result.apply_async((Tasks(gameID = newGame, tourID = toursNumber),), countdown = countdownTime.seconds)
action = Tasks(taskTime = start + delta, action = "endGame", gameID = newGame, tourID = toursNumber)
action.save()
return render_to_response('ok_create.html', locals(), context_instance=RequestContext(request))
error = u"Не удалось создать игру. Произошла ошибка."
return render_to_response('error.html', locals(), context_instance=RequestContext(request))
