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 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 _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(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_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 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 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 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 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_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 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 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, 'new': False}
return render_to_response(template_name, template_context,
RequestContext(request))
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 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 save(request):
obj = None
name = request.POST.get('name')
tag = request.POST.get('tag')
profile = Profile.objects.get(user_id=request.user.id)
try:
if request.POST.get('id'):
obj = Account.objects.get(id=request.POST.get('id'))
except Account.DoesNotExist:
pass
if obj:
form = AccountForm(request.POST or None, instance=obj)
else:
form = AccountForm(request.POST or None)
if form.is_valid():
instance = form.save(commit=False)
if request.POST.get('id'):
instance.updateuser = request.user
password = encrypt(request.POST.get('password'),
profile.key[:8] + profile.iv[8:],
profile.key[8:] + profile.iv[:8])
if password != obj.password:
instance.password = password
else:
instance.createuser = request.user
instance.tag_id = tag
instance.password = encrypt(request.POST.get('password'),
profile.key[:8] + profile.iv[8:],
profile.key[8:] + profile.iv[:8])
instance.save()
result = {"ret": 0, "status": "success"}
return HttpResponse(json.dumps(result),
content_type="application/json")
else:
msg = []
if form.errors:
for k, v in form.errors.iteritems():
msg.append(v[0])
return HttpResponse(json.dumps({
"ret": 10000,
"status": "error",
"msg": '\n'.join(msg)
}),
content_type="application/json")
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 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 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_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 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 account_add(request, shortcode=None):
account = None
if request.method == "POST":
form = AccountForm(request.POST, instance=account)
if form.is_valid():
account = form.save()
request.user.accounts.create(
account=account,
role=UserAccount.ROLE_OWNER,
)
return HttpResponseRedirect(reverse("index"))
else:
form = AccountForm(instance=account)
return render(request, "account_form.html", {
"form": form,
"account": account
})
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 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))
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))
