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 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 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))
