def payment(request, pk=False):
initial = {
'kwh_rent_cost': 0.34,
'fixed_cost': 334,
}
if pk:
try:
if models.Payment.objects.get(pk=pk).owner != request.user:
messages.error(request, "That payment is not yours!")
return HttpResponseRedirect(get_previous_page(request, APP_NAME))
except:
messages.error(request, "That payment does not exists!")
return HttpResponseRedirect(get_previous_page(request, APP_NAME))
payment_form = generate_form(request, models.Payment, models.PaymentForm, pk, initial)
if payment_form.is_valid():
p = payment_form.save(commit=False)
p.owner = request.user
p.save()
return HttpResponseRedirect(get_previous_page(request, APP_NAME))
payments = models.Payment.objects.filter(owner=request.user).order_by('-date')
return render(request, 'power_payment.html', {
'payment_form': payment_form,
'payments': payments,
})
def edit(request, model_name, pk=None, new_type=None):
model = getattr(models, model_name)
form_name = '%sForm' % model_name
model_form = getattr(models, form_name)
if model_name == 'Data' and new_type is not None:
print("model name er Data")
try:
new_type_pk = models.Category.objects.get(name=new_type).pk
except:
new_type_pk = None
form = generate_form(request, model, model_form, pk,
{'category': new_type_pk})
else:
form = generate_form(request, model, model_form, pk, None)
if form.is_valid():
form.save()
return HttpResponseRedirect(get_previous_page(request, APP_NAME))
if model_name == 'Data':
return render(request, 'databases_edit_data.html', {
'form': form,
'type': model_name,
})
else:
return render(
request, 'databases_edit.html', {
'form': form,
'type': model_name,
'entries': model.objects.values('pk', 'name'),
})
def delete_blog_comment(request, comment_pk):
csrf_token = csrf.get_token(request)
request_token = request.GET.get('token')
if request_token == csrf_token:
try:
comment = models.Comment.objects.get(pk=comment_pk)
comment.delete()
messages.success(request, 'Commet was deleted!')
except:
messages.error(request, 'Comment could not be deleted')
request.session['redirect_next'] = safe_referrer(request)
return HttpResponseRedirect(get_previous_page(request, APP_NAME))
else:
messages.error(request, u'Token did not match')
return HttpResponseRedirect(get_previous_page(request, APP_NAME))
def delete_blog(request, blog_pk):
if request.method == "POST":
comments = models.Comment.objects.filter(page=blog_pk)
images = models.Image.objects.filter(blog=blog_pk)
go_ahead = True
if comments:
messages.error(request, 'Delete all comments first!')
go_ahead = False
if images:
messages.error(request, 'Delete all images first!')
go_ahead = False
if go_ahead:
try:
blog = models.Blog.objects.get(pk=blog_pk)
title = blog.title
blog.delete()
messages.success(request, '%s is gone!' % title)
except:
messages.error(request, u'Could not delete post')
return HttpResponseRedirect(get_previous_page(request, APP_NAME))
else:
return render(request, 'blog_delete.html', {
u'blog_pk': blog_pk,
})
def img_comment(request, image_id):
image = image_exists(request, image_id)
comment = request.POST.get('comment', None)
if comment is None:
return render(request, 'image_comment.html', {
'image': image,
})
else:
image.description = comment
try:
image.save()
messages.success(request, "Image comment updated!")
return HttpResponseRedirect(get_previous_page(request, APP_NAME))
except:
messages.error(request, "Not able to save comment to image")
return HttpResponseRedirect(get_previous_page(request, APP_NAME))
def blog_comment(request, blog_pk):
try:
blog = models.Blog.objects.get(pk=blog_pk)
if blog.published and blog.linked:
if request.method == "POST":
form = models.CommentForm(request.POST)
if form.is_valid():
o = form.save(commit=False)
o.page = blog
o.ip = get_client_ip(request)
try:
#o.save()
return HttpResponseRedirect(
get_previous_page(request, APP_NAME))
except:
return Http404
else:
form = models.CommentForm()
else:
form = None
messages.error(request, 'Permission denied')
except:
form = None
messages.error(request, 'Blog ID does not exist')
set_redirect_session(request, 'blog_show', {'blog_pk': blog_pk})
return render(request, 'blog_comment.html', {
'form': form,
'title': blog.title,
})
def write(request, pk=False):
blog_form = generate_form(request, models.Blog, models.BlogForm, pk)
if blog_form.is_valid():
o = blog_form.save(commit=False)
o.owner = request.user
o.save()
blog_form.save_m2m()
messages.success(request, u'Blogg added/updated with ID=%s' % o.pk)
set_redirect_session(request, 'blog_show', {'blog_pk': o.pk})
return HttpResponseRedirect(get_previous_page(request, APP_NAME))
if pk:
request.session['redirect_next'] = reverse('blog_update', args=[pk])
try:
blog = models.Blog.objects.get(pk=pk)
sub_text = u'editing "%s"' % blog.title
redirect_url = reverse('blog_show', args=[pk])
except:
return Http404
else:
sub_text = u'new item'
redirect_url = None
return render(request, 'blog_edit.html', {
u'form': blog_form,
u'sub_header': sub_text,
u'redirect': redirect_url,
})
def write_ticker_history(request, pk=False):
ticker_form = generate_form(request, TickerHistory, TickerHistoryForm, pk)
if ticker_form.is_valid():
tf = ticker_form.save()
messages.success(request, u'Ticker history added/updated with ID=%s' % tf.pk)
set_redirect_session(request, 'app_stocks', {})
return HttpResponseRedirect(get_previous_page(request, APP_NAME))
if pk:
request.session['redirect_next'] = safe_referrer(request)
try:
header_text = "Redigere markedspris"
delete_link_pk = pk
redirect_url = None
except:
return Http404
else:
header_text = u'Ny markedspris'
redirect_url = None
delete_link_pk = None
return render(request, 'stocks_edit.html', {
u'form': ticker_form,
u'header_text': header_text,
u'redirect': redirect_url,
u'delete_link_name': "stocks_ticker_remove",
u'delete_link_pk': delete_link_pk,
})
def img_relarge(request, image_id):
image = image_exists(request, image_id)
if image:
if img_calc_large(image, 3840):
messages.success(request, "Large resize: Image resized!")
else:
messages.error(request, "Large resize: original not found")
else:
messages.error(request, "Large resize: image not in database")
return HttpResponseRedirect(get_previous_page(request, APP_NAME))
def category(request, pk=False):
category_form = generate_form(request, models.Category,
models.CategoryForm, pk, None)
if category_form.is_valid():
category_form.save()
return HttpResponseRedirect(get_previous_page(request, APP_NAME))
return render(request, 'blog_edit.html', {
'form': category_form,
'entries': models.Category.objects.all(),
})
def remove_ticker(request, pk):
csrf_token = csrf.get_token(request)
request_token = request.GET.get('token')
if request_token == csrf_token:
t = Ticker.objects.get(pk=pk)
t.delete()
messages.success(request, u'Ticker with ID=%s was deleted' % pk)
set_redirect_session(request, 'app_stocks', {})
else:
messages.error(request, u'Token did not match')
return HttpResponseRedirect(get_previous_page(request, APP_NAME))
def file_unlink(request, blog_id, file_id):
csrf_token = csrf.get_token(request)
request_token = request.GET.get('token')
if request_token == csrf_token:
obj = models.File.objects.get(pk=file_id)
rem_path = '%s%s/%s' % (settings.FILE_ROOT, blog_id, obj.filename)
if silentremove(request, rem_path):
if obj.delete():
return True
else:
messages.error(request, u'Token did not match')
return HttpResponseRedirect(get_previous_page(request, APP_NAME))
def delete(request, model_name, pk=None, new_type=None):
csrf_token = csrf.get_token(request)
request_token = request.GET.get('token')
if request_token == csrf_token:
model = getattr(models, model_name)
o = model.objects.get(pk=pk)
from django.db.models.deletion import ProtectedError
try:
o.delete()
except ProtectedError:
messages.error(
request,
"There are still database entries relying on this field!")
if model_name == 'Data':
return HttpResponseRedirect(get_previous_page(request, APP_NAME))
else:
return HttpResponseRedirect(
reverse('databases_new', args=[model_name]))
else:
messages.error(request, u'Token did not match')
return HttpResponseRedirect(get_previous_page(request, APP_NAME))
def tag_del(request, pk):
csrf_token = csrf.get_token(request)
request_token = request.GET.get('token')
if request_token == csrf_token:
try:
tag = models.Tag.objects.get(pk=pk)
tag.delete()
messages.success(request, 'Tag was deleted!')
except:
messages.error(request, 'Could not delete the Tag!')
return HttpResponseRedirect(reverse('blog_tag_add'))
else:
messages.error(request, u'Token did not match')
return HttpResponseRedirect(get_previous_page(request, APP_NAME))
def password_change(request):
user = request.user
form = ResetPasswordForm(user=user)
if request.method == 'POST':
form = ResetPasswordForm(request.POST, user=user)
if form.is_valid():
new_password = form.cleaned_data['password']
user.set_password(new_password)
user.save()
add_to_log(request, "Performed a password change", 1)
messages.success(request, "Your password has been changed!")
return HttpResponseRedirect(get_previous_page(request, 'root'))
header_text = "Bytt passordet for %s" % request.user.get_full_name()
return render(request, 'form_simple.html', {
'form': form,
'header': header_text,
})
def user_login(request):
form = LoginForm()
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
if form.cleaned_data:
if user_not_blocked(request):
username = request.POST['username']
password = request.POST['password']
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
user_name = user.get_full_name()
if user_name == '':
user_name = request.user
messages.success(
request,
'You are logged in as %s.' % user_name)
add_to_log(request,
"Successful user authentication")
return HttpResponseRedirect(
get_previous_page(request, 'root'))
else:
messages.error(request, 'Your are disabled.')
add_to_log(
request,
"Successful user authentication, but account is blocked",
1)
else:
messages.error(request,
'I could not verify your identity.')
log_message = "Failed attempt at authentication (%s)" % username
add_to_log(request, log_message, 2)
else:
messages.error(request,
'I could not verify your identity.')
log_message = "IP %s was blocked" % get_client_ip(request)
add_to_log(request, log_message, 1)
request.session['redirect_next'] = safe_referrer(request)
return render(request, 'login.html', {
'form': form,
})
def img_fullthumb(request, image_id):
image = models.Image.objects.get(pk=image_id)
img_calc_thumb(request, image, 800)
return HttpResponseRedirect(get_previous_page(request, APP_NAME))
def file_remove(request, blog_id, file_id):
file_unlink(request, blog_id, file_id)
request.session['redirect_next'] = safe_referrer(request)
return HttpResponseRedirect(get_previous_page(request, APP_NAME))
def details(request, ticker):
view_data = []
result_total = 0
try:
ticker_object = Ticker.objects.get(id=ticker)
header_text = {'name': ticker_object.company_name, 'ticker': ticker_object.ticker_name}
view_data = fifo_match(request, ticker_object)
for i in view_data:
try:
result = (i['sold'].average_stock_price - i['bought'].average_stock_price) * i['sold'].amount
result_total += result
except:
result = None
i['result'] = result
graph_num_stocks = []
graph_cost_stocks = []
graph_value_stocks = []
graph_labels = []
num_stocks = 0
cost_stocks = 0
value_stocks = 0
date_tracker = None
transactions = Transaction.objects.filter(ticker=ticker_object).order_by('date')
for t in transactions:
if date_tracker == None:
date_tracker = t.date.isoformat()
num_stocks += t.amount
cost_stocks += t.total_price
value_stocks = num_stocks * round(((t.total_price - t.brokerage) / t.amount), 2)
if t.date.isoformat() != date_tracker:
graph_num_stocks.append(int(num_stocks))
graph_cost_stocks.append(int(cost_stocks))
graph_value_stocks.append(int(value_stocks))
graph_labels.append(t.date.isoformat())
date_tracker = t.date.isoformat()
#nåverdi
import datetime
try:
latest_price = TickerHistory.objects.filter(ticker=ticker_object).order_by('date')[0].price
except:
latest_price = 0
graph_num_stocks.append(int(num_stocks)) #the same
graph_cost_stocks.append(int(cost_stocks)) #the same
graph_value_stocks.append(int(num_stocks * latest_price)) # current ticker price times the amount
graph_labels.append(datetime.date.today().isoformat())
except ObjectDoesNotExist:
set_redirect_session(request, 'app_stocks', {})
return HttpResponseRedirect(get_previous_page(request, APP_NAME))
return render(request, 'stocks_details.html', {
'view_data': view_data,
'result_total': result_total,
'header_text': header_text,
'graph_num_stocks': graph_num_stocks,
'graph_cost_stocks': graph_cost_stocks,
'graph_value_stocks': graph_value_stocks,
'graph_labels': graph_labels,
})
def edit(request, this_type, pk=False):
try:
request.user.profile
except:
messages.error(request, 'You need to create a user profile')
return HttpResponseRedirect(get_previous_page(request, APP_NAME))
# Get the first account entry used as default choice in form
try:
Account.objects.filter(owner=request.user)[0].pk
except:
messages.error(request, "You have no accounts!")
if pk:
pk = int(pk)
### salary
if this_type == u'salary':
if not pk:
form = SalaryForm(
initial={
'account': request.user.profile.DEFAULT_PAYMENT_ACCOUNT,
'comment': request.user.profile.DEFAULT_SALARY_COMMENT
})
if request.method == 'POST':
form = SalaryForm(request.POST)
else:
try:
instance = Salary.objects.get(pk=pk)
if instance.owner != request.user:
messages.error(request,
"You don't own this salary registration!")
return HttpResponseRedirect(
reverse("money_new", args=["salary"]))
except Salary.DoesNotExist:
raise Http404
form = SalaryForm(instance=instance)
if request.method == 'POST':
form = SalaryForm(request.POST, instance=instance)
# Restrict options shown for account
form.fields['account'].queryset = Account.objects.exclude(
account_type=2).filter(owner=request.user)
if request.method == 'POST':
if form.is_valid():
if form.cleaned_data:
# new instance
if not pk:
# The salary is new
s = form.save(commit=False)
# Add the owner
s.owner = request.user
# Add a new transaction
t = Transaction(
owner=request.user,
account=s.account,
amount=s.amount(),
date=s.date,
sub_category=s.account.sub_category,
category=s.account.sub_category.parent_category,
comment=s.comment,
)
t.save()
# Add the new transaction as foreign key
s.transaction = t
s.save()
# edit existing instance
else:
# Update a salary, just save it
s = form.save()
# update the corresponding transaction
t = s.transaction
t.account = s.account
t.amount = s.amount()
t.date = s.date
t.sub_category = s.account.sub_category
t.category = s.account.sub_category.parent_category
t.comment = s.comment
t.save()
return HttpResponseRedirect(
get_previous_page(request, APP_NAME))
### expence
elif this_type == u'expence':
if not pk:
form = ExpenceForm(
initial={
'account':
request.user.profile.DEFAULT_PAYMENT_ACCOUNT,
'sub_category':
request.user.profile.DEFAULT_EXPENCE_SUB_CATEGORY,
})
if request.method == 'POST':
form = ExpenceForm(request.POST)
else:
try:
instance = Transaction.objects.get(pk=pk)
if instance.owner != request.user:
messages.error(request,
"You don't own this expence registration!")
return HttpResponseRedirect(
reverse("money_new", args=["expence"]))
except Transaction.DoesNotExist:
raise Http404
form = ExpenceForm(instance=instance)
if request.method == 'POST':
form = ExpenceForm(request.POST, instance=instance)
form.fields['sub_category'].choices = categories_as_choices(
request.user)
#form.fields['account'].queryset = Account.objects.exclude(account_type=2).filter(owner=request.user)
form.fields['account'].queryset = Account.objects.filter(
owner=request.user)
if request.method == 'POST':
if form.is_valid():
if form.cleaned_data:
if not pk:
# The transaction is new
t = form.save(commit=False)
# Add the owner
t.owner = request.user
# Invert the sum (most used usecase)
t.amount = -(t.amount)
t.category = t.sub_category.parent_category
t.save()
else:
# Updateing an existing transaction
t = form.save(commit=False)
# We can't invert the sum once again, but we check the category from subcategory
t.category = t.sub_category.parent_category
t.save()
return HttpResponseRedirect(
get_previous_page(request, APP_NAME))
### bank_transaction
elif this_type == u'bank_transaction':
if not pk:
form = BankTransactionForm()
if request.method == 'POST':
form = BankTransactionForm(request.POST)
else:
try:
instance = BankTransaction.objects.get(pk=pk)
if instance.eier != request.user:
messages.error(request,
"You don't own this bank transaction!")
return HttpResponseRedirect(
reverse("money_new", args=["expence"]))
except BankTransaction.DoesNotExist:
raise Http404
form = BankTransactionForm(instance=instance)
if request.method == 'POST':
form = BankTransactionForm(request.POST, instance=instance)
if request.method == 'POST':
if form.is_valid():
if form.cleaned_data:
if not pk:
# The transaction is new
t = form.save(commit=False)
t.eier = request.user
t.save()
else:
# Updateing an existing transaction
t = form.save(commit=False)
t.save()
return HttpResponseRedirect(reverse("bank_transactions"))
### transaction
elif this_type == u'transaction':
form = TransactionForm(user=request.user)
if request.method == 'POST':
form = TransactionForm(request.POST, user=request.user)
if form.is_valid():
if form.cleaned_data:
source_account = form.cleaned_data['source_account']
destination_account = form.cleaned_data['destination_account']
date_field = form.cleaned_data['date']
amount = form.cleaned_data['amount']
comment_remove = "Transferred to %s" % destination_account
comment_add = "Transferred from %s" % source_account
# Remove amount from account
t1 = Transaction(
owner=request.user,
account=source_account,
amount=-amount,
comment=comment_remove,
date=date_field,
sub_category=destination_account.sub_category,
category=destination_account.sub_category.parent_category,
)
t1.save()
# Add to the destination account
t2 = Transaction(
owner=request.user,
account=destination_account,
amount=amount,
comment=comment_add,
date=date_field,
sub_category=destination_account.sub_category,
category=destination_account.sub_category.parent_category,
)
t2.save()
return HttpResponseRedirect(get_previous_page(request, APP_NAME))
### downpayment
elif this_type == u'downpayment':
if not pk:
form = DownpaymentForm(
initial={
# make it general !!
'comment':
request.user.profile.DEFAULT_DOWNPAYMENT_COMMENT,
'source_account':
request.user.profile.DEFAULT_PAYMENT_ACCOUNT,
})
if request.method == 'POST':
form = DownpaymentForm(request.POST)
else:
try:
instance = Downpayment.objects.get(pk=pk)
if instance.owner != request.user:
messages.error(
request,
"You don't own this loan repayment registration!")
return HttpResponseRedirect(
reverse("money_new", args=["downpayment"]))
except Downpayment.DoesNotExist:
raise Http404
form = DownpaymentForm(instance=instance)
if request.method == 'POST':
form = DownpaymentForm(request.POST, instance=instance)
form.fields['source_account'].queryset = Account.objects.exclude(
account_type=2).filter(owner=request.user)
form.fields['destination_account'].queryset = Account.objects.filter(
account_type=2, owner=request.user)
if request.method == 'POST':
if form.is_valid():
if form.cleaned_data:
# new instance
if not pk:
# catch the new downpayment object
d = form.save(commit=False)
# remove money from source account
t1 = Transaction(
owner=request.user,
account=d.source_account,
amount=-(d.repayment + d.interest_and_fees),
date=d.date,
sub_category=d.destination_account.sub_category,
category=d.destination_account.sub_category.
parent_category,
comment=d.comment,
)
t1.save()
# add money to the receiving account
t2 = Transaction(
owner=request.user,
account=d.destination_account,
amount=d.repayment,
date=d.date,
sub_category=d.destination_account.sub_category,
category=d.destination_account.sub_category.
parent_category,
comment=d.comment,
)
t2.save()
# save the downpayment object
d.owner = request.user
d.source_transaction = t1
d.destination_transaction = t2
d.save()
# edit existing instance
else:
# Update, just save it
d = form.save()
# update the corresponding transactions
t1 = d.source_transaction
t1.account = d.source_account
t1.amount = -(d.repayment + d.interest_and_fees)
t1.date = d.date
t1.sub_category = d.destination_account.sub_category
t1.category = d.destination_account.sub_category.parent_category
t1.comment = d.comment
t1.save()
t2 = d.destination_transaction
t2.account = d.destination_account
t2.amount = d.repayment
t2.date = d.date
t2.sub_category = d.destination_account.sub_category
t2.category = d.destination_account.sub_category.parent_category
t2.comment = d.comment
t2.save()
return HttpResponseRedirect(
get_previous_page(request, APP_NAME))
### default
else:
raise Http404
# add text for headers
head_text = "No title"
if this_type == u'salary':
head_text = "Legg til lønn"
if this_type == u'expence':
head_text = "Manuell registrering"
if this_type == u'transaction':
head_text = "Overfør mellom kontoer"
if this_type == u'downpayment':
head_text = "Nedbetaling lån"
if this_type == u'bank_transaction':
head_text = "Rediger importert banktransaksjon"
try:
back_link = request.session['redirect_url']
except:
back_link = None
return render(
request, u'money_edit.html', {
'type': this_type,
'form': form,
'back_link': back_link,
'head_text': head_text
})
def go_back(request):
return HttpResponseRedirect(get_previous_page(request, 'root'))