def account_page(request): if request.method == 'POST': # If the form has been submitted... form = AccountForm(request.POST) # A form bound to the POST data if form.is_valid(): # All validation rules pass cleaned_data = form.cleaned_data username = cleaned_data['username'] first_name = cleaned_data['first_name'] last_name = cleaned_data['last_name'] email = cleaned_data['email'] password_old = cleaned_data['password_old'] password_new = cleaned_data['password_new'] if authenticate(username=username, password=password_old): u = User.objects.get(username__exact=username) if password_new > '': u.set_password(password_new) if first_name > '': u.first_name = first_name if last_name > '': u.last_name = last_name if email > '': u.email = email u.save() return {'status': 'success'} else: return {'status': 'error', 'message': 'Wrong password!'} else: return {'status': 'error', 'message': 'Invalid form!'} else: form = AccountForm() return render_to_response('account.html', { 'form': form, }, context_instance=RequestContext(request))
def account_page(request): if request.method == 'POST': # If the form has been submitted... form = AccountForm(request.POST) # A form bound to the POST data if form.is_valid(): # All validation rules pass cleaned_data = form.cleaned_data username = cleaned_data['username'] first_name = cleaned_data['first_name'] last_name = cleaned_data['last_name'] email = cleaned_data['email'] password_old = cleaned_data['password_old'] password_new = cleaned_data['password_new'] if authenticate(username=username, password=password_old): u = User.objects.get(username__exact=username) if password_new > '': u.set_password(password_new) if first_name > '': u.first_name = first_name if last_name > '': u.last_name = last_name if email > '': u.email = email u.save() return {'status':'success'} else: return {'status':'error', 'message':'Wrong password!'} else: return {'status':'error', 'message':'Invalid form!'} else: form = AccountForm() return render_to_response('account.html', {'form': form,}, context_instance=RequestContext(request))
def create_account(): form = AccountForm() completion_msg = "" if form.validate_on_submit(): if form.save.data: new_account = Account(name=form.name.data, pnumber=form.pnumber.data, email=form.email.data, street=form.street.data, city=form.city.data, state=form.state.data, postal=form.postal.data, country=form.country.data, notes=form.notes.data) db.session.add(new_account) try: db.session.commit() except: completion_msg = "Failed to create account. Please try again." if completion_msg == "": completion_msg = "Success! The account has been saved." return redirect(url_for('view_account')) else: completion_msg = "Failed to create account. Please try again." return render_template("create_account.html", form=form, completion_msg=completion_msg)
def add_account(): """ Add a account to the database """ check_admin() add_account = True form = AccountForm() if form.validate_on_submit(): account = Account(AccNum=form.AccNum.data, name=form.name.data, AccCategory=form.AccCategory.data, SaccCategory=form.SaccCategory.data, balance=form.balance.data, Comment=form.Comment.data) try: # add department to the database db.session.add(account) db.session.commit() flash('You have successfully added a new entry.') except: # in case department name already exists flash('Error: entry name already exists.') # redirect to departments page return redirect(url_for('admin.list_account')) # load department template return render_template('admin/accounts/account.html', action="Add", add_account=add_account, form=form, title="Add Account")
def _handler(self, post=False): user = users.get_current_user() if user: accounts = Account.all().filter('user ='******'name').run() if post: form = AccountForm(data=self.request.POST) if form.is_valid(): # Save the data, and redirect to the view page entity = form.save(commit=False) entity.user = user entity.put() self.redirect(self.request.uri) return else: form = AccountForm() path = os.path.join(os.path.dirname(__file__), 'templates/accounts.html') self.response.out.write(template.render(path, { 'accounts': accounts, 'form': form, 'user': user, 'logout_url': users.create_logout_url("/") })) else: self.redirect(users.create_login_url(self.request.uri))
def edit_account(account_id): account = Account.query.get_or_404(account_id) form = AccountForm(obj=account) completion_msg = "" if form.validate_on_submit(): if form.save.data: account.name = form.name.data account.pnumber = form.pnumber.data account.email = form.email.data account.street = form.street.data account.city = form.city.data account.state = form.state.data account.postal = form.postal.data account.country = form.country.data account.notes = form.notes.data try: db.session.commit() except: completion_msg = "Failed to update account. Please try again." if completion_msg == "": completion_msg = "Success! The account has been saved." return redirect(url_for('view_account')) else: completion_msg = "Failed to update account. Please try again." return render_template("edit_account.html", form=form, completion_msg=completion_msg)
def account(request): """View for displaying and modyfing acount information""" if request.method == 'POST': form = AccountForm(request.POST) if form.is_valid(): email = form.cleaned_data['email'] ssh_public_key = form.cleaned_data['ssh_public_key'] username = request.user.username user = LdapUser.objects.get(uid=username) user.mail = email keys = user.ssh_public_key keys_new = [] for key in keys: if key.startswith(('ssh-dss','ssh-rsa',)): keys_new.append(ssh_public_key) else: keys_new.append(key) user.ssh_public_key = keys_new user.save() return render_to_response('account.html', {'form': form, 'changed': 1}, context_instance=RequestContext(request)) else: username = request.user.username user = LdapUser.objects.get(uid=username) form = AccountForm(initial={'email': user.mail, 'ssh_public_key': find_primary_key(user)}) return render_to_response('account.html', {'form': form,}, context_instance=RequestContext(request))
def edit(request, object_id, template_name='accounts/accounts_edit.html', next='accounts_detail'): # object = get_one_or_404(Account, id=object_id) object = get_one_or_404(Account, id=ObjectId(object_id), user=request.user, perm='can_edit') user = request.user if not (user.is_staff or object.local_id == str(user.id)): raise PermissionDenied() if request.method == 'POST': form = AccountForm(request.POST, instance=object) locationform = LocationUpdateForm(request.POST, instance=object) if form.is_valid(request.user) and locationform.is_valid(): acct = get_account(request.user.id) object.locations = locationform.locations object.save() increment_resource_crud('account_edit', account=acct) object = form.save(False) object.save(reindex=True) return HttpResponseRedirect(reverse(next, args=[object.id])) else: form = AccountForm(instance=object) locationform = LocationUpdateForm(instance=object) template_context = { 'form': form, 'object': object, 'locationform': locationform, 'new': False } return render_to_response( template_name, template_context, RequestContext(request) )
def account_settings(): form = AccountForm() formpass = ChangePasswordForm() error = '' sel_tab = 1 user = UserAccount.query.filter(UserAccount.id==g.user.id).one() if form.validate_on_submit(): user.username = form.username.data user.email = form.email.data db.session.add(user) db.session.commit() flash ('Changes saved.') form.username.data = user.username form.email.data = user.email if request.method == 'POST' and formpass.submit_pass: sel_tab = 2 if formpass.validate_on_submit(): password = md5.md5(formpass.password.data).hexdigest() user1 = UserAccount.query.filter(and_(UserAccount.id==g.user.id, UserAccount.password==password)).first() if not user1: error = 'Invalid password.' else: newpassword = md5.md5(formpass.newpassword.data).hexdigest() user1.password = newpassword db.session.add(user1) db.session.commit() flash ('New password saved.') return render_template('account.html', form=form, formpass=formpass, site_data=site_data(), navigation=return_navigation(), error=error, sel_tab=sel_tab)
def do_create_account(): form = AccountForm(request.form) account = Account() form.populate_obj(account) if form.validate_on_submit(): account.save() return redirect(url_for("app_blueprint.show_accounts")) return render_template("account.html", form=form), 400
def make_account(request): if request.method == 'POST': form = AccountForm(request.POST) if form.is_valid(): return render(request, 'account_info.html', {'data': json.dumps(form.cleaned_data)}) else: form = AccountForm() return render(request, 'account.html', {'form': form})
def account_add(request): "Add a new mail account" form = AccountForm(request.POST or None) form.fields['domain'].queryset = get_domains(request.user) if form.is_valid(): ac = form.save(commit=False) ac.set_password(form.cleaned_data['password']) ac.save() return redirect('limeade_mail_account_list') return render_to_response("limeade_mail/account_add.html", {"form": form}, context_instance = RequestContext(request))
def edit_account(request, pk): """ Edit an email account. """ account = get_object_or_404(SMTPAccount, pk=pk, owner=request.user) account_form = AccountForm(instance=account) if request.method == "POST": account_form = AccountForm(request.POST, instance=account) if account_form.is_valid(): account = account_form.save() messages.success(request, "%s updated" % account.email_address) return redirect("view_account", account.id) return render(request, "accounts/edit.html", {"account": account, "form": account_form})
def create_account(request): """ Create a new email account. """ account_form = AccountForm() if request.method == "POST": account_form = AccountForm(request.POST) if account_form.is_valid(): account = account_form.save(commit=False) account.owner = request.user account.save() messages.success(request, "%s added" % account.email_address) return redirect("view_account", account.id) return render(request, "accounts/create.html", {"form": account_form})
def post(self, request): try: log.info("Entering SignUp View") log.debug("Signup Customer Request Details - {0}".format(request.POST)) form = AccountForm(request.POST) if form.is_valid(): log.debug("Form is Valid") log.debug( Account.objects.filter( email=request.POST.get('email'), phone_number=request.POST.get('phone_number'))) is_account_already_exits_with_email = Account.objects.filter( email=request.POST.get('email')) if is_account_already_exits_with_email: return render( request, 'finance/signup.html', { 'context_dict': 'Account already exists with the email provided'}) is_account_already_exits_with_phone_number = Account.objects.filter( email=request.POST.get('phone_number')) if is_account_already_exits_with_phone_number: return render(request, 'finance/signup.html', {'context_dict': 'Account already exists with the phone number provided'}) model_instance = form.save(commit=False) model_instance.created_by = 'customer' model_instance.created_datetime = timezone.now() model_instance.save() request.session['account_id'] = model_instance.account_id log.debug( "Account Created Successfully and added account_id to session - {0}".format(request.session['account_id'])) return HttpResponseRedirect(reverse('dashboard')) else: log.debug("Form is not Valid") form = AccountForm() extra_context = {} extra_context['form'] = form return render('finance/signup.html', extra_context, context_instance=RequestContext(request)) except Exception as e: log.error(e) log.error(form.errors)
def account_add(): form = AccountForm() if current_user.is_manager: form.role.choices = [(current_user.MANAGER, 'Manager'),(current_user.ADMIN, 'Admin')] if form.validate_on_submit(): account = User(form.username.data, form.password.data, form.email.data, form.displayname.data, form.role.data) account.language = form.language.data account.organisations = form.organisations.data db.session.add(account) db.session.commit() flash(_('Account added')) return redirect(url_for("profil.accounts")) return render_template('account_add.html', form=form)
def account_options(request): basic = get_basic(request) try: prof = Profile.objects.get(user=request.user) except ObjectDoesNotExist: prof = Profile() if request.method == 'POST': form = AccountForm(request.POST, instance=prof) if form.is_valid(): obj = form.save(commit=False) obj.user = User.objects.get(id=request.user.id) obj.save() else: form = AccountForm(instance=prof) return render(request, 'accountoptions.html', {'form': form, 'basic': basic})
def createaccount(self): form = AccountForm.RegisterForm() formLogin = AccountForm.LoginForm(request.form) if request.method == 'GET': if g.user.is_authenticated == False: return render_template('createaccount.html', form=form, formLogin=formLogin) else: return redirect(url_for('index')) elif request.method == 'POST': if request.form.get('login', None) == 'Login': return authenticatePopUpLogin(formLogin, 'index') return createUser(form, formLogin)
def account_add(request): """Add a new mail account. :param request: the request object :returns: an edit form template """ form = AccountForm(request.POST or None) form.fields['domain'].queryset = get_domains(request.user) if form.is_valid(): ac = form.save(commit=False) ac.set_password(form.cleaned_data['password']) ac.save() return redirect('limeade_mail_account_list') return render_to_response("limeade_mail/account_add.html", {"form": form}, context_instance = RequestContext(request))
def add_collection(self): form = AccountForm.LoginForm(request.form) if self.request.method == 'GET': return render_template('add_collection.html', user=current_user, formLogin=form) elif self.request.method == 'POST': parsed_json = json.loads(self.request.data) print current_user product_id = None for data in parsed_json: print "the data is %s" % data if ('collection_title' in data): produc = Product( title=data['collection_title'], description=data['collection_description'], user_id=g.user.id) product_id = InsertRow(produc) elif (product_id is not None): prodItem = ProductItem( image_url=data['image_url'], image_description=data['image_description'], product_id=product_id) Item_id = InsertRow(prodItem) return self.request.data
def search_customer(): if request.method == 'GET': account_search = AccountSearchForm() return render_template('account_search.html', user=current_user.type, form=account_search) elif request.method == 'POST': account_search = AccountSearchForm(request.form) account = None if account_search.customer_id.data: account = Account.query.filter_by( ws_cust_id=int(account_search.customer_id.data)).first() elif account_search.account_id.data: account = Account.query.filter_by( act_id=int(account_search.account_id.data)).first() else: flash('Invalid customer') if account: selected_account = AccountForm() selected_account.customer_id.data = account.ws_cust_id selected_account.account_id.data = account.act_id selected_account.account_type.data = 'Savings' if account.ws_acct_type == 'S' else 'Current' selected_account.balance.data = account.ws_acct_balance return render_template('search_customer.html', form=selected_account) else: flash('Account does not exist', 'danger') flash('Please enter a value', 'warning') return redirect(url_for('app.search_customer'))
def get_context_data(self, *args, **kwargs): context = super(AccountSetPasswordView, self).get_context_data(*args, **kwargs) context['object'] = self.get_object() context['form'] = AccountForm(instance=self.get_object()) context['form2'] = PasswordChangeForm(self.get_object(), **self.get_form_kwargs()) return context
def add_acct(): print (str(session['email']),'is on add_acct') form = AccountForm() if request.method == 'POST': if form.validate() == False: return render_template('addacct.html', form=form) else: newacct = Accounts(form.name.data, session['email']) db_session.add(newacct) db_session.commit() flash('You created a new account.') print (str(session['email']),'has successfully added a new account') return redirect(url_for('home/')) elif request.method == 'GET': print (str(session['email']),'is still on add_acct') return render_template('addacct.html', form=form)
def view_accounts(): page = request.args.get('page', 1) q = request.args.get('q') accounts = restful.GetAccounts(int(page), q) if not accounts.has_key(restful.ITEM_OBJECTS): return redirect(url_for('view_accounts')) accountforms = [ logic.GetAccountFormById(x[restful.ITEM_ID]) for x in accounts[restful.ITEM_OBJECTS] ] while None in accountforms: accountforms.remove(None) if request.method == 'POST': form = AccountForm(request.form) if request.form.has_key('delete'): orm.db.session.delete(orm.Account.query.get(int(form.id.data))) orm.db.session.commit() return redirect(url_for('view_accounts', page=page, q=q)) form = PageInfo() logic.LoadBasePageInfo('所有用户', '查看', form) return render_template('view_accounts.html', forms=accountforms, form=form, paging=restful.GetPagingFromResult(accounts))
def account_add(request): """Add a new FTP account. :param request: the request object :returns: an edit form template """ form = AccountForm(request.POST or None) form.fields['vhost'].queryset = get_vhosts(request.user) if form.is_valid(): ac = form.save(commit=False) ac.set_password(form.cleaned_data['password']) ac.save() return redirect('limeade_ftp_account_list') return render_to_response("limeade_ftp/account_add.html", {"form": form}, context_instance = RequestContext(request))
def about(self): """ To address user pop up login , we have to pass formLogin to each page """ formLogin = AccountForm.LoginForm(request.form) if request.method == 'GET' : return render_template('about.html',formLogin=formLogin) if request.method == 'POST' : if request.form.get('login', None) == 'Login' : return AccountController.authenticatePopUpLogin(formLogin,'about')
def index(self): formLogin = AccountForm.LoginForm(request.form) if request.method == 'GET': return render_template('index.html', formLogin=formLogin) if request.method == 'POST': if request.form.get('login', None) == 'Login': return AccountController.authenticatePopUpLogin( formLogin, 'index')
def editaccount(self): user = current_user form = AccountForm.EditAccountForm(request.form, user) if (request.method == 'GET'): return render_template('editaccount.html', form=form) elif (request.method == 'POST'): return editUser(form) return render_template('editaccount.html', form=form)
def register(request): if request.method == 'POST': acct_form = AccountForm(request.POST) if acct_form.is_valid(): #create user username = acct_form.cleaned_data['username'] email = acct_form.cleaned_data['email'] password = acct_form.cleaned_data['password1'] user = User.objects.create_user(username, email, password) user.save() else: response = {} response['errors'] = acct_form.errors return JsonResponse(response, safe=False) return HttpResponse(status=200)
def show_account(account_id): account = Account.get_by_id(account_id) subscriptions = account.get_subscriptions(active_only=True) form = AccountForm(obj=account) return render_template("account.html", form=form, account=account, subscriptions=subscriptions)
def edit(request, object_id, template_name='engine_groups/edit.html'): object = get_one_or_404(id=object_id) if request.method == 'POST': form = AccountForm(request.POST, instance=object) if form.is_valid(): g = form.save() return HttpResponseRedirect(reverse('group', args=[object.id])) else: form = AccountForm(instance=object) template_context = {'form': form} return render_to_response( template_name, template_context, RequestContext(request) )
def create_user(): form = AccountForm(request.form) if form.validate(): user = models.get_user(form.data['username']) if user != None: message = "User already exists. Please choose another username." return render_template("create.html", form=form, message=message) elif form.data['password'] != form.data['auth_pass']: message = "Passwords do not match." return render_template("create.html", form=form, message=message) else: new_user = User(name=form.data['username'], password=form.data['password'], role="user") g.db.add(new_user) login_user(new_user) return redirect(url_for("home")) print form.data return render_template("create.html", form=form, message=None)
def edit_account(request, username): person = get_object_or_404(DjangoPerson, user__username = username) if request.method == 'POST': form = AccountForm(request.POST) if form.is_valid(): person.openid_server = form.cleaned_data['openid_server'] person.openid_delegate = form.cleaned_data['openid_delegate'] person.save() return HttpResponseRedirect('/%s/' % username) else: form = AccountForm(initial = { 'openid_server': person.openid_server, 'openid_delegate': person.openid_delegate, }) return render(request, 'edit_account.html', { 'form': form, 'person': person, 'user': person.user, })
def account(): img = url_for('static', filename='profile_pics/' + current_user.image) form = AccountForm() if form.validate_on_submit(): if form.picture.data: random_hex = secrets.token_hex(8) _, p_ext = os.path.splitext(form.picture.data.filename) p_fn = random_hex + p_ext picture_path = os.path.join(app.root_path, 'static/profile_pics', p_fn) form.picture.data.save(picture_path) db.update_picture(p_fn, current_user.username) current_user.image = p_fn flash('Picture Successfully Updated', 'success') return redirect(url_for('account')) return render_template('account.html', title='Account', form=form, image_file=img)
def account(): form = AccountForm() if form.validate_on_submit(): # Update user picture if form.picture.data: picture_file = save_picture(form.picture.data) current_user.image_file = picture_file # Update user info current_user.username = form.username.data current_user.email = form.email.data db.session.commit() flash("Your account has been updated!", 'success') return redirect(url_for('account')) elif request.method == 'GET': # Prepopulate field with user info form.username.data = current_user.username form.email.data = current_user.email image_file = url_for('static', filename='images/' + current_user.image_file) return render_template('account.html', image_file=image_file, form=form)
def view_account(): account_id = request.args.get('id') q = request.args.get('q') if q is not None: return redirect(url_for('view_accounts', page=1, q=q)) form = AccountForm(request.form) if request.method == 'POST' and form.validate(): if form.id.data: account = orm.Account.query.get(int(form.id.data)) account.username = form.telephone.data account.name = form.telephone.data account.telephone = form.telephone.data account.role = 0 account.flag_telephone = 1 if form.flag_telephone.data else 0 account.checkcode = form.checkcode.data account.source = form.source.data account.dtcreate = form.dtcreate.data orm.db.session.commit() else: account = orm.Account(form.telephone.data, '1234', form.telephone.data, form.telephone.data, 0, 1 if form.flag_telephone.data else 0, '1234', form.source.data, form.dtcreate.data) orm.db.session.add(account) orm.db.session.commit() form.id.data = account.id return redirect(url_for('view_account')) elif request.method == 'GET' and account_id: form = logic.GetAccountFormById(account_id) logic.LoadBasePageInfo('修改用户', '输入并确定', form) else: logic.LoadBasePageInfo('新建用户', '输入并确定', form) if form.id.data: account = orm.Account.query.get(int(form.id.data)) form.account = account return render_template('view_account.html', form=form)
def index(request): if not request.user.is_authenticated(): return render(request, 'login.html', locals()) try: account = Account.objects.get(user=request.user) except Account.DoesNotExist: account = Account(user=request.user) if request.POST: form = AccountForm(request.POST, instance=account) if form.is_valid(): account = form.save() return redirect('/') else: form = AccountForm(instance=account) messages = Message.objects.all().order_by('-sent')[:50] social = request.user.social_auth.get() twitter = social.extra_data return render(request, 'index.html', locals())
def index(id): is_account_popup_active = "" accounts_form = AccountForm(request.form) accounts_form.hdn_account_id.data = id if id != 0 and request.method != "POST": db_account = Account.get_accounts(id) accounts_form.hdn_account_id.data = db_account[0]["ID"] accounts_form.account_type.process_data(db_account[0]["TYPE"]) accounts_form.full_address.data = db_account[0][ "ACCOUNT_HOLDER_ADDRESS"] accounts_form.full_name.data = db_account[0]["NAME"] accounts_form.mobile.data = db_account[0][ "ACCOUNT_HOLDER_CONTACT_NUMBER"] accounts_form.account_number.data = db_account[0][ "ACCOUNT_HOLDER_BANK_DETAILS"] is_account_popup_active = "active" transaction_form = CreditDebitForm() transaction_form.FROM_ACCOUNT.choices = Account.get_account_by_type(1) transaction_form.TO_ACCOUNT.choices = Account.get_account_by_type(2) print(request.method) if request.method == "POST": if accounts_form.validate(): Account.create_account(accounts_form, id) return redirect(url_for("index", id=0)) else: is_account_popup_active = "active" return render_template( "index.html", accounts=Account.get_accounts(0), account_transactions=Account.get_account_transaction(0, 0, 0), form=accounts_form, form2=transaction_form, is_account_popup_active=is_account_popup_active, is_trans_popop_active="", )
def index_bak(request): pwd_forms = ChangeForm() forms = AccountForm() tags = Tag.objects.all() template = loader.get_template('account.html') context = { "account": "active", "forms": forms, "tags": tags, "username": request.user.username, "pwd_forms": pwd_forms } return HttpResponse(template.render(context, request))
def view_account(): account_id = request.args.get('id') q = request.args.get('q') if q is not None: return redirect(url_for('view_accounts', page=1, q=q)) form = AccountForm(request.form) if request.method == 'POST' and form.validate(): if form.id.data: account = orm.Account.query.get(int(form.id.data)) account.username = form.telephone.data account.name = form.telephone.data account.telephone = form.telephone.data account.role = 0 account.flag_telephone = 1 if form.flag_telephone.data else 0 account.checkcode = form.checkcode.data account.source = form.source.data account.dtcreate = form.dtcreate.data orm.db.session.commit() else: account = orm.Account(form.telephone.data, '1234', form.telephone.data, form.telephone.data, 0, 1 if form.flag_telephone.data else 0, '1234', form.source.data, form.dtcreate.data) orm.db.session.add(account) orm.db.session.commit() form.id.data = account.id return redirect(url_for('view_account')) elif request.method =='GET' and account_id: form = logic.GetAccountFormById(account_id) logic.LoadBasePageInfo('修改用户','输入并确定',form) else: logic.LoadBasePageInfo('新建用户','输入并确定',form) if form.id.data: account = orm.Account.query.get(int(form.id.data)) form.account = account return render_template('view_account.html',form = form)
def GetAccountFormById(account_id): account = orm.Account.query.get(int(account_id)) if account is None: return None accountform = AccountForm() accountform.id.data = account.id accountform.username.data = account.username accountform.password.data = account.password accountform.name.data = account.name accountform.telephone.data = account.telephone accountform.flag_telephone.data = True if account.flag_telephone > 0 else False accountform.checkcode.data = account.checkcode accountform.source.data = account.source accountform.dtcreate.data = account.dtcreate return accountform
class ContactController(object): def __init__(self,request): self.request = request def contactus(self): """ To address user pop up login , we have to pass formLogin to each page """ formLogin = AccountForm.LoginForm(request.form) if request.method == 'GET' : return render_template('contact.html',formLogin=formLogin) elif request.method == 'POST' : if request.form.get('login', None) == 'Login' : return AccountController.authenticatePopUpLogin(formLogin,'contact')
def login(self): form = AccountForm.LoginForm(request.form) print request.form if request.method == 'GET': # Check if user is already logged in, return login page if not, otherwise index if g.user.is_authenticated == False: return render_template('login.html', form=form, formLogin=form) elif g.user.is_authenticated: return redirect(url_for('index')) elif (request.method == 'POST'): if request.form.get('login', None) == 'Login': return authenticatePopUpLogin(form, 'login') else: return authenticate(form)
def account(request): if request.method == 'POST': account_form = AccountForm(request.POST) if account_form.is_valid(): user = service.update( request.user, account_form.cleaned_data['first_name'], account_form.cleaned_data['last_name'], account_form.cleaned_data['password'], ) messages.success( request, 'Your account has successfully been updated.' ) else: account_form = AccountForm(instance=request.user) data = { 'forms': { 'account': account_form }, } return render_to_response('accounts/account.html', data, context_instance = RequestContext(request))
def home(request): #region GET if request.method == "GET": form_capcha = CaptchaTestForm() form_account = AccountForm() html_dtc = dict(form_capcha=form_capcha, form_account=form_account, count=len(AccountModel.objects.all())) error_message = request.session.get('error_message', False) if error_message: html_dtc.update(dict(error_message=error_message)) del request.session['error_message'] html_dtc.update(csrf(request)) return render_to_response('chikun/home.html', html_dtc) #endregion #region POST if request.method == "POST": # human test form = CaptchaTestForm(request.POST) if not form.is_valid(): request.session.update(dict(error_message='Invalid Captcha')) return redirect('home') # validate return address return_address = request.POST.get('return_address', False) if not is_address_valid(return_address): request.session.update( dict(error_message='Invalid Bitcoin Address')) return redirect('home') # log details account_record = AccountModel.objects.create( return_address=return_address) account_record.save() # deposit address deposit_address = master_public_key.subkey(account_record.id).address() # html tags html_dtc = dict(deposit_address=deposit_address) html_dtc.update(csrf(request)) return render_to_response('chikun/address.html', html_dtc) ''''''
def my_account(): user_info = General.query.get(current_user.id) form = AccountForm( name=user_info.name, email=user_info.email, password=None, api_key=user_info.api_key, ) if form.validate_on_submit(): message = "" if form.password.data: hash_pw = generate_password_hash(form.password.data, method="pbkdf2:sha256", salt_length=8) user_info.password = hash_pw message += "Password change has been saved." user_info.name = form.name.data user_info.email = form.email.data user_info.api_key = form.api_key.data message += " All changes saved." flash(message) db.session.commit() return redirect(url_for("account.my_account")) return render_template("account.html", form=form, api=user_info.api_key)
def account(): if request.method == "GET": form = AccountForm(obj=current_user) else: form = AccountForm(request.form) try: subscribed = Subscription.objects.get(user=current_user.pk) except Subscription.DoesNotExist: subscribed = None if not request.method == 'POST' or not form.validate(): context = {'form': form, 'subscribed': subscribed} return render_template('account.html', **context) if form.username.data: current_user.username = form.username.data if form.email.data: current_user.email = form.email.data if form.phone.data: current_user.phone = form.phone.data if form.address.data: current_user.address = form.address.data if form.subscribe.data: current_user.subscribe = form.subscribe.data if form.password.data: current_user.set_password(form.password.data) try: current_user.save() except Exception, e: print str(e)
def edit_account(id): """ Edit an entry """ check_admin() add_account = False account = Account.query.get_or_404(id) form = AccountForm(obj=account) if form.validate_on_submit(): account.AccNum = form.AccNum.data account.name = form.name.data account.AccCategory = form.AccCategory.data account.SaccCategory = form.SaccCategory.data account.balance = form.balance.data account.Comment = form.Comment.data db.session.commit() flash('You have successfully edited the entry.') # redirect to the departments page return redirect(url_for('admin.list_account')) form.AccNum.data = account.AccNum form.name.data = account.name form.AccCategory.data = account.AccCategory form.SaccCategory.data = account.SaccCategory form.balance.data = account.balance form.Comment.data = account.Comment return render_template('admin/accounts/account.html', action="Edit", add_account=add_account, form=form, account=account, title="Edit Entry")
def account_form(request, id=None): obd = Account.objects.get(name='Opening Balance Difference', company=request.company) if id: account = get_object_or_404(Account, id=id, company=request.company) scenario = 'Update' else: account = Account() scenario = 'Create' for query in request.GET: setattr(account, query, request.GET[query]) if request.POST: form = AccountForm(data=request.POST, instance=account, company=request.company, scenario=scenario) if form.is_valid(): opening_dr = form.cleaned_data.get('opening_dr') opening_cr = form.cleaned_data.get('opening_cr') item = form.save(commit=False) item.company = request.company item.save() form.save_m2m() if scenario == 'Create' or scenario == 'Update': if not opening_dr == 0: set_transactions(item, date.today(), ['dr', item, form.cleaned_data['opening_dr']]) set_transactions(item, date.today(), ['cr', obd, form.cleaned_data['opening_dr']]) if not opening_cr == 0: set_transactions(item, date.today(), ['cr', item, form.cleaned_data['opening_cr']]) set_transactions(item, date.today(), ['dr', obd, form.cleaned_data['opening_cr']]) if request.is_ajax(): return render(request, 'callback.html', {'obj': AccountSerializer(item).data}) return redirect('/ledger/') else: form = AccountForm(instance=account, company=request.company, scenario=scenario) form.hide_field(request) if request.is_ajax(): base_template = 'modal.html' else: base_template = 'dashboard.html' return render(request, 'account_form.html', { 'scenario': scenario, 'form': form, 'base_template': base_template, })
def account_edit(request, response_format='html'): "Account edit" profile = request.user.profile if request.POST: form = AccountForm(request.POST, instance=profile) if form.is_valid(): form.save() return HttpResponseRedirect(reverse('account_view')) else: form = AccountForm(instance=profile) return render_to_response('account/account_edit', { 'profile': profile, 'form': Markup(form.as_ul()) }, context_instance=RequestContext(request), response_format=response_format)
def edit_account(request): redirect_to = request.REQUEST.get('next', '') user = request.user account = user.account if request.method == 'POST': # If the form has been submitted... if 'cancel' in request.POST: return HttpResponseRedirect(redirect_to) form = AccountForm(request.POST,instance=account) # A form bound to the POST data if form.is_valid(): # All validation rules pass form.save() messages.info(request, "Account updated.") return HttpResponseRedirect(redirect_to) else: form.reload_disabled() else: user = request.user account = user.account form = AccountForm(instance=account) # An unbound form return render_to_response('registration/edit_profile.html', { 'form': form, 'next': redirect_to, }, context_instance=RequestContext(request))