def app_register(request):
username = request.user.get_username()
if request.method == "POST":
try:
user = User.objects.get(username=username)
app_id = request.POST["app-id"].lower()
app_name = request.POST["app-name"]
app_token = str(uuid.uuid4())
app = App(
app_id=app_id, app_name=app_name,
user=user, app_token=app_token)
app.save()
try:
hashed_password = hashlib.sha1(app_token).hexdigest()
DataHubManager.create_user(
username=app_id, password=hashed_password, create_db=False)
except Exception as e:
app.delete()
raise e
return HttpResponseRedirect('/developer/apps')
except Exception as e:
c = {
'login': username,
'errors': [str(e)]}
c.update(csrf(request))
return render_to_response('app-create.html', c)
else:
c = {'login': username}
c.update(csrf(request))
return render_to_response('app-create.html', c)
def registerUser(request):
from movie_website.users.forms import RegisterUserForm
if request.user.is_authenticated():
return render_to_response('users/register.html', {'has_account': "Posiadasz już konto"}, context_instance=RequestContext(request))
if request.method == 'POST':
form = RegisterUserForm(request.POST)
if form.is_valid():
form.save()
username = form.cleaned_data['username']
password = form.cleaned_data['password2']
user = authenticate(username=username, password=password)
login(request, user)
return HttpResponseRedirect('/index.html')
else:
form = RegisterUserForm(request.POST)
c = {'form': form, 'reg_failed': "Wprowadzono błędne dane"}
c.update(csrf(request))
return render_to_response('users/register.html', c, context_instance=RequestContext(request))
else:
form = RegisterUserForm(request.POST)
c = {'form': form}
c.update(csrf(request))
return render_to_response('users/register.html', c)
def add_product(request, reseller_id):
params = {}
params['company_id'] = reseller_id
if request.method == 'GET':
form = FuelForm()
form.fields['producer'].queryset = Company.objects.all().filter(region='Generico') # load in queryset only geographical areas
params["form"] = form
params.update(csrf(request))
return render_to_response('it/users/add_product.html', params,
context_instance=RequestContext(request))
if request.method == 'POST':
form = FuelForm(request.POST)
if form.is_valid():
form.save()
return redirect('it.users.auth.main_profile')
else:
params = {'message': '<strong>Campi mancanti. Per favore completa correttamente il form.</strong>'}
form = FuelForm()
params["form"] = form
params.update(csrf(request))
return render_to_response('it/users/add_product.html', params,
context_instance=RequestContext(request))
def changepwd(request):
base = base_ctx(request=request)
if not request.user.is_authenticated():
base.update(csrf(request))
return render_to_response("login.html", base)
base.update({"user": request.user.username})
if not ("old" in request.POST and "new" in request.POST and "newre" in request.POST):
base.update(csrf(request))
return render_to_response("changepwd.html", base)
if not request.user.check_password(request.POST["old"]):
base["messages"].append(
Message("The old password didn't match. Your password was not changed.", type=Message.ERROR)
)
base.update(csrf(request))
return render_to_response("changepwd.html", base)
if request.POST["new"] != request.POST["newre"]:
base["messages"].append(
Message("The new passwords didn't match. Your password was not changed.", type=Message.ERROR)
)
base.update(csrf(request))
return render_to_response("changepwd.html", base)
request.user.set_password(request.POST["new"])
base["messages"].append(
Message("The password for " + request.user.username + " was successfully changed.", type=Message.SUCCESS)
)
request.user.save()
return render_to_response("changepwd.html", base)
def add_transport(request, reseller_id):
if request.method == 'GET':
params = {}
params['company_id'] = reseller_id
form = AddTransportForm()
form.fields['courier'].queryset = Company.objects.all().filter(products_group__category=3)
params["form"] = form
params.update(csrf(request))
return render_to_response('it/users/add_transport.html', params,
context_instance=RequestContext(request))
if request.method == 'POST':
s = get_object_or_404(Company, id=reseller_id)
form = AddTransportForm(request.POST, instance = s)
if form.is_valid():
form.save()
return redirect('it.users.auth.main_profile')
else:
params = {'message': '<strong>Campi mancanti. Per favore completa correttamente il form.</strong>'}
form = AddTransportForm()
params["form"] = form
params.update(csrf(request))
return render_to_response('it/users/add_transport.html', params,
context_instance=RequestContext(request))
def others_edit_view(request, model_name, **kwargs):
perm = getattr(get_user_profile(request.user), model_name + '_permission') or request.user.is_superuser
form_class = crispy_form_factory(model=model_name_dict[model_name],
widgets=widgets_dict[model_name],
disabled=[],
exclude=[],
)
if request.method == 'GET':
edit_form = form_class(instance=get_object_or_404(model_name_dict[model_name], id=kwargs['id']))
request_context = csrf(request)
form_html = render_crispy_form(edit_form, context=request_context)
return HttpResponse(json.dumps({'form_html': form_html}))
if request.method == 'POST':
if perm:
edit_form = form_class(request.POST, instance=get_object_or_404(model_name_dict[model_name],
id=kwargs['id']))
if edit_form.is_valid():
edit_form.save()
return HttpResponse(json.dumps({'success': True}))
else:
request_context = csrf(request)
form_html = render_crispy_form(edit_form, context=request_context)
return HttpResponse(json.dumps({'success': False, 'permission': True, 'form_html': form_html}))
else:
return HttpResponse(json.dumps({'success': False, 'permission': False}))
def visionary_old(request):
c = {}
c.update(csrf(request))
#message = 'this is demo version. signup to be able to save changes.>>>>>'
message = ''
signedin = 0
if request.user.is_authenticated():
message = ''
args = {}
args.update(csrf(request))
args['form'] = RegisterForm()
state = 'empty'
#s, created=State.objects.get_or_create(user=request.user)
#state = s.state
#state = state.replace ("\\", "\\\\")
return render_to_response('visionary.html',
{'message':message,
'full_name':request.user.username,
'signedin':signedin,
'form':args['form'],
'state': state,},
context_instance=RequestContext(request))
def edit_view(request, model_name, **kwargs):
objs_and_perm = get_objs_and_perm(request.user, **kwargs)
higher_model_name = higher_model_name_dict[model_name]
if higher_model_name is None:
disabled = []
else:
disabled = [higher_model_name]
form_class = crispy_form_factory(model=model_name_dict[model_name],
widgets=widgets_dict[model_name],
disabled=disabled,
exclude=[],
)
if request.method == 'GET':
edit_form = form_class(instance=objs_and_perm[model_name])
request_context = csrf(request)
form_html = render_crispy_form(edit_form, context=request_context)
return HttpResponse(json.dumps({'form_html': form_html}))
if request.method == 'POST':
if objs_and_perm['perm']:
POST = request.POST.copy()
if higher_model_name is not None:
POST[higher_model_name] = objs_and_perm.get(higher_model_name).id
edit_form = form_class(POST, instance=objs_and_perm[model_name])
if edit_form.is_valid():
edit_form.save()
return HttpResponse(json.dumps({'success': True}))
else:
request_context = csrf(request)
form_html = render_crispy_form(edit_form, context=request_context)
return HttpResponse(json.dumps({'success': False, 'permission': True, 'form_html': form_html}))
else:
return HttpResponse(json.dumps({'success': False, 'permission': False}))
def others_add_view(request, model_name):
# this view is for non-leveled model
perm = getattr(get_user_profile(request.user), model_name + '_permission') or request.user.is_superuser
form_class = crispy_form_factory(model=model_name_dict[model_name],
widgets=widgets_dict[model_name],
disabled=[],
exclude=[],
)
if request.method == 'GET':
add_form = form_class()
request_context = csrf(request)
form_html = render_crispy_form(add_form, context=request_context)
return HttpResponse(json.dumps({'form_html': form_html}))
if request.method == 'POST':
if perm:
add_form = form_class(request.POST)
if add_form.is_valid():
add_form.save()
return HttpResponse(json.dumps({'success': True}))
else:
request_context = csrf(request)
form_html = render_crispy_form(add_form, context=request_context)
return HttpResponse(json.dumps({'success': False, 'permission': True, 'form_html': form_html}))
else:
return HttpResponse(json.dumps({'success': False, 'permission': False}))
def result(request):
if "member_id" in request.session:
if request.method == 'POST':
h_name = request.POST.get( 'hotel_name' )
result = Hotel.objects.filter(Q( hotel_name__icontains = h_name ))
in_date = request.POST.get('check_in')
out_date = request.POST.get('check_out')
now = datetime.now()
date_now = now.strftime("%Y-%m-%d")
# print date_now
# print in_date
# print out_date
if out_date < in_date:
return HttpResponseRedirect('/reserve/reservation1/')
if in_date < date_now:
return HttpResponseRedirect('/reserve/reservation1/')
a = datetime.strptime(in_date, '%Y-%m-%d')
b = datetime.strptime(out_date, '%Y-%m-%d')
days = (b-a).days
print days
context={}
context.update(csrf(request))
context['hotel'] = result
context['name'] = h_name
context['date_in'] = in_date
context['date_out'] = out_date
context['days'] = days
# context = {'hotel': result, 'name':h_name, 'date_in': in_date, 'date_out': out_date}
return render(request, 'reserve/result.html', context)
else:
c={}
c.update(csrf(request))
return render(request, 'reserve/reservation.html',c)
else:
return HttpResponseRedirect("/reserve/login/")
def notify(request):
group = request.user.groups.values_list('name')[0][0]
department_users = User.objects.filter(groups=Group.objects.get(name='Department'))
departments = [i.department for i in department_users]
notifications = Notification.objects.all()
c={'user':request.user,'departments':departments,'notifications':notifications}
c.update(csrf(request))
if request.method == 'POST':
class NotificationForm(ModelForm):
class Meta:
model = Notification
form = NotificationForm(request.POST)
if form.is_valid():
form.save()
print "done"
c.update({'group':group})
c.update({'departments':departments})
c.update({'errors':form.errors})
c.update(csrf(request))
Notification.objects.filter(lastdate__lt=datetime.utcnow().date()).delete()
return render_to_response("ExamCellHome.html",c)
else:
Notification.objects.filter(lastdate__lt=datetime.utcnow().date()).delete()
return render_to_response("ExamCellHome.html",c)
def post(self, request, *args, **kwargs):
content = {'page_title': "Customer Forget Password"}
form = ForgetPwdForm(request.POST)
if form.is_valid():
if form.cleaned_data['recaptcha'] == str(request.session['ReCaptcha']):
customer_list = customers.objects.filter(email = form.cleaned_data['email'])
if customer_list:
customer = customer_list[0]
success = True
mail_body = 'Your password is %s' %customer.pass_field
mail.send_mail(sender="*****@*****.**",
to=customer.email,
subject="Saltwaterfish.com: Password request", body=mail_body)
else:
(success, error_msg) = (False, "Email-id is not found in our records.")
else:
(success, error_msg) = (False, "Human verification is failed.")
else:
(success, error_msg) = (False, "Incomplete or invalid form data")
if success:
content = {'form': form, 'page_title': "Customer Forget Password"}
content['recaptcha'] = "https://chart.googleapis.com/chart?chst=d_text_outline&chld=FFCC33|16|h|FF0000|b|%s" %self.GetRecaptcha(request)
content['message'] = "Password has been sent to your EMail. Please check your inbox"
content.update(csrf(request))
return render_template(request,'login.htm', content)
else:
c = {'form': form, 'error_message': error_msg}
c['recaptcha'] = "https://chart.googleapis.com/chart?chst=d_text_outline&chld=FFCC33|16|h|FF0000|b|%s" %self.GetRecaptcha(request)
c.update(csrf(request))
return render_to_response('login.htm', c)
def add_photo(request):
c = {}
c.update(csrf(request))
form = PhotoForm()
c =({'form':form})
if request.method == 'POST':
#~ from ipdb import set_trace; set_trace()
form = PhotoForm(request.POST,request.FILES)
data= {
'photographe': request.POST['photographe'],\
'title': request.POST['title'],\
'format': request.POST['format'],\
'mode': request.POST['mode'],\
'date':request.POST['date'],\
'photo':request.FILES['photo'],\
'type_p': request.POST['type_p'],\
'lieux':request.POST['lieux'],\
'appareil':request.POST['appareil'],\
'sens': request.POST['sens'],\
'description':request.POST['description'],\
}
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('galerie'))
c.update({'form':form})
c.update(csrf(request))
return render_to_response('add_photo.html',c)
def execute(request):
list_of_records = dict()
if request.POST:
form_sql = ExecuteSqlForm(request.POST)
if form_sql.is_valid():
model = request.POST
print(request.POST)
global formDB
print("\n db path is ----> ")
print(formDB['dbpath'])
str = form_sql['query'].value()
list_of_records = execQuery(pathInLocal, str)
print("fetched records are \n")
print(list_of_records)
args = {}
args['form_sql'] = form_sql
args['table_records'] = json.dumps(list_of_records)
args.update(csrf(request))
return render_to_response('executestring.html', args)
else:
form_sql = ExecuteSqlForm()
args = {}
args['form_sql'] = form_sql
args.update(csrf(request))
return render_to_response('executestring.html', args)
def login(request):
if request.POST:
form_sys = SystemDetailsForm(request.POST)
if form_sys.is_valid():
global syst
syst = request.POST
connect_remote(ssh, syst) #persistent ssh connection call to func in system/ssh.py
form_db = DbDetailsForm()
args = {}
args['form_db'] = form_db
name = form_sys["hostname"].value()
args['user'] = name
args.update(csrf(request))
return render_to_response('searchdb.html', args)
else:
form_sys = SystemDetailsForm()
form_sys.fields['password'].widget = forms.PasswordInput()
args = {}
args['form_sys'] = form_sys
args.update(csrf(request))
return render_to_response('login.html', args)
def user_id(request, id):
voilet_list = CustomUser.objects.get(id=id)
content = {}
data_time = time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))
if request.method == 'POST':
if request.POST.getlist("password1") == request.POST.getlist("password2"):
uf = edit_user_from(request.POST)
if uf.is_valid():
# print "is ok"
zw = uf.save(commit=False)
zw.last_login = data_time
zw.date_joined = data_time
zw.id = id
zw.password = make_password(request.POST.getlist("password1"))
zw.save()
content["user_list"] = voilet_list
content.update(csrf(request))
return render_to_response('user/user_edit.html', content, context_instance=RequestContext(request))
# else:
# print "is over"
else:
content["data_time"] = data_time
content["user_list"] = voilet_list
content["department"] = department_Mode.objects.all()
content["jobs_name"] = manager_demo
content.update(csrf(request))
return render_to_response('user/user_page.html', content, context_instance=RequestContext(request))
def uploader(request, page_name):
if request.method == "POST":
form = CSVUploader(request.POST, request.FILES)
if form.is_valid():
form.save()
messages.success(request,
"CSV has been uploaded for processing",
extra_tags="success")
context = {"form": form}
else:
for errors_key, error_value in form.errors.iteritems():
messages.error(request,
"%s: %s" % (errors_key, error_value),
extra_tags="danger")
context = {"form": form}
context.update(csrf(request))
return render_to_response("custom_admin/upload.html", context,
context_instance=RequestContext(request))
else:
form = CSVUploader()
context = {"form": form}
context.update(csrf(request))
return render_to_response("custom_admin/upload.html", context,
context_instance=RequestContext(request))
def index(request):
yamlcanon = u""; # YAML in canonical form.
yamlerror = u"" # YAML error messages.
yamloriginal = u"" # The original text. Shown only for error messages.
yamlstate = STATE_GET # The state of the page.
ourmap = {"yamlstate": yamlstate, "yamlcanon": yamlcanon,
"yamlerror": yamlerror, "yamloriginal": yamloriginal};
if request.method == 'GET':
ourmap.update(csrf(request));
context = RequestContext(request, ourmap);
else: # POST request.
try:
ourtarget = request.POST.get("yamlarea");
composition = yaml.compose_all(ourtarget, Loader12);
yamlcanon = yaml.serialize_all(composition,
canonical=True, allow_unicode=True);
ourmap["yamlstate"] = STATE_POST_YES;
if len(yamlcanon) == 0:
ourmap["yamlcanon"] = COMMENTSTR
else:
ourmap["yamlcanon"] = yamlcanon;
# PKM2014 - AttributeErrors are now caught.
except (YAMLError, AttributeError) as e:
ourmap["yamlstate"] = STATE_POST_NO;
ourmap["yamlerror"] = e.__str__();
ourmap["yamloriginal"] = ourtarget;
ourmap.update(csrf(request));
context = RequestContext(request, ourmap);
return TemplateResponse(request, 'isityaml/isityaml.html', context=context)
def viewAssignments (request):
args = {}
args.update(csrf(request))
current_user = request.user
sc=Class.objects.filter(user=current_user)
if sc.count() == 1:
section = Class.objects.get(user=current_user)
else:
if sc.count () == 0:
return HttpResponseRedirect('/fileuploader/selectClass.html')
#return render_to_response('fileuploader/selectClass.html',args)
else:
htmlmessage = "Class Chosen Already - Contact Instructor or Create a New User Account"
args = {}
args.update (csrf (request))
args['message'] = htmlmessage
args['user'] = request.user
return render_to_response ('fileuploader/viewErrorMessage.html',args)
if request.user.is_superuser:
args['assignments'] = Assignment.objects.all()
else:
args['assignments'] = Assignment.objects.all().filter(hidden_status = 0,class_name=section.classnum)
#UTC TIME args['currenttime'] = datetime.datetime.now()
args['currenttime'] = timezone.now()
args['user'] = request.user
return render_to_response('fileuploader/viewAssignments.html',args)
def superuser(request):
list = info.objects.all()
if request.POST.get('dname', ''):
c = {}
c.update(csrf(request))
dname = request.POST.get('dname', '')
user = account.objects.get(name=dname)
user.delete()
inf = info.objects.get(name=dname)
inf.delete()
return render(request,'superuser.html',{'list': list})
elif request.POST.get('name', '') and request.POST.get('password', '') and request.POST.get('gender', '') and request.POST.get('height', '') and request.POST.get('weight', ''):
c = {}
c.update(csrf(request))
name = request.POST.get('name', '')
password = request.POST.get('password', '')
gender = request.POST.get('gender', '')
height = request.POST.get('height', '')
weight = request.POST.get('weight', '')
acc_obj = account.objects.create(name=name,password=password)
acc_obj.save()
info_obj = info.objects.create(name=name,gender=gender,height=height,weight=weight,time=datetime.now())
info_obj.save()
return render(request,'superuser.html',{'list': list})
else:
return render(request,'superuser.html',{'list': list})
def index(request):
u = request.user
custom_user = CustomUser.objects.get(user=u)
#if not custom_user.is_admin_approved == False:
#return HttpResponseRedirect('/logins/register_success')
try:
custom_user = CustomUser.objects.get(user=u)
info_list =Info.objects.filter(game__in=custom_user.game.all(), department__in = custom_user.department.all()).distinct()
#visible = Info.objects.filter(department__in=customuser.departments.all(), game__in=customuser.games.all())
context = RequestContext(request, {
'info_list': info_list,
})
template = loader.get_template('logins/index.html')
args = {}
args.update(csrf(request))
args['index'] = Info.objects.all()
return HttpResponse(template.render(context), args)
except ObjectDoesNotExist:
info_list = None;
context = RequestContext(request, {
'info_list': info_list,
})
template = loader.get_template('logins/index.html')
args = {}
args.update(csrf(request))
args['index'] = Info.objects.all()
return HttpResponse(template.render(context), args)
def orders(request):
if request.POST:
c=request.POST.get('charges')
b=request.POST.get('other_charges')
order=request.POST.get('order_no')
form= OrderForm(request.POST)
if form.is_valid():
form.save()
a=OrderModel.objects.get(order_no=order)
a.total_charges=int(c)+int(b)
a.save()
c={}
c.update(csrf(request))
c['path']='/shipper/'
c['form']=ShipperForm
c['title']= "SHIPPING INFO"
return render_to_response('forms.html',c,context_instance=RequestContext(request))
else:
form=OrderForm
a={}
a.update(csrf(request))
a['path']='/orders/'
a['form']=form
a['title']= "ORDER INFO"
a['button']="PROCEED TO SHIPPING DETAILS"
return render_to_response('forms.html',a,context_instance=RequestContext(request))
def register_user(request):
if request.method == 'POST':
form = MyRegistrationForm(request.POST)
if form.is_valid():
# autologin after register here
new_user = form.save()
new_user = authenticate(username=request.POST['username'],
password=request.POST['password1'])
auth.login(request, new_user)
userprofile = UserProfile(name=request.POST['username'])
userprofile.save()
return HttpResponseRedirect('/accounts/loggedin')
else:
args = {}
args.update(csrf(request))
args['form'] = MyRegistrationForm()
context={"invalid": True,"args":args}
return render(request, 'register.html', context)
args = {}
args.update(csrf(request))
args['form'] = MyRegistrationForm()
context={"invalid": False,"args":args}
return render(request, "register.html", context)
def add_post(request):
args = {}
args['user'] = get_object_or_404(ourUser,id=request.user.id)
form = post_form()
if request.POST:
form = post_form(request.POST)
if form.is_valid():
#tie the post to the wall and define the user for the post
user = get_object_or_404(ourUser, username=request.user.username)
community_wall = list(communityWall.objects.filter(community=user.community).exclude(wall_name="deleted"))
#makes a post object with commit=false to allow for editing
#setting attributes
post = form.save(commit=False)
args = post.post_handler(community_wall[0], user)
return HttpResponseRedirect('/user/home/')
else: #if there is an error, asks user to fix it
args = {}
args.update(csrf(request))
args['form'] = form
args['error'] = 1
return render_to_response('add_post.html', args)
else:
args.update(csrf(request))
args['form'] = form
return render_to_response('add_post.html', args)
def login(request):
if request.user.is_authenticated(): # if there is a user logged in already
user_name = UserProfile(name=request.user.username)
if request.POST:
form = UserProfileForm(request.POST, instance=user_name)
if form.is_valid():
form.save()
return HttpResponseRedirect('/')
else:
form = UserProfileForm(instance=user_name)
args = {}
args.update(csrf(request))
args['form'] = UserProfileForm()
print args
context = {"full_name": request.user.username, "args" :args}
return HttpResponseRedirect("", context)
else:
c={}
c.update(csrf(request))
context = {"c": c}
return render(request, "login.html", context)
def register(request):
content = {}
if request.user.is_superuser:
if request.method == 'POST':
print u"注册数据"
form = UserCreateForm(request.POST) # UserCreationForm(request.POST)
print u"验证完成"
if form.is_valid():
# form.is_staff = 1
new_user = form.save(commit=False)
new_user.is_staff = 1
new_user.save()
# perhaps set permissions of the new user
# return render(request, 'registration/success.html') # need to create success.html
return HttpResponseRedirect('/')
else:
content["form"] = form
content.update(csrf(request))
return render_to_response('user/reg.html',content,context_instance=RequestContext(request))
else:
data = UserCreateForm() # UserCreationForm()
content["data"] = data
content.update(csrf(request))
# return render(request, 'user/reg.html', context_instance=RequestContext(request))
return render_to_response('user/reg.html',content,context_instance=RequestContext(request))
return render_to_response('user/auth_error_index.html', context_instance=RequestContext(request))
def handle_location_data(request,pk):
profile = UserProfile.objects.get(user__pk=pk)
current_user = request.user.userprofile
friend_list = current_user.friends.filter(UserA__is_shared=True)
share = False
if request.user == profile.user:
share = True
else:
share = profile.shared(request.user.userprofile)
if(share):
latitude = profile.last_location_latitude
longtitude = profile.last_location_longtitude
self_latitude = current_user.last_location_latitude
self_longtitude = current_user.last_location_longtitude
if request.method == 'GET':
context = {'pk':pk, 'latitude':latitude, 'longtitude':longtitude,'user':profile.user,'self_latitude':self_latitude,
'self_longtitude':self_longtitude,'friend_list':friend_list}
context.update(csrf(request))
return render_to_response('location/location.html',
context)
else:
current_user.last_location_latitude = request.POST.get("new_latitude")
current_user.last_location_longtitude = request.POST.get("new_longtitude")
current_user.save()
context = {'pk':pk, 'latitude':latitude, 'longtitude':longtitude,'user':profile.user,'self_latitude':current_user.last_location_latitude,
'self_longtitude':current_user.last_location_longtitude,'friend_list':friend_list}
context.update(csrf(request))
return render_to_response('location/location.html',context)
else:
return render(request,'location/accessdeny.html')
def equipment(request):
if request.POST:
form= EquipmentForm(request.POST)
dl=request.POST.get('driver_name')
if form.is_valid():
form.save()
b=DriverModel.objects.get(license_no=dl)
task=b.assigned_tasks
task+=1
b.assigned_tasks=task
b.reputation=reputation(b.finished_tasks,b.assigned_tasks)
b.save()
c={}
c.update(csrf(request))
c['path']='/carrier/'
c['form']=CarrierForm
c['title']= "CARRIER INFO"
return render_to_response('forms.html',c,context_instance=RequestContext(request))
else:
form=EquipmentForm
a={}
a.update(csrf(request))
a['path']='/equipment/'
a['form']=form
a['title']= "EQUIPMENT INFO "
a['button']="PROCEED TO PAY TO DETAILS"
return render_to_response('forms.html',a,context_instance=RequestContext(request))
def post_detail(request, pk):
if request.user.is_authenticated():
if auth.get_user(request).username == str(Post.objects.get(pk=pk).author):
post = get_object_or_404(Post, pk=pk)
return render(request, 'post_detail.html', {'post': post, 'username': auth.get_user(request).username})
else:
comments_form = PostComments
args = {}
args.update(csrf(request))
args['post_views'] = Post.objects.get(pk=pk)
args['comments'] = Comments.objects.filter(comments_post_id=pk)
args['form'] = comments_form
args['username'] = auth.get_user(request).username
args['author'] = Post.objects.get(pk=pk).author
return render_to_response('post_views.html', args)
else:
comments_form = PostComments
args = {}
args.update(csrf(request))
args['post_views'] = Post.objects.get(pk=pk)
args['comments'] = Comments.objects.filter(comments_post_id=pk)
args['form'] = comments_form
args['username'] = auth.get_user(request).username
args['author'] = Post.objects.get(pk=pk).author
return render_to_response('post_views.html', args)
def subredditdetail(request,sub_id,post_id):
post_info = Post.objects.get(id=post_id)
comment_info = Comment.objects.filter(post=post_info)
comment_info = comment_info.order_by('-count')
num = 0
if post_info.firstlink == "":
num = num+1
if post_info.secondlink == "":
num = num+1
if post_info.thirdlink == "":
num = num+1
if num == 3:
c = {
'Post_list': post_info,
'invalid': True ,
'comment_list': comment_info,
}
c.update(csrf(request))
return render_to_response("Rebbit/subredditdetail.html", c, context_instance=RequestContext(request))
else:
c = {
'Post_list': post_info,
'comment_list': comment_info,
}
c.update(csrf(request))
return render_to_response("Rebbit/subredditdetail.html", c, context_instance=RequestContext(request))
def BookMachine(request):
#query everything that it is available to use today during the whole day until gym closes. assume it clos$
#everything is done ine simple 24 hours format so 1 is 1 am 13 is 1 pm ...
#select current date #year month day
curr_date=datetime.datetime.now()
today=curr_date.strftime("%Y-%m-%d")
tmr_date=datetime.datetime.today()+timedelta(days=1)
tomorrow=tmr_date.strftime("%Y-%m-%d")
time=strftime("%H")
sfu_id=request.user.username
multi_book=""
if request.POST:
#'id_machine_name' is passed via the form
new_booking = Bookings(machine_name='id_machine_name',booked_date=today, username=sfu_id)
form = AddBookingForm(request.POST, instance=new_booking)#try to add the bookings for today
booked_time=""
if form.is_valid():
data = form.cleaned_data
if(data['machine_name']=='rowing'):
booked_time=data['rowing_time']
elif(data['machine_name']=='treadmill'):
booked_time=data['treadmill_time']
elif(data['machine_name']=='stairs'):
booked_time=data['stairs_time']
new_booking.booked_time=booked_time
#check that user hasnt previoulsy booked that machine
booked_check=Bookings.objects.filter(machine_name=data['machine_name'],booked_date=today,username=sfu_id,booked_time=booked_time)
if(booked_check.count()>0):
return HttpResponseRedirect('/swt/bookings/')
else:
form.save()
return HttpResponseRedirect('/swt/bookings/')
else:
form_today= AddBookingForm()
form_tomorrow=AddBookingFormTomorrow()
args={}
args.update(csrf(request))
#query database see what the user has booked for today
my_bookings= Bookings.objects.filter(booked_date=today,username=sfu_id).order_by('booked_time')
#assume that there are 2 machines of each type at the gym and we have to calculate how many machines are booked for each time
fully_booked_treadmill=Bookings.fully_booked_arr(today,'treadmill')
fully_booked_rowing=Bookings.fully_booked_arr(today,'rowing')
fully_booked_stairs=Bookings.fully_booked_arr(today,'stairs')
#now do the same types of query's but for tomorrow's date
my_bookings_tmr=Bookings.objects.filter(booked_date=tomorrow,username=sfu_id).order_by('booked_time')
#assume there are 2 machines of each time, if wished change number in the model function
fully_booked_treadmill_tmr=Bookings.fully_booked_arr(tomorrow,'treadmill')
fully_booked_rowing_tmr=Bookings.fully_booked_arr(tomorrow,'rowing')
fully_booked_stairs_tmr=Bookings.fully_booked_arr(tomorrow,'stairs')
#we may not need THIS
booked_times_treadmill = []
booked_times_stairs = []
booked_times_rowing = []
# The Default Index to start with in Booking Time Dropdown
default_t_index = 6
default_s_index = 6
default_r_index = 6
#tomorrows indexes
default_t_index_tmr=6
default_s_index_tmr=6
default_r_index_tmr=6
#calculatin the indexes for today
default_t_index=default_t_index + Bookings.get_delta_index(fully_booked_treadmill)
default_s_index=default_s_index + Bookings.get_delta_index(fully_booked_stairs)
default_r_index=default_r_index + Bookings.get_delta_index(fully_booked_rowing)
#calculatin the index for tomorrow
default_t_index_tmr=default_t_index_tmr+ Bookings.get_delta_index(fully_booked_treadmill_tmr)
default_s_index_tmr=default_s_index_tmr+ Bookings.get_delta_index(fully_booked_stairs_tmr)
default_r_index_tmr=default_r_index_tmr+ Bookings.get_delta_index(fully_booked_rowing_tmr)
args['form_today'] = form_today
args['booked_times_treadmill'] = booked_times_treadmill
args['booked_times_stairs'] = booked_times_stairs
args['booked_times_rowing'] = booked_times_rowing
args['default_t_index'] = default_t_index
args['default_s_index'] = default_s_index
args['default_r_index'] = default_r_index
args['fully_booked_treadmill']=fully_booked_treadmill
args['fully_booked_stairs']=fully_booked_stairs
args['fully_booked_rowing']=fully_booked_rowing
args['my_bookings']=my_bookings
args['time']=int(time)
#tomorrow variables and related
args['tomorrow']=tomorrow
args['form_tomorrow']=form_tomorrow
args['my_bookings_tmr']=my_bookings_tmr
return render_to_response('bookmachine.html',args)
def home(request):
c = {}
c.update(csrf(request))
return render_to_response('home.jade', c, RequestContext(request))
def about(request):
c = {}
c.update(csrf(request))
return render_to_response('about.jade', c, RequestContext(request))
def resources(request):
c = {}
c.update(csrf(request))
return render_to_response('resources.jade', c, RequestContext(request))
def copy_workout(request, pk):
'''
Makes a copy of a workout
'''
workout = get_object_or_404(Workout, pk=pk, user=request.user)
# Process request
if request.method == 'POST':
workout_form = WorkoutCopyForm(request.POST)
if workout_form.is_valid():
# Copy workout
days = workout.day_set.all()
workout_copy = workout
workout_copy.pk = None
workout_copy.comment = workout_form.cleaned_data['comment']
workout_copy.save()
# Copy the days
for day in days:
sets = day.set_set.all()
day_copy = day
days_of_week = [i for i in day.day.all()]
day_copy.pk = None
day_copy.training = workout_copy
day_copy.save()
for i in days_of_week:
day_copy.day.add(i)
day_copy.save()
# Copy the sets
for current_set in sets:
current_set_id = current_set.id
exercises = current_set.exercises.all()
current_set_copy = current_set
current_set_copy.pk = None
current_set_copy.exerciseday = day_copy
current_set_copy.save()
# Exercises has Many2Many relationship
current_set_copy.exercises = exercises
# Go through the exercises
for exercise in exercises:
settings = exercise.setting_set.filter(
set_id=current_set_id)
# Copy the settings
for setting in settings:
setting_copy = setting
setting_copy.pk = None
setting_copy.set = current_set_copy
setting_copy.save()
return HttpResponseRedirect(
reverse('wger.manager.views.workout.view',
kwargs={'id': workout.id}))
else:
workout_form = WorkoutCopyForm({'comment': workout.comment})
template_data = {}
template_data.update(csrf(request))
template_data['title'] = _('Copy workout')
template_data['form'] = workout_form
template_data['form_action'] = reverse('workout-copy',
kwargs={'pk': workout.id})
template_data['form_fields'] = [workout_form['comment']]
return render_to_response('form.html',
template_data,
context_instance=RequestContext(request))
def add_csrf(request, **kwargs):
"""Add CSRF and user to dictionary."""
d = dict(user=request.user, **kwargs)
d.update(csrf(request))
return d
def to_json(request, election, poll):
data = poll.get_booth_dict()
data['token'] = unicode(csrf(request)['csrf_token'])
return HttpResponse(json.dumps(data, default=common_json_handler),
content_type="application/json")
def query(request, repo_base, repo):
try:
login = get_login(request)
data = {
'login': get_login(request),
'repo_base': repo_base,
'repo': repo,
'select_query': False,
'query': None
}
data.update(csrf(request))
if 'q' in request.REQUEST:
query = request.REQUEST['q']
query = query.strip().rstrip(';')
manager = DataHubManager(user=repo_base)
select_query = False
if (query.split()[0]).lower() == 'select':
select_query = True
count = 0
limit = 50
if select_query:
res = manager.execute_sql(query='EXPLAIN %s' % (query))
num_rows = re.match(r'.*rows=(\d+).*',
res['tuples'][0][0]).group(1)
count = int(num_rows)
total_pages = 1 + (int(count) / limit)
current_page = 1
try:
current_page = int(request.REQUEST['page'])
except:
pass
if current_page < 1:
current_page = 1
start_page = current_page - 5
if start_page < 1:
start_page = 1
end_page = start_page + 10
if end_page > total_pages:
end_page = total_pages
db_query = query
if select_query:
# wrap query in another select statement, to allow the
# user's LIMIT statements to still work
db_query = 'select * from (' + query + ') as BXCQWVPEMWVKFBEBNKZSRPYBSB'
# wrap in datahub limit and offset statements, to support pagination
db_query = '%s LIMIT %s OFFSET %s' % (db_query, limit,
(current_page - 1) *
limit)
res = manager.execute_sql(query=db_query)
if select_query or res['row_count'] > 0:
column_names = [field['name'] for field in res['fields']]
tuples = res['tuples']
else:
column_names = ['status']
tuples = [['success' if res['status'] else res['error']]]
url_path = '/browse/%s/%s/query' % (repo_base, repo)
data.update({
'select_query': select_query,
'query': query,
'column_names': column_names,
'tuples': tuples,
'url_path': url_path,
'current_page': current_page,
'next_page': current_page + 1,
'prev_page': current_page - 1,
'total_pages': total_pages,
'pages': range(start_page, end_page + 1)
})
return render_to_response("query-browse-results.html", data)
else:
return render_to_response("query.html", data)
except Exception, e:
return HttpResponse(json.dumps({'error': str(e)}),
content_type="application/json")
hashed_password = hashlib.sha1(app_token).hexdigest()
DataHubManager.create_user(username=app_id,
password=hashed_password,
create_db=False)
except Exception, e:
app.delete()
raise e
return HttpResponseRedirect('/developer/apps')
except Exception, e:
c = {'login': login, 'errors': [str(e)]}
c.update(csrf(request))
return render_to_response('app-create.html', c)
else:
c = {'login': login}
c.update(csrf(request))
return render_to_response('app-create.html', c)
@login_required
def app_remove(request, app_id):
try:
login = get_login(request)
user = User.objects.get(username=login)
app = App.objects.get(user=user, app_id=app_id)
app.delete()
DataHubManager.remove_user(username=app_id)
return HttpResponseRedirect('/developer/apps')
except Exception, e:
def card(request, repo_base, repo, card_name):
try:
login = get_login(request)
card = Card.objects.get(repo_base=repo_base,
repo_name=repo,
card_name=card_name)
query = card.query
manager = DataHubManager(user=repo_base)
res = manager.execute_sql(query='EXPLAIN %s' % (query))
limit = 50
num_rows = re.match(r'.*rows=(\d+).*', res['tuples'][0][0]).group(1)
count = int(num_rows)
total_pages = 1 + (int(count) / limit)
current_page = 1
try:
current_page = int(request.REQUEST['page'])
except:
pass
if current_page < 1:
current_page = 1
start_page = current_page - 5
if start_page < 1:
start_page = 1
end_page = start_page + 10
if end_page > total_pages:
end_page = total_pages
# wrap query in another select statement, to allow the
# user's LIMIT statements to still work
db_query = 'select * from (' + query + ') as BXCQWVPEMWVKFBEBNKZSRPYBSB'
db_query = '%s LIMIT %s OFFSET %s' % (db_query, limit,
(current_page - 1) * limit)
res = manager.execute_sql(query=db_query)
column_names = [field['name'] for field in res['fields']]
tuples = res['tuples']
annotation_text = None
url_path = '/browse/%s/%s/card/%s' % (repo_base, repo, card_name)
try:
annotation = Annotation.objects.get(url_path=url_path)
annotation_text = annotation.annotation_text
except:
pass
data = {
'login': get_login(request),
'repo_base': repo_base,
'repo': repo,
'card_name': card_name,
'annotation': annotation_text,
'query': query,
'column_names': column_names,
'tuples': tuples,
'url_path': url_path,
'current_page': current_page,
'next_page': current_page + 1,
'prev_page': current_page - 1,
'total_pages': total_pages,
'pages': range(start_page, end_page + 1)
}
data.update(csrf(request))
return render_to_response("card-browse.html", data)
except Exception, e:
return HttpResponse(json.dumps({'error': str(e)}),
content_type="application/json")
def login(request):
c = {}
c.update(csrf(request))
return render(request, )
def table(request, repo_base, repo, table):
try:
login = get_login(request)
dh_table_name = '%s.%s.%s' % (repo_base, repo, table)
res = DataHubManager.has_table_privilege(login, repo_base,
dh_table_name, 'SELECT')
if not (res and res['tuples'][0][0]):
raise Exception('Access denied. Missing required privileges.')
manager = DataHubManager(user=repo_base)
res = manager.execute_sql(query='EXPLAIN SELECT * FROM %s' %
(dh_table_name))
limit = 50
num_rows = re.match(r'.*rows=(\d+).*', res['tuples'][0][0]).group(1)
count = int(num_rows)
total_pages = 1 + (int(count) / limit)
current_page = 1
try:
current_page = int(request.REQUEST['page'])
except:
pass
if current_page < 1:
current_page = 1
start_page = current_page - 5
if start_page < 1:
start_page = 1
end_page = start_page + 10
if end_page > total_pages:
end_page = total_pages
print "-------------"
res = manager.execute_sql(query='SELECT * from %s LIMIT %s OFFSET %s' %
(dh_table_name, limit,
(current_page - 1) * limit))
column_names = [field['name'] for field in res['fields']]
tuples = res['tuples']
annotation_text = None
url_path = '/browse/%s/%s/table/%s' % (repo_base, repo, table)
try:
annotation = Annotation.objects.get(url_path=url_path)
annotation_text = annotation.annotation_text
except:
pass
data = {
'login': get_login(request),
'repo_base': repo_base,
'repo': repo,
'table': table,
'column_names': column_names,
'tuples': tuples,
'annotation': annotation_text,
'current_page': current_page,
'next_page': current_page + 1,
'prev_page': current_page - 1,
'url_path': url_path,
'total_pages': total_pages,
'pages': range(start_page, end_page + 1)
}
data.update(csrf(request))
return render_to_response("table-browse.html", data)
except Exception, e:
return HttpResponse(json.dumps({'error': str(e)}),
content_type="application/json")
def registration(request):
args = {}
args.update(csrf(request))
request.session['name'] = ''
return render_to_response('Registration.html',args)
def studentc(request): #Student Registration Courses
if request.session['money_paid'] == True and request.session[
'freeze'] == False:
c = {}
c.update(csrf(request))
courses = course.objects.all()
pk1 = request.session['s_id']
q = student.objects.get(id=pk1)
q1 = compulsary.objects.get(branch=q.branch)
sem = q.semester
if sem == 1:
c_courses = q1.sem1
if sem == 2:
c_courses = q1.sem2
if sem == 3:
c_courses = q1.sem3
if sem == 4:
c_courses = q1.sem4
if sem == 5:
c_courses = q1.sem5
if sem == 6:
c_courses = q1.sem6
if sem == 7:
c_courses = q1.sem7
if sem == 8:
c_courses = q1.sem8
cm_courses = c_courses.all()
#print cm_courses
try:
q2 = fulldetail.objects.get(id1=pk1)
except ObjectDoesNotExist:
q2 = fulldetail(id1=pk1)
q2.name = q.name
q2.branch = q.branch
q2.email = q.email
q2.semester = q.semester
q2.save()
for c in cm_courses:
c1 = course.objects.get(code=c.code)
q2.courses.add(c1)
q2.save()
if request.method == "POST":
code = request.POST.get('type', '')
type1 = request.POST.get('type1', '')
flag = True
try:
q3 = request1.objects.get(
id1=pk1, course_name=course.objects.get(code=code).name)
messages.success(request, "Request already sent!")
except ObjectDoesNotExist:
for c in cm_courses:
if c.code == code:
flag = False
messages.success(
request,
"This is a compulsary course. Already selected by default! Choose electives to send request"
)
if flag == True:
q = course.objects.get(code=code)
cname = q.name
fcode = q.faculty_code
q1 = faculty.objects.get(id1=fcode)
sdetail = student.objects.get(id=pk1)
a1 = request1(
id1=pk1,
course_name=cname,
name=sdetail.name,
semester=sdetail.semester,
branch=sdetail.branch,
email=sdetail.email
) #Much more can be passed here !! Ajeet's object can be :P
a1.save()
q1.requests.add(a1)
q1.save()
messages.success(request, "Request sent!")
return render(request, 'app/student_registration.html', {
'courses': courses,
'cm_courses': cm_courses
})
else:
messages.success(
request, 'Complete your payment process to register for courses')
return redirect('/studentp')
def suggestions1(request):
args = {}
args.update(csrf(request))
return render_to_response('suggestions.html', args)
def otp(request):
args = {}
args.update(csrf(request))
print "cococ"
return render_to_response('otp.html',args)
def show_mail_compose(self, request):
try:
if request.is_ajax():
mail_sent_complete = False
if request.method == 'POST':
form = ComposeMailForm(request.POST)
if form.is_valid():
new_mail = Message()
user = request.user
new_mail.id_sender = user
user2 = User.objects.get(
id=form.cleaned_data['user_id'])
new_mail.id_receiver = user2
new_mail.datetime = datetime.now()
new_mail.id_conversation = 1
new_mail.text = form.cleaned_data['text']
new_mail.subject = form.cleaned_data['subject']
new_mail.save()
form = ComposeMailForm()
mail_sent_complete = MAILSENTCOMPLETE
else:
form = ComposeMailForm()
week = {
0: 'Lunes',
1: 'Martes',
2: 'Miércoles',
3: 'Jueves',
4: 'Viernes',
5: 'Sábado',
6: 'Domingo'
}
month = {
0: 'Enero',
1: 'Febrero',
2: 'Marzo',
3: 'Abril',
4: 'Mayo',
5: 'Junio',
6: 'Julio',
7: 'Agosto',
8: 'Septiembre',
9: 'Octubre',
10: 'Noviembre',
11: 'Diciembre'
}
date_time = week[datetime.today().weekday()] + " " + str(
datetime.today().day) + "/" + month[
datetime.today().month - 1] + " " + str(
datetime.today().year)
c = {
'form': form,
'date_t': date_time,
'mail_sent_complete': mail_sent_complete
}
c.update(csrf(request))
return render_to_response('user_send_mail.html', c)
else:
return HttpResponseRedirect("/usuarios/profile/mail")
except Exception as e:
return self.show_error(e)
def login(request):
args = {}
args.update(csrf(request))
return render_to_response('SignIn.html',args)
def addpost(request):
args = {}
# tm = datetime.now().time()
if request.method == 'GET':
args['username'] = auth.get_user(request).username
args.update(csrf(request))
return render_to_response('addpost.html', args)
if request.method == 'POST':
post_title = request.GET['id_title']
nameFile = str(uuid.uuid4())[:12]
# nameFile = "%s_%s" % (post_title, auth.get_user(request).id)
# nameFile = "%s" % post_title
body_text = request.GET['id_text']
data = json.loads(request.body)
image_post = data['my_image']
imgstr = re.search(r'base64,(.*)', image_post).group(1)
#path = default_storage.save('/home/sadko/social-network-master/media/data_image/%s.png' % nameFile, ContentFile(imgstr))
# pathmedium = default_storage.save('%s_tm.png' % nameFile, ContentFile(imgstr))
img_file = open(
"/home/sadko/social-network-master/media/data_image/%s.png" %
nameFile, 'wb')
img_file.write(base64.b64decode(imgstr))
img_file.close()
# save timbinal imageMedium=pathmedium,
crop(nameFile)
#
post = Post(title=post_title,
body=body_text,
user_post=request.user,
image=nameFile)
post.save()
owner_id = '47376425' # intattoo
token = '2d3fddc7fb9d92e47dda437815fab6eed531688e14402224344aa686851b455778ef49894d49fb9ce0b8b'
# token = 'eb9bd1088f0623a59e41f8cb4ee42a1f4f38114b4e23738d5a7d96df1e8c7136af4718225d1da430bcf51'
method_0 = 'https://api.vk.com/method/wall.post?' # 1
method_1 = 'https://api.vk.com/method/photos.getWallUploadServer?'
method_2 = 'https://api.vk.com/method/photos.saveWallPhoto?'
#titVK = post.title
titVK = post_title
######
# f = open("/Users/macbookpro/PycharmProjects/app/media/%s" % path, "rb")
f = open("/home/sadko/social-network-master/media/%s" % path, "rb")
img = {'photo': f} #!!!!!!
# data = dict(access_token=token, gid=owner_id)
data = dict(group_id=owner_id, access_token=token)
response = requests.post(method_1, data)
result = json.loads(response.text)
upload_url = result['response']['upload_url']
# Загружаем изображение на url
response = requests.post(upload_url, files=img)
result = json.loads(response.text)
# Сохраняем фото на сервере и получаем id
# data = dict(access_token=token, gid=owner_id, photo=result['photo'], hash=result['hash'], server=result['server'])
data = dict(group_id=owner_id,
photo=result['photo'],
hash=result['hash'],
server=result['server'],
access_token=token)
response = requests.post(method_2, data)
result = json.loads(response.text)['response'][0]['id']
# отправка в вк
# data = dict(access_token=token, owner_id='-' + owner_id, attachments=result, message='%s' % titVK)
data = dict(owner_id='-' + owner_id,
attachments=result,
message='%s' % titVK,
access_token=token)
response = requests.post(method_0, data)
result = json.loads(response.text)
return redirect('/', result)
return render_to_response('addpost.html', args)
def login(request):
c = {}
c.update(csrf(request))
return render_to_response('jsdev/marat_login.html', c)
def login(request):
c = {}
c.update(csrf(request))
return render(request, 'login.html', c)
def search_post(request):
context = dict()
context.update(csrf(request))
if request.POST:
context['result'] = request.POST['search_content']
return render(request, 'form-post.html', context)
def make_context(self, request, interface):
context = csrf(request)
context['auth'] = interface
context['page'] = 'security'
return context
def login(request):
context = {}
context.update(csrf(request))
return render(request, 'registration/login.html')
def login(request):
log_content = {}
log_content.update(csrf(request))
return render_to_response('login.html', log_content)
def gallery(request, page):
if page == '0':
lat = request.GET['lat']
lon = request.GET['lon']
gender = request.GET['gender']
request.session['gender'] = gender
request.session['lat'] = lat
request.session['lon'] = lon
params = {}
params.update(csrf(request))
u = user.objects.get(fsq_id=request.session['fsq_id'])
token = u.token
u.last_lat = lat
u.last_lon = lon
u.save()
trending = authenticator.query("/venues/trending", token,
{'ll': str(lat) + ',' + str(lon)})
trending_venues = {}
nearby_venues = {}
for item in trending['venues']:
try:
trending_venues[
item['id']] = item['name'], item['categories'][0]['name']
except:
trending_venues[item['id']] = item['name'], ''
browser_radius = request.GET['radius']
radius = hotspots(float(lat), float(lon))
if not radius:
radius = browser_radius
else:
pass
request.session['radius'] = radius
all_nearby = authenticator.query(
"/venues/search", token, {
'll': str(lat) + ',' + str(lon),
'limit': 50,
'intent': 'browse',
'radius': radius
})
i = 0
for item in all_nearby['venues']:
if item['hereNow']['count'] > 0:
try:
nearby_venues[item['id']] = item['name'], item[
'categories'][0]['name']
except:
nearby_venues[item['id']] = item['name'], ''
for item in set(nearby_venues).intersection(set(trending_venues)):
del nearby_venues[item]
all_venues_nearby = nearby_venues.items() + trending_venues.items()
## if len(all_venues_nearby)<16:
## return render_to_response ('block.html')
## else:
## pass
venue_names = []
chickpix = {}
backpix = {}
herenow = []
v_ids = []
i = 0
n = 0
for venue in all_venues_nearby:
herenow.append(
authenticator.query("/venues/" + venue[0] + "/herenow", token))
v_ids.append(venue[0])
herenow[i]['hereNow']['venueName'] = venue[1][0]
herenow[i]['hereNow']['venueCat'] = venue[1][1]
i = i + 1
for item in herenow:
venueName = item['hereNow']['venueName']
venueCat = item['hereNow']['venueCat']
for entry in item['hereNow']['items']:
if entry['user']['gender'] == gender:
the_id = entry['user']['id']
if entry['user']['photo'].startswith(
"https://foursquare.com/img/"):
pass
elif categorize(venueName):
chickpix[the_id] = [
entry['user']['photo'][36:],
entry['user']['firstName'],
venueName.split('-')[0], v_ids[n]
]
else:
backpix[the_id] = [
entry['user']['photo'][36:],
entry['user']['firstName'],
venueName.split('-')[0], v_ids[n]
]
try:
user_lookup.objects.create(
fsq_id=entry['user']['id'],
pic_id=entry['user']['photo'][36:])
except:
pass
else:
pass
n += 1
preferred = [list(x) for x in chunk(chickpix.values(), 2)]
other = [list(x) for x in chunk(backpix.values(), 2)]
random.shuffle(preferred)
random.shuffle(other)
pairs = preferred + other
for item in pairs:
if len(item) < 2:
item.append(pairs[0][0])
request.session['chickpix'] = pairs
else:
params = {}
params.update(csrf(request))
request.session.modified = True
if len(request.session['chickpix']) < (int(page) + 1):
newradius = int(request.session['radius']) + 15000
request.session['radius'] = newradius
if newradius > 100000:
lastpage = True
else:
lastpage = False
return render_to_response(
'lastpage.html', {
'newradius': newradius,
'lastpage': lastpage,
'gender': request.session['gender'],
'lat': request.session['lat'],
'lon': request.session['lon']
})
else:
image_pair = request.session['chickpix'][int(page)]
return render_to_response('gallery.html', {
'chickpix': image_pair,
'csrf': params,
'page': int(page)
},
context_instance=RequestContext(request))
def send_simple_email(request):
if request.method == 'POST':
form = EmailForm(request.POST)
if form.is_valid():
subject = request.POST["subject"]
message = request.POST["message"]
from_email = request.POST["sender"]
recipient_list = request.POST["to"]
recipient_list = [r.strip() for r in recipient_list.split(",")]
categoryData = request.POST["category"]
categories = parse_csv_string(categoryData)
# https://docs.djangoproject.com/en/dev/ref/forms/fields/#booleanfield
html = getattr(request.POST, "html", False)
enable_gravatar = getattr(request.POST, "enable_gravatar", False)
enable_click_tracking = getattr(request.POST,
"enable_click_tracking", False)
add_unsubscribe_link = getattr(request.POST,
"add_unsubscribe_link", False)
sendGridEmail = SendGridEmailMessage(
subject,
message,
from_email,
recipient_list,
)
if html:
sendGridEmail.content_subtype = "html"
if categories:
logger.debug("Categories {c} were given".format(c=categories))
# The SendGrid Event API will POST different data for single/multiple category messages.
if len(categories) == 1:
sendGridEmail.sendgrid_headers.setCategory(categories[0])
elif len(categories) > 1:
sendGridEmail.sendgrid_headers.setCategory(categories)
sendGridEmail.update_headers()
filterSpec = {}
if enable_gravatar:
logger.debug("Enable Gravatar was selected")
filterSpec["gravatar"] = {"enable": 1}
if enable_gravatar:
logger.debug("Enable click tracking was selected")
filterSpec["clicktrack"] = {"enable": 1}
if add_unsubscribe_link:
logger.debug("Add unsubscribe link was selected")
# sendGridEmail.sendgrid_headers.add
filterSpec["subscriptiontrack"] = {
"enable": 1,
"text/html": "<p>Unsubscribe <%Here%></p>",
}
if filterSpec:
filterutils.update_filters(sendGridEmail,
filterSpec,
validate=True)
logger.debug("Sending SendGrid email {e}".format(e=sendGridEmail))
response = sendGridEmail.send()
logger.debug("Response {r}".format(r=response))
return HttpResponseRedirect("/")
else:
form = EmailForm()
c = {"form": form}
c.update(csrf(request))
return render_to_response('main/send_email.html', c)
def __render(template_name, context, request=None, enable_csrf=False):
if enable_csrf:
context.update(csrf(request))
return render(request, template_name, context)
return render_to_response(template_name, context)
def single_thread(request, course_id, discussion_id, thread_id):
course = get_course_with_access(request.user, course_id, 'load')
cc_user = cc.User.from_django_user(request.user)
user_info = cc_user.to_dict()
try:
thread = cc.Thread.find(thread_id).retrieve(recursive=True,
user_id=request.user.id)
except (cc.utils.CommentClientError,
cc.utils.CommentClientUnknownError) as err:
log.error("Error loading single thread.")
raise Http404
if request.is_ajax():
courseware_context = get_courseware_context(thread, course)
annotated_content_info = utils.get_annotated_content_infos(
course_id, thread, request.user, user_info=user_info)
context = {'thread': thread.to_dict(), 'course_id': course_id}
# TODO: Remove completely or switch back to server side rendering
# html = render_to_string('discussion/_ajax_single_thread.html',
# context)
content = utils.safe_content(thread.to_dict())
if courseware_context:
content.update(courseware_context)
return utils.JsonResponse({
#'html': html,
'content':
content,
'annotated_content_info':
annotated_content_info,
})
else:
category_map = utils.get_discussion_category_map(course)
try:
threads, query_params = get_threads(request, course_id)
threads.append(thread.to_dict())
except (cc.utils.CommentClientError,
cc.utils.CommentClientUnknownError) as err:
log.error("Error loading single thread.")
raise Http404
course = get_course_with_access(request.user, course_id, 'load')
for thread in threads:
courseware_context = get_courseware_context(thread, course)
if courseware_context:
thread.update(courseware_context)
if thread.get('group_id') and not thread.get('group_name'):
thread['group_name'] = get_cohort_by_id(
course_id, thread.get('group_id')).name
# patch for backward compatibility with comments service
if not "pinned" in thread:
thread["pinned"] = False
threads = [utils.safe_content(thread) for thread in threads]
# recent_active_threads = cc.search_recent_active_threads(
# course_id,
# recursive=False,
# query_params={'follower_id': request.user.id},
#)
# trending_tags = cc.search_trending_tags(
# course_id,
#)
annotated_content_info = utils.get_metadata_for_threads(
course_id, threads, request.user, user_info)
cohorts = get_course_cohorts(course_id)
cohorted_commentables = get_cohorted_commentables(course_id)
user_cohort = get_cohort_id(request.user, course_id)
context = {
'discussion_id':
discussion_id,
'csrf':
csrf(request)['csrf_token'],
'init':
'', # TODO: What is this?
'user_info':
saxutils.escape(json.dumps(user_info), escapedict),
'annotated_content_info':
saxutils.escape(json.dumps(annotated_content_info), escapedict),
'course':
course,
#'recent_active_threads': recent_active_threads,
#'trending_tags': trending_tags,
'course_id':
course.id, # TODO: Why pass both course and course.id to template?
'thread_id':
thread_id,
'threads':
saxutils.escape(json.dumps(threads), escapedict),
'category_map':
category_map,
'roles':
saxutils.escape(json.dumps(utils.get_role_ids(course_id)),
escapedict),
'thread_pages':
query_params['num_pages'],
'is_course_cohorted':
is_course_cohorted(course_id),
'is_moderator':
cached_has_permission(request.user, "see_all_cohorts", course_id),
'flag_moderator':
cached_has_permission(request.user, 'openclose_thread', course.id)
or has_access(request.user, course, 'staff'),
'cohorts':
cohorts,
'user_cohort':
get_cohort_id(request.user, course_id),
'cohorted_commentables':
cohorted_commentables
}
return render_to_response('discussion/single_thread.html', context)
def statistics(request):
current_user_pk = auth.get_user(request).pk
# date1 = date2 - datetime.timedelta(days=30)
args = {'title': 'kormushka'}
args.update(csrf(request))
return render(request, 'statistics/layout.html', args)
