def profile(request):
if request.method == 'POST':
form = ProfileForm(request.POST)
buyer = request.user.buyer
if form.is_valid():
if form.cleaned_data['name'] != "":
buyer.name = form.cleaned_data['name']
if form.cleaned_data['address'] != "":
buyer.address = form.cleaned_data['address']
if form.cleaned_data['phone_number'] != "":
buyer.phone_number = form.cleaned_data['phone_number']
if form.cleaned_data['credit_card_number'] != "":
buyer.credit_card_number = form.cleaned_data['credit_card_number']
if form.cleaned_data['credit_card_exp'] != "":
buyer.credit_card_exp = form.cleaned_data['credit_card_exp']
if form.cleaned_data['credit_card_sec'] != "":
buyer.credit_card_sec = form.cleaned_data['credit_card_sec']
buyer.save()
#Process
buyer = request.user.buyer
ccn = "**** **** **** " + buyer.credit_card_number[12:17] if buyer.credit_card_number else "-"
cce = buyer.credit_card_exp if buyer.credit_card_exp else "-"
ccs = "***" if buyer.credit_card_sec else ""
defaults = {"name":buyer.name,"address":buyer.address,"phone_number":buyer.phone_number,"credit_card_number":ccn, "credit_card_expiration" : cce, "credit_card_security":ccs}
return render(request, "profile.html", {"form":form, "success":True,"defaults":defaults})
else:
return render(request, "profile.html", {"form":form, "error":True})
else:
form = ProfileForm()
buyer = request.user.buyer
ccn = "**** **** **** " + buyer.credit_card_number[12:17] if buyer.credit_card_number else "-"
cce = buyer.credit_card_exp if buyer.credit_card_exp else "-"
ccs = "***" if buyer.credit_card_sec else ""
defaults = {"name":buyer.name,"address":buyer.address,"phone_number":buyer.phone_number,"credit_card_number":ccn, "credit_card_expiration" : cce, "credit_card_security":ccs}
return render(request, "profile.html", {"form":form, "defaults":defaults})
def profile(nickname):
user = g.user
print user.nickname
form = ProfileForm()
if request.method == 'POST':
if form.validate_on_submit():
firstname = form.firstname.data
lastname = form.lastname.data
city = form.city.data
state = form.state.data
country = form.country.data
zipcode = form.zipcode.data
major = form.major.data
degree = form.degree.data
account = Account(user.id, firstname, lastname, city, state, country, zipcode, major, degree)
db.session.add(account)
db.session.commit()
return render_template('profile.html',
title=nickname,
form=form,
user=user)
return render_template('profile.html',
title=nickname,
form=form,
user=user)
def edit(request):
""" Update UserProfile """
if request.method == 'POST':
form = ProfileForm(request.POST,
instance=UserProfile.objects.get(user=request.user))
if form.is_valid(): # All validation rules pass
try:
User.objects.filter(email=form.cleaned_data['email']).\
exclude(pk=request.user.pk).get()
request.session['flash'] = ['This e-mail is already in use',
'error']
return HttpResponseRedirect(
request.META.get('HTTP_REFERER', '/'))
except User.DoesNotExist:#Check if the e-mail is not already in use
pass
request.user.email = form.cleaned_data['email']
request.user.save()
form.save()
request.session['flash'] = ['Your profile has been updated',
'success']
return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))
else:
form = ProfileForm(instance=UserProfile.objects.get(user=request.user),
initial = {'email': request.user.email})
return render_to_response('accounts/edit.html', {'form': form},
context_instance=build_context(request))
def contact_edit(request, first_name, last_name):
'''
get contact page
@param request:
@param first_name: Profile.first_name
@param last_name: Profile.last_name
'''
profile = get_object_or_404(Mybio,
pk=1)
if request.method == "POST":
profile_form = ProfileForm(request.POST, instance=profile)
if profile_form.is_valid():
profile = profile_form.save()
if request.method == "GET":
profile_form = ProfileForm(instance=profile)
return {
"profile": profile,
"profile_form": profile_form,
"utility_links": ((reverse('profile-view',
kwargs={"first_name": profile.first_name,
"last_name": profile.last_name, }),
_("View profile"),
{}),)}
def profile():
if current_user.is_authenticated():
user = current_user
else:
user = None
form = ProfileForm(obj=user)
if not form.password or form.password == '':
del form.password
if form.validate_on_submit():
if user:
flash('Successfully updated your profile.')
else:
user = User()
user.role = 1
flash('Congratulations, you just created an account!')
form.populate_obj(user)
db.session.add(user)
db.session.commit()
if not current_user.is_authenticated():
login_user(user)
return redirect('/')
return render_template('demographic.html', form=form)
def post(self):
user = tusers.get_current_user()
if user:
form = ProfileForm(self.request.POST)
if (form.validate()):
user.full_name = form.name.data
user.current_institution = form.institution.data
user.public_profile = form.public.data
user.phone = form.phone.data
user.put()
if form.email.data:
user.change_email(form.email.data)
if form.email_code.data:
user.verify_email(form.email_code.data)
self.redirect('/update_profile')
else:
template_values = {
'user' : user,
'logout' : tusers.create_logout_url('/'),
'form' : form
}
template = JINJA_ENVIRONMENT.get_template('view/update_profile.html')
self.response.write(template.render(template_values))
else:
self.redirect(tusers.create_login_url(self.request.uri))
def new_person():
if not current_user.is_admin:
return abort(401)
form = ProfileForm()
form.location.query = Location.query.order_by('name')
form.brewery.query = Brewery.query.order_by('name')
if form.validate_on_submit():
person = Person(firstname=form.firstname.data,
lastname=form.lastname.data,
email=form.email.data,
password = bcrypt.generate_password_hash(form.password.data),
is_admin = form.is_admin.data,
is_manager = form.is_manager.data,
is_brewer = form.is_brewer.data)
db.session.add(person)
db.session.commit()
if person.is_manager:
location = Location.query.get(form.location.data.id)
location.managers.append(person)
db.session.add(location)
if person.is_brewer:
brewery = Brewery.query.get(form.brewery.data.id)
brewery.brewers.append(person)
db.session.add(brewery)
db.session.commit()
flash("Person added successfully", "success")
return redirect(url_for("index"))
if form.errors:
flash("Changes to profile could not be saved. Please correct errors and try again.", "error")
return render_template('new_person.html',
title='Add a person',
form=form,
admin_template=True)
def profile():
form = ProfileForm(request.form)
if request.method == 'POST' and form.validate():
#need to set up salalchemy and reset the redirect to a
#different url_fo()
return redirect(url_for('profile'))
return render_template('profile.html', form=form)
def profile(request):
"""
Form for modifying and adding profile values
"""
if request.method == 'POST':
form = ProfileForm(request.POST,
instance = request.user)
email = request.POST.get('email', '')
if not email == '' and not email == request.user.email:
#confirm the email
salt = sha_constructor(str(random())).hexdigest()[:5]
confirmation_key = sha_constructor(salt + email).hexdigest()
current_site = Site.objects.get_current()
path = reverse('confirm_email',
args=[confirmation_key])
activate_url = u"http://%s%s" % (unicode(current_site.domain),
path)
context = {
"user": request.user,
"activate_url": activate_url,
"current_site": current_site,
"confirmation_key": confirmation_key,
}
subject = render_to_string(
"email_confirmation_subject.txt",
context)
# remove superfluous line breaks
subject = "".join(subject.splitlines())
message = render_to_string(
"email_confirmation_message.txt",
context)
print email
send_mail(subject,
message,
getattr(settings,
'DEFAULT_FROM_EMAIL',
'do-not-reply@%s' % current_site),
[email])
Email.objects.create(
owner = request.user,
email = email,
email_is_verified = False,
sent = datetime.now(),
confirmation_key = confirmation_key)
form.save()
return HttpResponseRedirect(request.POST.get('next', '/'))
else:
form = ProfileForm(instance = request.user)
next = request.GET.get('next', '/')
return render_to_response('profile.html',
{'form': form,
'next': next},
context_instance = RequestContext(request))
def profile():
form = ProfileForm()
if form.validate_on_submit():
user = User.query.filter_by(username=current_user.username).one()
user.email = form.email.data
if form.new_password1.data:
if user.verify_password(form.current_password.data):
user.password = form.new_password1.data
else:
db.session.commit()
flash('Current password is not correct.', 'danger')
return redirect(url_for('profile'))
db.session.commit()
flash('Profile changes saved.', 'success')
return redirect(url_for('profile'))
else:
user = User.query.filter_by(username=current_user.username).one()
form.email.data = user.email
return render_template('profile.html', form=form)
def update_profile(request):
try:
promoter = request.user.promoterprofile
except PromoterProfile.DoesNotExist:
error_meta = {
"method": "promoter.views.update_profile",
}
ErrorLog.objects.create_log(4, "Promoter Object Error", error_meta, request)
raise SuspiciousOperation('Error Code: 4')
form = ProfileForm(request.POST or None, instance=promoter)
context = {
"form": form
}
if request.POST:
if form.is_valid():
form.save()
activity_meta = {
"method": "promoter.views.update_profile",
"form_validation": "True"
}
ActivityLog.objects.create_log(request, "Update Promoter Account", activity_meta)
return redirect('/pr/account/')
else:
return render(request, "promoter/edit_profile.html", context)
else:
activity_meta = {
"method": "promoter.views.update_profile",
}
ActivityLog.objects.create_log(request, "Update Promoter Account", activity_meta)
return render(request, "promoter/edit_profile.html", context)
def edit_profile():
if request.remote_addr != "127.0.0.1":
return "UNAUTHORIZED ACCESS ATTEMPT REJECTED"
form = ProfileForm()
if form.validate_on_submit():
if cache.get('ip_dict_valid'):
cache.set('rerun_setup', True)
cache.set('ip_dict_valid', True)
file = request.files['picture']
file.save(os.path.join(basedir,"app/static/profile.jpg"))
pickling = {}
#Get form data here!
pickling["name"] = form.name.data
pickling["location"] = form.location.data
pickling["organization"] = form.organization.data
pickling["about"] = form.about.data
pickling["project"] = form.project.data
pickling["project_description"] = form.project_description.data
pickle.dump(pickling, open('pickledUser.p', 'wb'))
#form.picture.save(filename)
return redirect(url_for('profile'))
#Get cpickle stuff here
return render_template('edit_profile.html', form=form)
def edit(request, template_name='edit_profile.html',
redirect_to='auth_profile'):
form = ProfileForm(request.POST, instance=request.user.get_profile())
if request.POST:
if form.is_valid():
form.save()
u = request.user
u.email = form.data['email']
u.first_name = form.data['first_name']
u.last_name = form.data['last_name']
u.save()
else:
return render_to_response(template_name, {'form': form},
context_instance=RequestContext(request))
return HttpResponseRedirect(reverse(redirect_to))
else:
initial_dict = {'email': request.user.email,
'username': request.user.username,
'first_name': request.user.first_name,
'last_name': request.user.last_name}
form = ProfileForm(instance=request.user.get_profile(),
initial=initial_dict)
return render_to_response(template_name, {'form': form},
context_instance=RequestContext(request))
def edit(request):
key = ApiKey.objects.get(user = request.user)
if request.method == 'POST':
form = ProfileForm(request.POST,request=request)
if form.is_valid():
# update basic data
email = form.cleaned_data.get("email")
first_name = form.cleaned_data.get("first_name")
last_name = form.cleaned_data.get("last_name")
request.user.email = email
request.user.first_name = first_name
request.user.last_name = last_name
request.user.save()
messages.success(request, _(u"Profile updated"))
# if password should be changed
password = form.cleaned_data.get("password")
if password:
request.user.set_password(password)
request.user.save()
messages.success(request, _(u"Password updated"))
else:
form = ProfileForm(initial={'username':request.user.username,
'email':request.user.email,
'first_name':request.user.first_name,
'last_name':request.user.last_name,
'api_key': key.key},request=request)
return render(request, 'mquiz/profile/profile.html', {'form': form,})
def edit(request, profile_id):
profile = UserProfile.objects.get(id=profile_id)
if request.method == 'POST':
form = ProfileForm(request.POST, request.FILES)
if form.is_valid():
cd = form.cleaned_data
user_profile = UserProfile.objects.get(id=profile_id)
user_profile.pic = cd['pic']
user_profile.url = cd['url']
user_profile.mobile = cd['mobile']
user_profile.save()
return HttpResponseRedirect('/')
else:
form = ProfileForm(initial={
'id': profile.id,
'pic': profile.pic,
'url': profile.url,
'mobile': profile.mobile})
args = {}
args.update(csrf(request))
args['form'] = form
return render(request, "edit.html", args)
def profile(request, nickname, template_name = "account/profile.html"):
profile = get_object_or_404(Profile, nick = nickname)
if request.user.is_authenticated():
if request.user == profile.user:
is_me = True
else:
is_me = False
else:
is_me = False
if is_me:
if request.method == "POST":
if request.POST["action"] == "update":
profile_form = ProfileForm(request.POST, instance=profile)
profile = profile_form.save(commit=False)
profile.save()
profile_form = ProfileForm(instance=profile)
else:
profile_form = None
return render_to_response(template_name, {
"profile": profile,
"profile_form": profile_form,
"is_me": is_me,
"other_user": profile.user,
}, context_instance=RequestContext(request))
def profile(request):
if not request.user.is_authenticated():
raise PermissionDenied
record = request.user.courses_taken.all()
if request.method == 'POST':
form = ProfileForm(request.POST)
if form.is_valid():
# Validate
if form.cleaned_data['password0']:
if form.cleaned_data['password0'] == form.cleaned_data['password1']:
request.user.set_password(form.cleaned_data['password0'])
messages.success(request, "<strong>Success!</strong> Password changed.")
else:
messages.error(request, "The two passwords do not match.")
if request.user.option != form.cleaned_data['option']:
request.user.option = form.cleaned_data['option']
messages.success(request, "<strong>Success!</strong> Option selected.")
request.user.save()
return HttpResponseRedirect(reverse('profile'))
else:
form = ProfileForm(initial={'option': request.user.option})
return render_to_response(
'student/edit-profile.html',
{'form': form, 'record': record},
context_instance=RequestContext(request))
def profile_add():
form = ProfileForm(request.form)
if request.method == 'GET':
return render_template('profile_add.html',form=form)
if form.validate() and request.method == 'POST':
first_name = request.form['first_name']
last_name = request.form['last_name']
age = request.form['age']
file = request.files['image']
username = request.form['username']
sex = request.form['sex']
filename = file.filename
file.save(os.path.join('app/static/uploads', filename))
# write the information to the database
newprofile = Myprofile(first_name=first_name,
last_name=last_name,
age=age,
sex=sex,
username=username,
image='/static/uploads/'+filename)
db.session.add(newprofile)
db.session.commit()
return "{} {} was added to the database".format(request.form['first_name'],
request.form['last_name'])
return render_template('profile_add.html',form=form)
def profile(request, tplname='userprefs/profile.html'):
update_password = True
if True in events.raiseQueryEvent("PasswordChange", request.user):
update_password = False
if request.method == "POST":
form = ProfileForm(
update_password, request.POST, instance=request.user
)
if form.is_valid():
form.save()
if update_password and form.cleaned_data["confirmation"] != "":
request.session["password"] = encrypt(form.cleaned_data["confirmation"])
return ajax_simple_response(dict(
status="ok", respmsg=_("Profile updated")
))
return ajax_simple_response({
"status": "ko",
"errors": form.errors
})
form = ProfileForm(update_password, instance=request.user)
return ajax_simple_response({
"status": "ok",
"content": _render_to_string(request, tplname, {
"form": form
})
})
def activate(request, activation_key,
template_name='userena/activate_fail.html',
extra_context=None):
"""
Activate a user with an activation key.
"""
user = UserenaSignup.objects.activate_user(activation_key)
if user:
# Sign the user in.
auth_user = authenticate(identification=user.username,
check_password=False)
UserDetail.set_activation_datetime(auth_user)
login(request, auth_user)
if userena_settings.USERENA_USE_MESSAGES:
messages.success(request, _('Congratulations -- your Art of Gratitude account is confirmed!'),
fail_silently=True)
if request.method == 'POST':
form = ProfileForm(request.POST, user=user)
if form.is_valid():
form.save()
redirect_to = settings.LOGIN_REDIRECT_URL % {'username': user.username }
return redirect(redirect_to)
else:
if not extra_context: extra_context = {}
return ExtraContextTemplateView.as_view(template_name=template_name,
extra_context=extra_context)(request)
def profile(request): #处理个人资料功能
if not request.user.is_authenticated():
return redirect('/weblogin')
user = request.user
if request.method =='GET':
form = ProfileForm(instance=user, initial={
'name': user.webuser.name,
'telephone': user.webuser.telephone,
'hospital': user.webuser.hospital,
'position': user.webuser.position,
'department': user.webuser.department,
'abstract': user.webuser.abstract
})
if request.user.is_superuser:
return render(request, 'adminuser/person_page_info.html', {'form': form})
return render(request, 'webuser/person_page_info.html', {'form': form})
else:
form = ProfileForm(request.POST)
if form.is_valid():
webuser = Webuser.objects.get(user=request.user)
webuser.name = form.cleaned_data.get('name')
webuser.telephone = form.cleaned_data.get('telephone')
webuser.hospital = form.cleaned_data.get('hospital')
webuser.position = form.cleaned_data.get('position')
webuser.department = form.cleaned_data.get('department')
webuser.abstract = form.cleaned_data.get('abstract')
webuser.save()
messages.add_message(request, messages.SUCCESS, u'您的资料已经编辑成功.')
if request.user.is_superuser:
return render(request, 'adminuser/person_page_info.html', {'form': form})
else:
return render(request, 'webuser/person_page_info.html', {'form': form})
def post(self):
form = ProfileForm(data=self.request.POST)
if form.is_valid():
user = users.get_current_user()
username = self.request.get('username')
#profile = Profile.all().filter('user !=', user).filter('username ='******'username ='******'username_exists': ['%s is already exists'] }
profile = { 'username': username }
template_vars = { 'errors': errors, 'profile': profile }
self.render_response('profile/profile_edit.html', template_vars)
else:
profile = Profile.all().filter('user ='******'/profile')
else:
template_vars = { 'form': form }
self.render_response('profile/profile_edit.html', template_vars)
def register(request):
if request.method == "POST":
data = json.loads(request.raw_post_data)
uForm = UserForm(data = data)
pForm = ProfileForm(data = data)
aForm = None
if data['artist']:
aForm = ArtistForm(data = data)
if uForm.is_valid() and pForm.is_valid() and (aForm == None or aForm.is_valid()):
user = uForm.save()
user.save()
profile = pForm.save(commit = False)
profile.user = user
if not profile.invites:
profile.invites = 0
profile.save()
if aForm:
artist = aForm.save(commit = False)
artist.profile = profile
artist.save()
user = authenticate(username = data['username'],
password = data['password1'])
login(request, user)
resp = HttpResponse(json.dumps({'success': 'true'}), mimetype="application/json")
resp.status_code = 201
return resp
else:
error = dict(uForm.errors.items()
+ pForm.errors.items())
else:
error = "The request must be a POST"
resp = HttpResponse(json.dumps({'error': error}), mimetype="applcation/json")
resp.status_code = 400
return resp
def edit_profile(request):
'''
'''
user = request.user
form = ProfileForm()
if request.method == "POST":
form = ProfileForm(request.POST, request.FILES)
if form.is_valid():
data = form.cleaned_data
'''
if len(data['name']) > NAME_MAX_LEN * 3:
messages.warning(request, u'名号输入过长，被自动截断')
if len(data['signature']) > SIGNATURE_MAX_LEN * 3:
messages.warning(request, u'签名输入过长，被自动截断')
'''
form.save(user.userprofile, data)
messages.success(request, u'个人资料修改成功')
else:
messages.error(request, u'你的输入有误')
profile = request.user.userprofile
return render_to_response('settings/edit_profile.html',
{'time_limit': PROFILE_NAME_CHANGE_DAYS,
'form': form,
'name': profile.name,
'website': profile.website,
'signature': profile.signature,
'detail': profile.detail,
},
context_instance=RequestContext(request))
def profile(req):
g = get_object_or_404(Gentleman, pk=req.user.gentleman.id)
if req.method == 'POST':
pf = ProfileForm(req.POST, req.FILES, instance=g)
if pf.is_valid():
ng = pf.save()
if 'before_pic' in req.FILES:
g.before_pic.file = req.FILES['before_pic']
if 'after_pic' in req.FILES:
g.after_pic.file = req.FILES['after_pic']
ng.user_id = g.user_id
ng.id = g.id
ng.save()
pf = ProfileForm(instance=ng)
messages.info(req, 'Gentleman updated successfully.')
else:
pf = ProfileForm(instance=g)
return render(req, 'voting/profile.html', {'pf': pf })
def edit_user(request):
profile_form = ProfileForm(request.POST, instance=request.user)
if profile_form.is_valid():
profile_form.save()
messages.success(request, 'Yup, changes made.')
else:
messages.error(request, 'Nop, something is wrong.')
return redirect('view_user', request.user.id)
def post(self, request, pk=None):
if request.user.is_authenticated():
user = Profile.objects.get_or_create(user=request.user)[0]
form = ProfileForm(request.POST, request.FILES or None, instance=user)
if form.is_valid():
form.save()
return redirect("profile")
def test_create_profile(self):
form = ProfileForm({
'username': '******',
'password': '******',
'email': '*****@*****.**' })
self.assertTrue(form.is_valid(), 'Formularz jest niepoprawny.')
form = ProfileForm()
self.assertFalse(form.is_valid(), 'Formularz nie jest niepoprawny.')
def profile_edit(request):
data = request.POST or None
profile_form = ProfileForm(data, instance=request.user)
if profile_form.is_valid():
profile_form.save()
messages.success(request, "Profile saved")
elif not data is None:
messages.error(request, "Profile could not be saved, because of invalid data")
return render(request, "profiles/edit.html", {'form': profile_form})
def profile_view(request):
user = check_validation(request)
if user:
if request.method == "POST":
form = ProfileForm(request.POST, request.FILES)
if form.is_valid():
image = form.cleaned_data.get('avatar')
profile = User.objects.create(user=user, avatar=image)
profile.save()
path = str(BASE_DIR + profile.avatar.url)
client = ImgurClient(
"6fc30e7f6bd87be",
"0e21d82e47b11e66d7f6f3874cd269633c25c682")
profile.image_url = client.upload_from_path(path,
anon=True)['link']
profile.save()
return render(request, 'error.html')
app = ClarifaiApp(api_key=CLARIFAI_API_KEY)
model = app.models.get('nsfw-v1.0')
response = model.predict_by_url(url=profile.avatar_url)
concepts_value = response['outputs'][0]['data']['concepts']
for i in concepts_value:
if i['name'] == 'nsfw':
nudity_level = i['value']
if nudity_level >= 0.85:
print response['outputs'][0]['data']['concepts']
print nudity_level
profile.delete()
error_message = "You are trying to post an inappropriate photo!!"
return render(request, "error.html",
{'error_message': error_message})
else:
return redirect('/feed/')
else:
form = PostForm()
return render(request, "profile.html", {'form': form})
else:
return redirect('login')
def profile_edit(request, username=None):
if username is None:
p = request.user.get_profile()
user = request.user
else:
user = User.objects.get(username=username)
p = user.get_profile()
if request.method == 'POST':
user_form = UserForm(request.POST, instance=user)
profile_form = ProfileForm(request.POST, instance=p, editor=request.user)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
p = profile_form.save()
if 'is_active' in request.POST and request.user.has_perm('auth.change_user'):
user.is_active = True
user.save()
send_mail(
"Your myschoolcommute.com account has been approved",
"You may login at http://%s/%s" % (request.META['HTTP_HOST'], reverse('login'),),
settings.SERVER_EMAIL,
[user.email]
)
return HttpResponseRedirect(reverse('user_detail', args=[user.username]))
else:
user_form = UserForm(instance=user)
profile_form = ProfileForm(instance=p, editor=request.user)
profile_form.helper.add_input(Submit('submit', 'Save account'))
return render_to_response("accounts/edit.html", {
'user_form' : user_form, 'profile_form': profile_form, 'user': user
}, context_instance=RequestContext(request) )
def profile():
form = ProfileForm()
if request.method == 'POST':
if form.validate_on_submit():
username = form.username.data
if not User.query.filter_by(username=username).first():
user = User(username=username,
first_name=form.first_name.data,
last_name=form.last_name.data,
age=form.age.data)
db.session.add(user)
db.session.commit()
uploaded_file = request.files['image']
if uploaded_file and allowed_file(uploaded_file.filename):
filename = 'user_profile_{0}.{1}'.format(
user.user_id, uploaded_file.filename.split('.')[-1]
)
uploaded_file.save(os.path.join(app.config['UPLOAD_FOLDER'],
filename))
user.image = filename
db.session.commit()
return redirect(url_for('profiles'))
# User already exist. Can't create
flash("User with username %s already exist" % username)
for field, errors in form.errors.items():
for error in errors:
flash(u"Error in the %s field - %s" % (
getattr(form, field).label.text,
error
))
return render_template('profile_form.html', form=form)
def register(request):
if request.method == 'POST':
register = RegisterForm(request.POST, prefix='register')
usrprofile = ProfileForm(request.POST, prefix='profile')
print register
if register.is_valid() * usrprofile.is_valid():
user = register.save()
usrprof = usrprofile.save(commit=False)
usrprof.user = user
# usrprof.set_token()
usrprof.subscribed = '1'
usrprof.save()
return HttpResponse('congrats')
else:
return HttpResponse('errors')
else:
userform = RegisterForm(prefix='register')
userprofileform = ProfileForm(prefix='profile')
return render(request, 'accounts/register.html', {
'userform': userform,
'userprofileform': userprofileform
})
def configuracoes(request):
if request.method == 'POST':
form = ProfileForm(request.POST, instance=request.user.profile)
if form.is_valid():
form.save()
return redirect('principal')
else:
return redirect('configuracoes')
else:
form = ProfileForm(instance=request.user.profile)
return render(request, 'configuracoes.html', {'form': form})
def register(request):
if request.method == 'POST':
user_form = RegistrationForm(request.POST)
profile_form = ProfileForm(request.POST)
if user_form.is_valid() and profile_form.is_valid():
new_user = user_form.save()
p = Profile.objects.get(user=new_user)
profile_form = ProfileForm(request.POST, instance=p)
profile_form.save()
users_page = 'http://' + request.META['HTTP_HOST'] + reverse('user_list')
approve_page = 'http://' + request.META['HTTP_HOST'] + reverse('user_edit', args=[new_user.username])
message = "New user registration!\n\n%s\n%s, %s\nActivate user: %s\nView all users: %s" % (
new_user.username, new_user.first_name, new_user.last_name, approve_page, users_page,
)
try:
try:
g = Group.objects.get(name="Account Admins")
emails = [u.email for u in g.user_set.all()]
except:
# email to single email for now
# https://github.com/MAPC/myschoolcommute/issues/49
emails = ['*****@*****.**']
send_mail(
'myschoolcommute.com new user '+new_user.username,
message,
settings.SERVER_EMAIL,
emails
)
except:
#Problem finding group or emailing
mail_admins('myschoolcommute.com new user '+new_user.username, message)
return HttpResponseRedirect("/accounts/register/success/")
else:
profile_form = ProfileForm()
user_form = RegistrationForm()
profile_form.helper.add_input(Submit('submit', 'Create the account'))
return render_to_response("accounts/register.html", {
'user_form' : user_form, 'profile_form': profile_form
}, context_instance=RequestContext(request))
def profile(request):
customer = Customer.objects.get(user=request.user)
if request.method == 'POST':
form = ProfileForm(request.POST)
if not form.is_valid():
return render(request, 'info_profile.html', {
'customer': customer,
'form': form,
})
first_name = form.cleaned_data.get('first_name')
last_name = form.cleaned_data.get('last_name')
email = form.cleaned_data.get('email')
user = request.user
user.first_name = first_name
user.last_name = last_name
user.email = email
user.save()
customer.user = user
tel = form.cleaned_data.get('tel')
address = form.cleaned_data.get('address')
wechat = form.cleaned_data.get('wechat')
customer.tel = tel
customer.address = address
customer.wechat = wechat
customer.save()
form = ProfileForm(instance=request.user,
initial={
'email': request.user.email,
'first_name': request.user.first_name,
'last_name': request.user.last_name,
'tel': customer.tel,
'address': customer.address,
'wechat': customer.wechat
})
return render(request, 'info_profile.html', {
'customer': customer,
'form': form,
})
def view_user(request, user_id):
user = get_object_or_404(User, pk=user_id)
profile_form = ProfileForm(instance=user) if request.user == user else None
rank = (User.objects.count() - (User.objects.annotate(
num_shirts=Count('owns')).order_by('-num_shirts').filter(
num_shirts__lt=user.owns.count()).count()))
return render(
request, 'user.html', {
'pageuser': user,
'rank': rank,
'count_users': User.objects.count() - 1,
'profile_form': profile_form
})
def info():
user_id = g.current_login_id
user_profile = g.db.query(UserProfile).filter(
UserProfile.user_id == user_id).one()
if request.method == "POST":
form = ProfileForm(request.form)
if form.validate():
try:
user_profile.company_name = form.company_name.data
user_profile.contact_name = form.contact.data
user_profile.mobile = form.mobile.data
user_profile.company_addr = form.addr.data
g.db.flush()
success = u"修改用户资料成功"
except Exception, e:
log.error(e.message)
g.db.rollback()
errors = [
u"未知异常",
]
else:
errors = [v[0] for k, v in form.errors.iteritems()]
def add_profile():
"""Render form template"""
form = ProfileForm()
if (form.validate_on_submit()):
fname = form.firstname.data
lname = form.lastname.data
uname = form.username.data
uage = form.age.data
gen = form.gender.data
bio = form.biography.data
imagefolder = app.config["UPLOAD_FOLDER"]
img = form.image.data
imagename = secure_filename(img.filename)
img.save(os.path.join(imagefolder, imagename))
uid = random.randint(1000, 1999)
ctime = timeinfo()
profile = UserProfile(userid=uid,
first_name=fname,
last_name=lname,
username=uname,
age=uage,
gender=gen,
biography=bio,
image=imagename,
created_on=ctime)
db.session.add(profile)
db.session.commit()
flash('User Profile Added', 'success')
return redirect(url_for('home'))
flash_errors(form)
return render_template("add_profile.html", form=form)
def edit_profile(request):
profile = Profile.objects.get(user = request.user)
if request.method == 'POST':
profileForm = ProfileForm(request.POST, instance = profile)
if profileForm.is_valid() and request.user.is_authenticated():
profile = profileForm.save(commit = False)
profile.user = request.user
profile.is_active = True
profile.save()
profileForm.save_m2m()
return HttpResponseRedirect('profile/' + request.user.username)
else:
return render(request, 'editProfile.html', {'profileForm': profileForm})
else:
profileForm = ProfileForm(instance = profile)
return render(request, 'editProfile.html', {'profileForm': profileForm})
def create_profile(request):
# REMEMBER TO HANDLE UNAUTHENTICATED USERS
if request.method == 'POST':
profileForm = ProfileForm(request.POST)
if profileForm.is_valid() and request.user.is_authenticated():
profile = profileForm.save(commit = False)
profile.user = request.user
profile.is_active = True
profile.save()
profileForm.save_m2m()
return HttpResponseRedirect('home.html')
else:
return render(request, 'createProfile.html', {'form': profileForm})
else:
profileForm = ProfileForm()
return render(request, 'createProfile.html', {'form': profileForm})
def profile():
form = ProfileForm()
if request.method == 'POST':
if form.validate() == False:
return render_template('profile.html', form=form)
else:
user = db.session.query(User).filter_by(
email=session['email']).first()
if form.firstname.data:
user.firstname = form.firstname.data
if form.lastname.data:
user.lastname = form.lastname.data
if form.password.data:
user.set_password(form.password.data)
db.session.commit()
return redirect(url_for('contacts'))
elif request.method == 'GET':
return render_template('profile.html', form=form)
def change_profile():
form = ProfileForm()
if form.validate():
try:
user = g.user
user.profile = form.profile.data
user.fullname = form.fullname.data
user.email = form.email.data
user.birthday = form.birthday.data
user.country = form.country.data
user.state_province_region = form.state_province_region.data
user.city = form.city.data
user.occupation = form.occupation.data
user.institution = form.institution.data
user.agree_mailer = form.agree_mailer.data
db.session.commit()
flash(dictionary()["updated_profile"], "success")
except:
flash(dictionary()["500"], "danger")
return render_template("user/edit.html", form=form)
def preferences_general(request):
shop = request.shop
profile = shop.admin.get_profile()
preferences = Preference.get_preference(shop)
form = GeneralPreferenceForm(request.POST or None, instance=preferences)
profile_form = ProfileForm(request.POST or None, instance=profile)
if form.is_valid() and profile_form.is_valid():
preferences = form.save(commit=False)
preferences.shop = shop
preferences.save()
profile = profile_form.save(commit=True)
shop.update_geolocation()
request.flash['message'] = unicode(
_("General preferences successfully saved."))
request.flash['severity'] = "success"
return HttpResponseRedirect(reverse('preferences_general'))
return render_to_response('preferences/preferences_general.html', {
'form': form,
'profile_form': profile_form
}, RequestContext(request))
def profile():
form = ProfileForm()
if(current_user.is_authenticated):
data = getUserData(["UserInfor", "UserLeague"])
form.username = data['UserInfor'][0]['Username']
form.email = data['UserInfor'][0]['Email']
form.country = data['UserInfor'][0]['Country']
form.leagueID = data['UserLeague'][0]['LeagueID']
return render_template('profile.html', form=form)
def newProfile():
form = ProfileForm()
if request.method == 'GET':
return render_template('newProfile.html', form=form)
elif request.method == 'POST':
if form.validate_on_submit():
firstname = form.firstname.data
lastname = form.lastname.data
gender = form.gender.data
email = form.email.data
location = form.location.data
bio = form.bio.data
dateCreated = datetime.date.today()
photo = form.photo.data
filename = secure_filename(photo.filename)
photo.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
userid = generateUserId(firstname, lastname)
newUser = UserProfile(userid=userid,
first_name=firstname,
last_name=lastname,
gender=gender,
email=email,
location=location,
biography=bio,
pic=filename,
created_on=dateCreated)
db.session.add(newUser)
db.session.commit()
flash("Profile Successfully Created", "success")
return redirect(url_for("profiles"))
def register(request):
if "back_button_register" in request.POST:
return HttpResponseRedirect('/login')
elif len(request.POST) > 0:
form = ProfileForm(request.POST)
if form.is_valid():
form.save(commit=True)
return HttpResponseRedirect('/login')
else:
return render(request, 'user_profile.html', {'ban': form})
else:
form = ProfileForm()
return render(request, 'user_profile.html', {'ban': form})
def my_profile(request):
if request.method == "POST":
form = ProfileForm(instance=request.user, data=request.POST)
if form.is_valid():
form.save()
messages.success(request, "Your account is now up to date !")
else:
form = ProfileForm(instance=request.user)
context = {}
context.update({"form": form})
return render(request, 'registration/my_profile.html', context)
def create_profile(request, args):
user_id = request.user.id
logging.debug("TEST CREATE PROFILE")
profile = Profile.objects.get(id=user_id)
if request.method == "POST":
form = ProfileForm(request.POST, instance=profile)
if form.is_valid():
print "CREATE PROFILE FORM VALID"
form.save()
return HttpResponseRedirect('/participate/profile')
else:
form = ProfileForm(instance=profile)
return render(request, 'accounts/create_profile.html', {'form': form})
def change_profile():
form = ProfileForm()
if form.validate_on_submit():
if form.password.data != form.password_again.data:
return render_template('change_profile.html', title='Изменение профиля',
form=form,
message="Пароли не совпадают")
db_sess = db_session.create_session()
if db_sess.query(User).filter(User.id == form.email.data).first():
if form.email.data == flask_login.current_user.id:
pass
else:
return render_template('change_profile.html', title='Изменение профиля',
form=form,
message="Такой пользователь уже есть")
db_sess = db_session.create_session()
user = db_sess.query(User).filter(User.id == flask_login.current_user.id).first()
user.id = form.email.data
user.set_password(form.password.data)
user.Name = form.name.data
db_sess.commit()
login_user(user, remember=False)
return redirect('/profile')
return render_template('change_profile.html', title='Изменение профиля', form=form)
def change_profile():
form = ProfileForm()
try:
user = g.user
user.fullname = form.fullname.data
user.gender = form.gender.data
user.website = form.website.data
user.bio = form.bio.data
db.session.commit()
flash("Profile updated successfully!", "success")
except:
flash("Something went wrong!", "danger")
return render_template("account/edit_profile.html", form=form)
def edit():
form = ProfileForm()
form.profile.data = g.user.profile
form.fullname.data = g.user.fullname
form.email.data = g.user.email
form.birthday.data = g.user.birthday
form.country.data = g.user.country
form.state_province_region.data = g.user.state_province_region
form.city.data = g.user.city
form.occupation.data = g.user.occupation
form.institution.data = g.user.institution
form.agree_mailer.data = g.user.agree_mailer
return render_template("user/edit.html", form=form)
def post(self, request):
success_message = ''
user = User.objects.create_user(request.POST.get('username', ''),
request.POST.get('email', ''),
request.POST.get('pass', ''))
user_form = ProfileForm()
#form = ProfileForm()
#form.usuario = user_form
#form.centro = request.POST.get('centro', '')
#form.responsable = request.POST.get('resp', '')
#form.fax = request.POST.get('fax', '')
if user_form.is_valid():
user.save()
return redirect('reports/home')
else:
success_message = u'¡Guardado con éxito!'
context = {'form': user_form, 'success_message': success_message}
return render(request, 'users/new_user.html', context)
def profile():
form = ProfileForm()
file_folder = app.config['UPLOAD_FOLDER']
if request.method == "POST" and form.validate_on_submit():
fname = request.form['firstname']
lname = request.form['lastname']
username = request.form['username']
userid = randomnum()
age = request.form['age']
gender = request.form['gender']
image = request.files['image']
biography = request.form['biography']
created = time.strftime("%-d,%b,%Y")
filename = secure_filename(image.filename)
image.save(os.path.join(file_folder, filename))
user = UserProfile(fname, lname, username, userid, age, gender,
biography, filename, created)
db.session.add(user)
db.session.commit()
flash('Profile Created')
return redirect(url_for('profiles'))
flash_errors(form)
return render_template('profileform.html', form=form)
def create_userprofile():
form = ProfileForm()
if request.method == 'POST':
if form.validate_on_submit():
username = form.username.data
firstname = form.first_name.data
lastname = form.last_name.data
age = form.age.data
biography = form.biography.data
email = form.email.data
image = form.image.data
gender = form.gender.data
# save user to database
user = UserProfile(id, username, firstname, lastname, age,
biography, email, image, gender)
db.session.add(user)
db.session.commit()
flash('User successfully added')
return redirect(url_for('login'))
flash_errors(form)
return render_template('profile.html', form=form)
def profile_add():
if request.method == 'POST':
first_name = request.form['first_name']
last_name = request.form['last_name']
# write the information to the database
newprofile = Myprofile(first_name=first_name, last_name=last_name)
db.session.add(newprofile)
db.session.commit()
return "{} {} was added to the database".format(
request.form['first_name'], request.form['last_name'])
form = ProfileForm()
return render_template('profile_add.html', form=form)
def profile(request):
"""
Form for modifying and adding profile values
"""
if request.method == 'POST':
form = ProfileForm(request.POST, instance=request.user)
email = request.POST.get('email', '')
if not email == '' and not email == request.user.email:
#confirm the email
salt = sha_constructor(str(random())).hexdigest()[:5]
confirmation_key = sha_constructor(salt + email).hexdigest()
current_site = Site.objects.get_current()
path = reverse('confirm_email', args=[confirmation_key])
activate_url = u"http://%s%s" % (unicode(
current_site.domain), path)
context = {
"user": request.user,
"activate_url": activate_url,
"current_site": current_site,
"confirmation_key": confirmation_key,
}
subject = render_to_string("email_confirmation_subject.txt",
context)
# remove superfluous line breaks
subject = "".join(subject.splitlines())
message = render_to_string("email_confirmation_message.txt",
context)
print email
send_mail(
subject, message,
getattr(settings, 'DEFAULT_FROM_EMAIL',
'do-not-reply@%s' % current_site), [email])
Email.objects.create(owner=request.user,
email=email,
email_is_verified=False,
sent=datetime.now(),
confirmation_key=confirmation_key)
form.save()
return HttpResponseRedirect(request.POST.get('next', '/'))
else:
form = ProfileForm(instance=request.user)
next = request.GET.get('next', '/')
return render_to_response('profile.html', {
'form': form,
'next': next
},
context_instance=RequestContext(request))
def edit_profile(request):
"""
Show and edit user profile.
"""
username = request.user.username
if request.method == 'POST':
form = ProfileForm(request.POST)
if form.is_valid():
nickname = form.cleaned_data['nickname']
intro = form.cleaned_data['intro']
try:
profile = Profile.objects.get(user=request.user.username)
except Profile.DoesNotExist:
profile = Profile()
profile.user = username
profile.nickname = nickname
profile.intro = intro
profile.save()
messages.success(request, _(u'Successfully edited profile.'))
# refresh nickname cache
refresh_cache(request.user.username)
return HttpResponseRedirect(reverse('edit_profile'))
else:
messages.error(request, _(u'Failed to edit profile'))
else:
try:
profile = Profile.objects.get(user=request.user.username)
form = ProfileForm({
'nickname': profile.nickname,
'intro': profile.intro,
})
except Profile.DoesNotExist:
form = ProfileForm()
# common logic
try:
server_crypto = UserOptions.objects.is_server_crypto(username)
except CryptoOptionNotSetError:
# Assume server_crypto is ``False`` if this option is not set.
server_crypto = False
return render_to_response('profile/set_profile.html', {
'form': form,
'server_crypto': server_crypto,
},
context_instance=RequestContext(request))
def jobapply():
viewprofile1 = viewprofile(request.args.get('username'))
form = ProfileForm()
if request.method == 'POST':
db = get_db()
username = request.args.get('username')
jobid = request.args.get('jobid')
if jobid:
db.execute(
'INSERT INTO jobsapplied(ID, username, status) VALUES (?,?,?)',
(jobid, username, 'Applied'))
c1 = db.execute('''UPDATE jobs SET status=? WHERE ID=?''',
['Applied', jobid])
db.commit()
return redirect(url_for('home', username=request.args.get('username')))
elif request.method == 'GET' and viewprofile1 != "":
db = get_db()
jobid = request.args.get('jobid')
c = db.execute('select * from jobs where ID=?', [jobid])
u = c.fetchone()
if u:
jobexists = dict({
"job_title": u[1],
"company_name": u[2],
"summary": u[3],
"location": u[4],
"status": u[5],
"id": u[0]
})
else:
jobexists = ""
return render_template('jobapply.html',
keys=request.args.get('username'),
viewprofile1=viewprofile1,
form=form,
jobid=request.args.get('jobid'),
jobs=jobexists)
if viewprofile1 == "":
flash('Please add you profile information!')
return redirect(url_for('home', username=request.args.get('username')))
