def save_new_transactions(request, transact_params=[]):
if transact_params == []:
# <DEBUG SECTION>
user = get_debug_user(request)
# <DEBUG SECTION>
entries = request_to_array(request)
else:
user = transact_params[0]["user"]
entries = transact_params
if entries != []:
for entry in entries:
try:
if entry['is_privat']:
transactionType = PrivatTransaction
audit_event_type = AuditEventTypes.private_transaction_created(
)
else:
transactionType = PublicTransaction
audit_event_type = AuditEventTypes.transaction_created()
new_transaction = transactionType(user = user, \
transactionstime = entry['date'],\
purpose = entry['purpose'], \
comment = entry['comment'], \
amount = entry['amount'])
new_transaction.save()
audit_created = audit_event(user, user,\
audit_event_type, \
transaction = new_transaction)
if not audit_created:
raise Exception
except Exception as exc:
return failure_page(request, "Failed on transaction " + \
str(entry) + " saving<br>" + str(exc))
return saved_success(request)
def family(request):
#<DEBUG SECTION>
user = get_debug_user(request)
#<DEBUG SECTION>
if len(user.get_all_members()) <= 1:
return redirect("/main")
return family_setings(request, user)
def give_necessary_statistics(request):
user = get_debug_user(request)
response_data = {"public_outcome" : 0, \
"public_income" : 0, \
"public_balance" : 0, \
"public_transaction_time" : 0, \
"private_outcome" : 0, \
"private_income" : 0, \
"private_balance" : 0, \
"private_transaction_time" : 0}
response_data["public_outcome"] = user.get_family_outcome_sum()
response_data["public_income"] = user.get_family_income_sum()
response_data["public_balance"] = user.get_family_balance()
first_transactions_datetime = user.get_first_transactions_datetime()
if first_transactions_datetime is None:
response_data["public_transaction_time"] = "Start Now!"
else:
response_data["public_transaction_time"] = \
first_transactions_datetime.date()
response_data["private_outcome"] = user.get_private_outcome_sum()
response_data["private_income"] = user.get_private_income_sum()
response_data["private_balance"] = user.get_private_balance()
first_transactions_datetime = user.get_first_private_transactions_datetime(
)
if first_transactions_datetime is None:
response_data["private_transaction_time"] = "Start Now!"
else:
response_data["private_transaction_time"] = \
first_transactions_datetime.date()
return JsonResponse(response_data)
def resend_confirmation(request, type="email"):
#DEBUG section
user = get_debug_user(request)
#DEBUG section
if get_count_confirmations_today(user) > 2:
return -6
code_conf = generate_email_confirmation(user)
if (code_conf == -1) or (code_conf == -2):
return -7
#TODO: Here is just an excellent place for refactoring!!!
host = get_hostname(request)
url = create_url(host, user.user.email, code_conf)
if type == "email":
receiver = user.user.email
subject = "Household keeper: Email confirmation"
new_user_name = return_full_name(receiver, "New User")
body_email = get_body_email_conf(new_user_name, \
receiver, url)
elif type == "family":
receiver = user.family.founder
family_founder_name = return_full_name(receiver, \
"Family founder")
body_email = get_body_family_conf(family_founder_name, \
user.user.email, url)
subject = "Household keeper: New member wants to join your family"
else:
return -8
email_is_sent = send_email("*****@*****.**", receiver, subject, \
body_email)
if not email_is_sent:
return -9
return 1
def search_result(request):
##DEBUG
user = get_debug_user(request)
##DEBUG
search_criterium = parse_request(request)
empty_set = []
if search_criterium["give_no_result"]:
return empty_set
output_set = get_initial_transactions_set(request)
if is_empty(output_set):
return empty_set
if search_criterium["show_outcome"] and search_criterium["show_income"]:
pass
elif search_criterium["show_outcome"]:
output_set = return_only_outcome(output_set)
elif search_criterium["show_income"]:
output_set = return_only_income(output_set)
if is_empty(output_set):
return empty_set
output_set = filter_transactions_by_amount(output_set,\
min_amount = search_criterium["min_amount"], \
max_amount = search_criterium["max_amount"])
if is_empty(output_set):
return empty_set
output_set = filter_transactions_by_date(output_set,\
before = search_criterium["before"], \
after = search_criterium["after"])
if is_empty(output_set):
return empty_set
output_set = filter_transactions_by_users(output_set,\
users = search_criterium["users"])
if is_empty(output_set):
return empty_set
output_set = filter_transactions_by_purpose(output_set,\
value=search_criterium["purpose"], \
exact=search_criterium["purpose_exact"])
if is_empty(output_set):
return empty_set
output_set = filter_transactions_by_comment(output_set,\
value=search_criterium["comment"], \
exact=search_criterium["comment_exact"])
return order_by_time(output_set)
def user_edit_form_validation(request):
# <DEBUG SECTION>
user = get_debug_user(request)
# <DEBUG SECTION>
if request.method == 'POST':
edit_user_form = EditUserForm(request.POST)
if edit_user_form.is_valid():
response = save_settings(request)
return response
else:
edit_user_form = EditUserForm() # An unbound form
return personal_settings(request, user, user_form=edit_user_form)
def user_is_allowed_to_edit(tr_id, request,
is_private): #DONE: Find out ow to define the user
#DEBUG SECTION#
user = get_debug_user(request)
#DEBUG SECTION#
if is_private:
transaction_type = PrivatTransaction
else:
transaction_type = PublicTransaction
user_list = user.get_all_members()
try:
transaction = transaction_type.objects.get(pk=tr_id)
except Exception as exc:
return -1
if transaction.user in user_list:
return transaction
else:
return False
def save_family_pseudos(request):
#<DEBUG SECTION>
for_user = get_debug_user(request)
#<DEBUG SECTION>
params_array = request_to_array(request)
for entry in params_array:
of_user = entry["user"]
pseudonym = entry["pseudo"]
try:
new_pseudo = Pseudonym.objects.get(of_the_user = of_user, \
for_the_user = for_user)
new_pseudo.pseudonym = pseudonym
except Pseudonym.DoesNotExist:
new_pseudo = Pseudonym(pseudonym = pseudonym, \
of_the_user = of_user, \
for_the_user = for_user)
try:
new_pseudo.save()
except:
return failure_page(request)
return saved_success(request)
def delete_transaction(request):
# <DEBUG SECTION>
user = get_debug_user(request)
# <DEBUG SECTION>
try:
initial_state = request.POST["is_private"]
except KeyError as excpt:
return failure_page(request, "incorrect POST data")
if int(initial_state) == 1:
private_transaction = True
audit_event_type = AuditEventTypes.private_transaction_deleted()
elif int(initial_state) == 0:
private_transaction = False
audit_event_type = AuditEventTypes.transaction_deleted()
else:
return failure_page(request, "incorrect POST data")
try:
tr_id = request.POST["id"]
except KeyError as excpt:
return failure_page(request, "incorrect POST data")
if not transaction_exists(tr_id):
return failure_page(request, "Incorrect ID")
transaction = user_is_allowed_to_edit(tr_id, request, private_transaction)
try:
transaction.deleted = True
transaction.save()
audit_created = audit_event(transaction.user, transaction.user,\
audit_event_type, \
transaction = transaction)
if not audit_created:
raise Exception
except Exception as exc:
return failure_page(request, "Audit wasn't created" + str(exc))
return deleted_success(request)
def add(request, several):
# <DEBUG SECTION>
user = get_debug_user(request)
# <DEBUG SECTION>
return add_transactions(request, user, several)
def parse_request(request):
##DEBUG
user = get_debug_user(request)
##DEBUG
output = {}
try:
after = request.GET["begin"]
except KeyError:
after = get_min_value_of_transaction(user, "transactionstime")
if after != "":
try:
after = parse(after)
except:
after = ""
output["after"] = after
try:
before = request.GET["end"]
except KeyError:
before = get_max_value_of_transaction(user, "transactionstime")
if before != "":
try:
before = parse(before)
except:
before = ""
output["before"] = before
try:
max_amount = request.GET["maxamount"]
except KeyError:
max_amount = get_max_value_of_transaction(user, "amount")
try:
float(max_amount)
except ValueError:
max_amount = ""
except TypeError:
max_amount = ""
output["max_amount"] = max_amount
try:
min_amount = request.GET["minamount"]
except KeyError:
min_amount = get_min_value_of_transaction(user, "amount")
try:
float(min_amount)
except ValueError:
min_amount = ""
except TypeError:
min_amount = ""
output["min_amount"] = min_amount
# try:
# show_private = request.GET["private"]
# output["show_private"] = True
# except KeyError:
# output["show_private"] = False
#
# try:
# show_private = request.GET["public"]
# output["show_public"] = True
# except KeyError:
# output["show_public"] = False
try:
show_income = request.GET["income"]
output["show_income"] = True
except KeyError:
output["show_income"] = False
try:
give_no_result = request.GET["nosearch"]
output["give_no_result"] = True
except KeyError:
output["give_no_result"] = False
try:
show_outcome = request.GET["outcome"]
output["show_outcome"] = True
except KeyError:
output["show_outcome"] = False
try:
users = request.GET.getlist('users')
output["users"] = []
for user_email in users:
try:
user_auth = User.objects.get(email=user_email)
user = Users.objects.get(user=user_auth)
output["users"].append(user)
except User.DoesNotExist:
pass
except Users.DoesNotExist:
pass
except KeyError:
output["users"] = []
output["purpose_exact"] = define_exact("purposecomparation", request)
output["comment_exact"] = define_exact("commentcomparation", request)
output["purpose"] = define_text("purpose", request)
output["comment"] = define_text("comment", request)
return output
def save_changes(request):
# <DEBUG SECTION>
user = get_debug_user(request)
# <DEBUG SECTION>
try:
initial_state = request.POST["is_private"]
except KeyError as excpt:
return failure_page(request, "incorrect POST data")
if int(initial_state) == 1:
private_transaction = True
audit_event_type = AuditEventTypes.private_transaction_edited()
elif int(initial_state) == 0:
private_transaction = False
audit_event_type = AuditEventTypes.transaction_edited()
else:
return failure_page(request, "incorrect POST data")
try:
private_flag = request.POST["private"]
is_private = True
except KeyError as excpt:
is_private = False
try:
tr_id = request.POST["id"]
amount = request.POST["amount"]
date = request.POST["date"]
purpose = request.POST["purpose"]
comment = request.POST["comment"]
except KeyError as excpt:
return failure_page(request, "incorrect POST data")
if not transaction_exists(tr_id):
return failure_page(request, "Incorrect PublicTransaction ID")
transaction = user_is_allowed_to_edit(tr_id, request, private_transaction)
if private_transaction != is_private:
transaction = change_transaction_type(transaction, \
private_transaction, is_private)
if isinstance(transaction, str):
return failure_page(request, "Failed on transaction " + \
transaction)
if transaction == -1:
return failure_page(request, "Unknown error")
if not transaction:
return failure_page(request, "Attempt for edit unallowed transaction")
if is_float(amount) and is_date(date):
float_amount = float(amount)
transactionstime = parse(date)
audit_list = []
if transaction.amount != float_amount:
change_dic = {"field": "amount", "old_value": transaction.amount, \
"new_value": float_amount}
audit_list.append(change_dic)
transaction.amount = float_amount
transactionstime_tz_aware = timezone.make_aware(transactionstime, \
timezone.get_current_timezone())
if transaction.transactionstime != transactionstime_tz_aware:
change_dic = {"field": "transactionstime", \
"old_value": transaction.transactionstime, \
"new_value": transactionstime}
audit_list.append(change_dic)
transaction.transactionstime = transactionstime_tz_aware
if transaction.purpose != purpose:
change_dic = {"field": "purpose", \
"old_value": transaction.purpose, \
"new_value": purpose}
audit_list.append(change_dic)
transaction.purpose = purpose
if transaction.comment != comment:
change_dic = {"field": "comment", \
"old_value": transaction.comment, \
"new_value": comment}
audit_list.append(change_dic)
transaction.comment = comment
try:
transaction.save()
except Exception as exc:
return failure_page(request, "Failed to save transaction " + \
"changes to DB")
try:
audit_created = audit_event(user, transaction.user, \
audit_event_type, \
transaction = transaction, \
list_of_changes = audit_list)
if not audit_created:
raise Exception
except Exception as exc:
return failure_page(request, "Failed to save audit changes to DB")
return saved_success(request)
else:
return failure_page(request, "Amount or Data parameters are incorrect")
def access(request):
#<DEBUG SECTION>
user = get_debug_user(request)
#<DEBUG SECTION>
return access_data(request, user)
'''
Created on Jul 10, 2014
@author: thavr
'''
from budget.debug import get_debug_user
from django.http.request import HttpRequest
from budget.transactions import save_new_transactions
def create_request(date = "", amount = "13.65", purpose ="", comment = "", \
count = 1):
request = HttpRequest()
request.POST["date"] = [date]
request.POST["amount"] = [amount]
request.POST["purpose"] = [purpose]
request.POST["comment"] = [comment]
for i in range(count - 1):
request.POST["date"].append(date)
request.POST["amount"].append(amount)
request.POST["purpose"].append(purpose)
request.POST["comment"].append(comment)
return request
if __name__ == '__main__':
user = get_debug_user()
request = create_request(count=1)
output = save_new_transactions(request)
print output
'''
Created on Jul 15, 2014
@author: thavr
'''
from budget.debug import get_debug_user
import django
if __name__ == '__main__':
django.setup()
u2 = get_debug_user()
u2.transaction_set.create(amount = -35.33, purpose = "Dinner with wife", \
transactionstime = "2013-01-01 23:59:00Z", \
comment = "")
u2.transaction_set.create(amount = 35.33, purpose = "Bank rate", \
transactionstime = "2012-12-31 13:27:00Z", \
comment = "Bank of America")
u2.transaction_set.create(amount = -36.33, purpose = "Pertol", \
transactionstime = "2013-02-15 12:59:00Z", \
comment = "ARAL")
u2.transaction_set.create(amount = 36.33, purpose = "Money-back from amazon",\
transactionstime = "2012-01-01 00:00:01-08:00", \
comment = "")
print "OK"
def personal_forms(request):
#<DEBUG SECTION>
user = get_debug_user(request)
#<DEBUG SECTION>
return edit_wo_form(request, user)
def personal(request):
#<DEBUG SECTION>
user = get_debug_user(request)
#<DEBUG SECTION>
return personal_settings(request, user)
def search(request):
from budget.views import search_page
##DEBUG
user = get_debug_user(request)
##DEBUG
return search_page(request, user)
def preferences(request):
#<DEBUG SECTION>
user = get_debug_user(request)
#<DEBUG SECTION>
return site_preferences(request, user)
def change_site_prefernces(request):
#DEBUG section
user = get_debug_user(request)
#DEBUG section
try:
request_parameters = parse_request(request)
except Exception as e:
return server_error(e, request)
current_preferences = user.get_settings_with_name()
prefernces_name_value = user.get_user_settings_as_voc()
for sett_name, new_value in request_parameters.iteritems():
entry_exists = True
audit_list = []
new_bool = None
new_float = None
new_string = None
try:
old_preference = current_preferences[sett_name]
except KeyError as e:
recreate_setting = SitePreferncesList.objects.get(setting_name\
=sett_name)
setting_conn = SitePrefernce.objects.get(setting=recreate_setting)
if setting_conn.type.prefernce_type == 'bool':
new_bool = request_parameters[sett_name]
elif setting_conn.type.prefernce_type == 'float':
new_float = request_parameters[sett_name]
elif setting_conn.type.prefernce_type == 'string':
new_string = request_parameters[sett_name]
elif setting_conn.type.prefernce_type == 'int':
new_int = request_parameters[sett_name]
users_default_settings = UserSettings(user = user, \
setting = setting_conn, \
value_bool = new_bool, \
value_float = new_float, \
value_int = new_int, \
value_string = new_string)
users_default_settings.save()
change_dic = {"field": sett_name, "old_value": None, \
"new_value": request_parameters[sett_name]}
audit_list.append(change_dic)
entry_exists = False
if entry_exists and prefernces_name_value[sett_name] != \
request_parameters[sett_name]:
setting_type = \
current_preferences[sett_name].setting.type.prefernce_type
if setting_type == 'bool':
new_bool = new_value
elif setting_type == 'float':
new_float = new_value
elif setting_type == 'string':
new_string = new_value
elif setting_type == 'int':
new_int = new_value
old_preference.value_bool = new_bool
old_preference.value_float = new_float
old_preference.value_string = new_string
old_preference.value_int = new_int
try:
old_preference.save()
except:
return failure_page(request, "Failed on user saving<br>")
change_dic = {"field": sett_name, \
"old_value": prefernces_name_value[sett_name], \
"new_value": request_parameters[sett_name]}
audit_list.append(change_dic)
audit_created = audit_event(user, user,\
AuditEventTypes.site_preferences_edited(), \
list_of_changes = audit_list)
if not audit_created:
raise Exception
response = HttpResponse("OK.", content_type="text/plain")
response['Overflow'] = "0"
return response
def get_initial_transactions_set(request):
##DEBUG
user = get_debug_user(request)
##DEBUG
return [user.get_all_public_family_transactions(), \
user.get_all_privat_user_transactions()]
def main2(request):
#<DEBUG SECTION>
user = get_debug_user(request)
family = user.family
#<DEBUG SECTION>
return main_page2(request, family, user)
def change_access_data(request):
#DEBUG section
user = get_debug_user(request)
#DEBUG section
attempt_audit = AccessDataChange(user_impacted = user, \
pasword_change= False, \
email_change= False, \
change_date = timezone.now(), \
password_verification_result = 'Pending')
try:
request_parameters = parse_request(request)
except Exception as e:
return server_error(e, request)
if request_parameters['new_email'] != '':
attempt_audit.email_change = True
if request_parameters['new_password'] != \
request_parameters['retype_new_password']:
return server_error(e, request)
if request_parameters['new_password'] != '':
attempt_audit.pasword_change = True
try:
attempt_is_allowed = is_attempt_allowed(user)
except Exception as e:
return server_error(e, request)
if not attempt_is_allowed:
response = HttpResponse("OK.", content_type="text/plain")
response['Overflow'] = "1"
attempt_audit.password_verification_result = 'Fail'
try:
attempt_audit.save()
except Exception as e:
return server_error(e, request)
return response
try:
password_is_correct = is_password_correct(user, \
request_parameters["conf_password"])
except Exception as e:
return server_error(e, request)
if not password_is_correct:
response = HttpResponse("OK.", content_type="text/plain")
response['Overflow'] = "-6"
attempt_audit.password_verification_result = 'Fail'
try:
attempt_audit.save()
except Exception as e:
return server_error(e, request)
return response
try:
save_access_data(user, request_parameters)
except Exception as e:
return server_error(e, request)
response = HttpResponse("OK.", content_type="text/plain")
response['Overflow'] = "0"
attempt_audit.password_verification_result = 'Success'
try:
attempt_audit.save()
except Exception as e:
return server_error(e, request)
try:
send_email_confirmation(user, get_hostname(request))
except Exception as e:
return server_error(e, request)
audit_created = audit_event(user, user,\
AuditEventTypes.user_edited())
if not audit_created:
return HttpResponseServerError("NOK")
return response
def save_settings(request):
# <DEBUG SECTION>
user = get_debug_user(request)
# <DEBUG SECTION>
audit_list = []
params = parse_inputs_personal(request)
if params == -1:
return failure_page(request, "Failed on parsing inputs<br>")
if user.birthdate != params['birthdate']:
change_dic = {"field": "birthdate", "old_value": user.birthdate, \
"new_value": params['birthdate']}
audit_list.append(change_dic)
user.birthdate = params['birthdate']
if user.cellcountry != params['cellcountry']:
change_dic = {"field": "cellcountry", "old_value": user.cellcountry, \
"new_value": params['cellcountry']}
audit_list.append(change_dic)
user.cellcountry = params['cellcountry']
if user.cellarea != params['cellarea']:
change_dic = {"field": "cellarea", "old_value": user.cellarea, \
"new_value": params['cellarea']}
audit_list.append(change_dic)
user.cellarea = params['cellarea']
if user.cellnum != params['cellnum']:
change_dic = {"field": "cellnum", "old_value": user.cellnum, \
"new_value": params['cellnum']}
audit_list.append(change_dic)
user.cellnum = params['cellnum']
if user.addrcountry != params['addrcountry']:
change_dic = {"field": "addrcountry", "old_value": user.addrcountry, \
"new_value": params['addrcountry']}
audit_list.append(change_dic)
user.addrcountry = params['addrcountry']
if user.addrpostid != params['addrpostid']:
change_dic = {"field": "addrpostid", "old_value": user.addrpostid, \
"new_value": params['addrpostid']}
audit_list.append(change_dic)
user.addrpostid = params['addrpostid']
if user.addrtown != params['addrtown']:
change_dic = {"field": "addrtown", "old_value": user.addrtown, \
"new_value": params['addrtown']}
audit_list.append(change_dic)
user.addrtown = params['addrtown']
if user.addrstr != params['addrstr']:
change_dic = {"field": "addrstr", "old_value": user.addrstr, \
"new_value": params['addrstr']}
audit_list.append(change_dic)
user.addrstr = params['addrstr']
if user.addrhousenum != params['addrhousenum']:
change_dic = {"field": "addrhousenum", "old_value": user.addrhousenum, \
"new_value": params['addrhousenum']}
audit_list.append(change_dic)
user.addrhousenum = params['addrhousenum']
if user.addrapt != params['addrapt']:
change_dic = {"field": "addrapt", "old_value": user.addrapt, \
"new_value": params['addrapt']}
audit_list.append(change_dic)
user.addrapt = params['addrapt']
if user.addradditional != params['addradditional']:
change_dic = {"field": "addradditional", \
"old_value": user.addradditional, \
"new_value": params['addradditional']}
audit_list.append(change_dic)
user.addradditional = params['addradditional']
user_auth = user.user
if user_auth.first_name != params['fname']:
change_dic = {"field": "fname", "old_value": user_auth.first_name, \
"new_value": params['fname']}
audit_list.append(change_dic)
user_auth.first_name = params['fname']
if user_auth.last_name != params['sname']:
change_dic = {"field": "sname", "old_value": user_auth.last_name, \
"new_value": params['sname']}
audit_list.append(change_dic)
user_auth.last_name = params['sname']
if audit_list != []:
try:
user.save()
user_auth.save()
audit_created = audit_event(user, user,\
AuditEventTypes.user_edited(), \
list_of_changes = audit_list)
if not audit_created:
raise Exception
except:
return failure_page(request, "Failed on user saving<br>")
return saved_success(request)
