def expensesList(request):
req = request.POST
if RequestUtils.param_exist("toDate", req):
toDate = DateService.parseDate(req['toDate'])
else:
toDate = datetime.datetime.now()
if RequestUtils.param_exist("fromDate", req):
fromDate = DateService.parseDate(req['fromDate'])
else:
fromDate = toDate - datetime.timedelta(days=getattr(settings,'EXPENSES_DEFAULT_DAYS_LIST', 5))
q = Expense.objects.filter(date__gte = DateService.midNight(fromDate), date__lte = DateService.midNight(toDate, True))
currentCategory = 0
if RequestUtils.param_exist("category", req) and req['category']!='0':
c = SubCategory.objects.filter(category=req['category']).values_list('pk', flat=True)
q = q.filter(subCategory__in=list(c))
currentCategory = req['category']
q = q.order_by("-date")
total = 0
for e in q:
total += e.amount
cList = Category.objects.all().order_by("name")
return {"settings": settings,
"list": q,
"today": datetime.date.today(),
"filterStart": fromDate,
"filterEnd": toDate,
"total": total,
"categoryList": cList,
"currentCategory": int(currentCategory)}
def list(request):
req = request.REQUEST
q = Expense.objects.filter()
if param_exist("amountStart",req):
q = q.filter(amount__gte=req['amountStart'])
if param_exist("amountEnd",req):
q = q.filter(amount__lte=req['amountEnd'])
if param_exist("dateStart",req):
q = q.filter(date__gte=DateService.invert(req['dateStart']))
if param_exist("dateEnd",req):
q = q.filter(date__lte=DateService.invert(req['dateEnd']))
if param_exist("subC",req):
q = q.filter(subCategory=req['subC'])
elif param_exist("cat",req):
c = SubCategory.objects.filter(category=req['cat'])
q = q.filter(subCategory__in=c)
if param_exist("payT",req):
q = q.filter(paymentType=req['payT'])
if param_exist("sort",req):
q = q.order_by(sortMethod(req))
if param_exist("limit",req):
list = q[req['start']:req['start']+req['limit']]
else:
list = q
res = []
for exp in list:
res.append({'id': exp.id, 'amount': exp.amount, 'date': exp.date,
'text': exp.text, 'paymentType_name': exp.paymentType.name,
'subCategory_name': exp.subCategory.name, 'paymentTypeId': exp.paymentType.id,
'subCategoryId': exp.subCategory.id})
data = '{"total": %s, "rows": %s}' % (q.count(), JsonParser.parse(res))
return data
def list(request):
req = request.REQUEST
# find close date
dateQuery = CardDates.objects.filter(closeDate__gt=DateService.todayDate())
dateQuery = dateQuery.order_by('closeDate')
if dateQuery.count()>0:
dt = dateQuery[:1][0]
else:
dt = CardDates(closeDate=DateService.todayDate(), expireDate=DateService.todayDate())
q = CardData.objects.extra(where=["ADDDATE(date, INTERVAL ((instalments+1) * 30) DAY) > '%s'" % DateService.invert(dt.closeDate)])
if param_exist("sort",req):
q = q.order_by(sortMethod(req))
if param_exist("limit",req):
start = req['start']
limit = req['limit']
list = q[start:start+limit]
else:
list = q
res = []
for exp in list:
rem = FinancialService.remainInstalments(exp.date, dt.closeDate, exp.instalments)
if rem >= 0:
res.append({'id': exp.id, 'date': exp.date,
'shop': exp.shop, 'instalments': exp.instalments,
'card_id': exp.card.id, 'card_name': exp.card.name,
'total': exp.total, 'own': exp.own,
'partial': exp.total / exp.instalments,
'remain': rem })
data = '{"total": %s,"close": "%s", "expire": "%s", "rows": %s}' % (CardData.objects.count(), DateService.format(dt.closeDate),DateService.format(dt.expireDate), JsonParser.parse(res))
return data
def monthCalc(request):
req = request.REQUEST
if param_exist("date",req):
date = DateService.parse(req['date'])
else:
date = DateService.today()
fromDate = DateService.firstDateOfMonth(date)
toDate = DateService.lastDateOfMonth(date)
q = Expense.objects.extra(select={'sum': 'sum(amount)'}).values('sum','date')
#q = Expense.objects.filter(date__gte=fromDate, date__lte=toDate)
q = q.filter(date__gte=fromDate, date__lte=toDate).order_by('date')
if param_exist("subC",req):
q = q.filter(subCategory=req['subC'])
elif param_exist("cat",req):
c = SubCategory.objects.filter(category=req['cat'])
q = q.filter(subCategory__in=c)
if param_exist("payT",req):
q = q.filter(paymentType=req['payT'])
q.query.group_by = ['date']
list = []
for exp in q:
list.append('[%d,%s]' % (int(DateService.toLong(exp['date'])),exp['sum']))
data = "[" + ",".join(list) + "]"
return data
def taxHome(request):
# some stuff are resolved using python code instead of django queryset because limitations of appengine
limit = (datetime.datetime.now() + datetime.timedelta(days=getattr(settings,'TAX_DEFAULT_DAYS_ADVANCE', 5)))
upcoming = Tax.objects.filter(expire__lte=limit).order_by('expire')
upcoming = [tax for tax in upcoming if tax.amount > 0]
current = Tax.objects.filter(expire__range=(DateService.firstDateOfMonth(datetime.date.today()), DateService.lastDateOfMonth(datetime.date.today())))
nextList = Tax.objects.filter(expire__range=DateService.getMonthDateRange(DateService.addMonth(DateService.todayDate(), 1)))
return {"list": upcoming, "listmonth": sorted(current, key=lambda service: tax.service), "listnextmonth": sorted(nextList, key=lambda service: tax.service)}
def incomeList(request):
req = request.POST
if RequestUtils.param_exist("fromDate", req):
fromDate = DateService.parseDate(req['fromDate'])
else:
dt = datetime.date.today() - datetime.timedelta(days=getattr(settings,'INCOME_DEFAULT_DAYS_AHEAD', 90))
fromDate = datetime.date(dt.year, dt.month, 1)
q = Income.objects.filter(period__gte = DateService.midNight(fromDate))
q = q.order_by("-period")
return {"list": q,
"filterStart": fromDate}
def update(request):
req = request.REQUEST
c = Card(pk=req['card.id'])
p = CardDates(pk=req['id'],closeDate=DateService.invert(req['closeDate']),
expireDate=DateService.invert(req['expireDate']),
card=c)
data = '{"success":true}'
try:
p.save()
except _mysql_exceptions.Warning:
pass
except Exception, e1:
data = '{"success":false, "msg": "%s"}' % (e1.args)
def handle(self, *args, **options):
list = Debits.objects.filter(Q(since__lte=datetime.now()) & (Q(last__isnull=True) | Q(last__lt=DateService.firstDateOfMonth(DateService.today()))))
for debit in list:
Expense.objects.create(text=debit.text,
amount=debit.amount,
subCategory=debit.subCategory,
paymentType=debit.paymentType,
date=DateService.invert(DateService.parse("%d/%d/%d" % (debit.day,
DateService.today().tm_mon,
DateService.today().tm_year))))
debit.last = datetime.now()
debit.save()
self.stdout.write("Processed %d\n" % list.count())
def get_loan_to_save(data, amount = None, lid = None):
if not lid:
l = Loan.objects.get(pk=data['loan.id'])
else:
l = Loan.objects.get(pk=lid)
if not amount:
amount = round(l.amount / l.instalments,2)
if amount > l.remain:
amount = l.remain
validate_amount(amount)
if param_exist("id",data):
p = Payment.objects.get(pk=data['id'])
prevAmount = p.amount
else:
p = Payment(loan=l)
prevAmount = None
if checkPayment(l,amount,prevAmount):
if prevAmount:
diff = float(prevAmount) - float(amount)
l.remain = unicode(float(l.remain) + diff)
else:
l.remain = unicode(float(l.remain) - float(amount))
p.amount=amount
p.date=DateService.parseDate(data['date'])
else:
raise ValidationError(_('The entered amount is greater than the amount owed.'))
return (l,p)
def save_or_update(request):
req = request.REQUEST
dt = DateService.parse(req['period'])
dt = datetime.date(dt.tm_year, dt.tm_mon, 1)
amount=req['amount']
try:
validate_amount(amount)
except ValidationError, va1:
return '{"success":false, "msg": "%s"}' % ("".join(va1.messages))
def calc(request):
req = request.REQUEST
if param_exist("date",req):
date = DateService.parse(req['date'])
else:
date = DateService.today()
fromDate = DateService.firstDateOfMonth(date)
toDate = DateService.lastDateOfMonth(date)
q = Expense.objects.filter(date__gte=fromDate, date__lte=toDate)
if param_exist("subC",req):
q = q.filter(subCategory=req['subC'])
elif param_exist("cat",req):
c = SubCategory.objects.filter(category=req['cat'])
q = q.filter(subCategory__in=c)
if param_exist("payT",req):
q = q.filter(paymentType=req['payT'])
sum=0
for exp in q:
sum+=exp.amount
today = DateService.today()
if today.tm_year==date.tm_year and today.tm_mon==date.tm_mon:
days=today.tm_mday
else:
days=DateService.lastDayOfMonth(date)
avg = sum / days
data = '{"data":{"total":%s,"avg":%s}}' % (sum,avg)
return data
def req_to_obj(request):
req = request.REQUEST
if req.has_key("id"):
obj = Debits.objects.get(pk=req["id"])
else:
obj = Debits()
obj.day = req["day"]
obj.subCategory = SubCategory.objects.get(pk=req["subCategory.id"])
obj.paymentType = PaymentType.objects.get(pk=req["paymentType.id"])
obj.text = req["text"]
obj.amount = req["amount"]
obj.since = DateService.invert(req["since"])
return obj
def backup(request):
if RequestUtils.param_exist("date", request.REQUEST):
today = datetime.datetime.strptime(request.REQUEST['date'],"%Y%m%d")
else:
today = datetime.date.today()
fromDate = DateService.midNight(today - datetime.timedelta(days=7))
toDate = DateService.midNight(today)
try:
records = SyncRecord.objects.filter(created__gte=fromDate, created__lt=toDate)
data = serializers.serialize("xml", records);
filename = "%s_cashbackup.xml" % today.strftime("%Y%m%d")
filedata = StringIO.StringIO()
zipped = gzip.GzipFile(filename, 'wb', fileobj=filedata)
zipped.write(data)
zipped.close()
st = StorageService()
st.file_put(filedata.getvalue(), filename + ".gz")
error = ''
except Exception, e:
logger.error(str(e))
send_mail("EXPORT ERROR", 'Processing %s.\n\nError: %s' % (today.strftime("%Y-%m-%d"), str(e)))
error=str(e)
def stats(request):
req = request.REQUEST
toDate = DateService.today()
fromDate = datetime.date(toDate.tm_year, toDate.tm_mon, 1)
fromDate = DateService.addMonth(fromDate,-12)
toDate = datetime.date(toDate.tm_year, toDate.tm_mon, 1)
q = Income.objects.values('period').annotate(sum=Sum('amount'))
q = q.filter(period__gte=fromDate, period__lte=toDate).order_by('period')
# q = Income.objects.extra(select={'sum': 'sum(amount)'}).values('sum','period')
# q = q.filter(period__gte=fromDate, period__lte=toDate).order_by('period')
# q.query.group_by = ['period']
#q = Income.objects.filter(period__gte=fromDate, period__lte=toDate).order_by('period')
list = []
for exp in q:
#list.append('[%d,%s]' % (int(DateService.toLong(exp.period)),exp.amount))
list.append('[%d,%s]' % (int(DateService.toLong(exp['period'])),exp['sum']))
data = "[" + ",".join(list) + "]"
return data
def generate():
date = DateService.addMonth(DateService.todayDate(),-1)
fromDate = DateService.addMonth(DateService.firstDateOfMonth(date),-6)
toDate = DateService.lastDateOfMonth(date)
values = DateService.getMonthRange(fromDate, toDate)
for value in values:
create_stats(*value)
def fromParams(req):
if param_exist("id",req):
e = CardData(pk=req['id'])
else:
e = CardData()
c = Card(pk=req['card.id'])
e.date=DateService.invert(req['date'])
e.shop=req['shop']
e.instalments=req['instalments']
e.total=req['total']
e.card = c
return e
def report(request):
if RequestUtils.param_exist("date", request.REQUEST):
date = DateService.parseDate(request.REQUEST['date'])
else:
date = DateService.addMonth(DateService.todayDate(),-1)
fromDate = DateService.midNight(DateService.firstDateOfMonth(date))
toDate = DateService.midNight(DateService.lastDateOfMonth(date),True)
try:
q = Expense.objects.filter(date__gte=fromDate, date__lte=toDate)
filedata = StringIO.StringIO()
filedata.write('"pk","date","text","amount","paymentTypePk","paymentTypeName","categoryPk","categoryName","subCategoryPk","subCategoryName"\n')
for expense in q:
d = {'pk': expense.pk,
'date': DateService.invert(expense.date),
'text': expense.text,
'amount': expense.amount,
'paymentTypePk': expense.paymentType.pk,
'paymentTypeName': expense.paymentType.name,
'categoryPk': expense.subCategory.category.pk,
'categoryName': expense.subCategory.category.name,
'subCategoryPk': expense.subCategory.pk,
'subCategoryName': expense.subCategory.name}
filedata.write(smart_str('%(pk)s,%(date)s,"%(text)s",%(amount)s,%(paymentTypePk)s,"%(paymentTypeName)s",%(categoryPk)s,"%(categoryName)s",%(subCategoryPk)s,"%(subCategoryName)s"\n' % d, 'latin1'))
filename = "expensereport_%s.csv" % fromDate.strftime("%Y%m")
if RequestUtils.param_exist("gz", request.REQUEST):
filezip = StringIO.StringIO()
zipped = gzip.GzipFile(filename, 'wb', fileobj=filezip)
zipped.write(filedata)
zipped.close()
st = StorageService()
st.file_put(filezip.getvalue(), filename + ".gz")
else:
st = StorageService()
st.file_put(filedata.getvalue(), filename)
error = ''
except Exception, e:
logger.error(str(e))
send_mail("EXPORT ERROR", 'Processing %s.\n\nError: %s' % (fromDate.strftime("%Y-%m"), str(e)))
error=str(e)
def fromParams(req):
s = SubCategory.objects.get(pk=req['subCategory.id'])
p = PaymentType(pk=req['paymentType.id'])
if param_exist("text",req):
text = req['text']
else:
text = s.name
if param_exist("id",req):
e = Expense.objects.get(pk=req['id'])
else:
e = Expense()
e.text=text
e.date=DateService.invert(req['date'])
e.amount=req['amount']
e.subCategory=s
e.paymentType=p
return e
def sixMonthCalc(request):
req = request.REQUEST
if param_exist("date",req):
date = DateService.parse(req['date'])
else:
date = DateService.today()
fromDate = DateService.addMonth(DateService.firstDateOfMonth(date),-6)
toDate = DateService.lastDateOfMonth(date)
query = "SELECT sum(amount), date FROM expense "\
"WHERE date between '%s' and '%s'" % (str(fromDate), str(toDate))
if param_exist("subC",req):
query += " AND sub_category_id = '%s'" % req['subC']
elif param_exist("cat",req):
c = SubCategory.objects.filter(category=req['cat'])
query += " AND sub_category_id in (%s)" % ",".join(["'"+str(s.id)+"'" for s in c])
if param_exist("payT",req):
query += " AND payment_type_id = '%s'" % req['payT']
query += " group by month(date)"
cursor = connection.cursor()
cursor.execute(query)
list = []
for exp in cursor.fetchall():
sum, date = exp
i = Income.objects.extra(select={'sum': 'sum(amount)'}).values('sum')
i = i.filter(period = DateService.firstDateOfMonth(date.timetuple()))
val = i[0]['sum']
if val is None:
val = 0
list.append({'date': date, 'expense': sum, 'income': val})
data = '{"rows": %s}' % (JsonParser.parse(list))
return data
def generate_current():
date = DateService.todayDate()
fromDate = DateService.firstDateOfMonth(date)
toDate = DateService.lastDateOfMonth(date)
create_stats(fromDate, toDate)
p.save()
amount += float(p.amount)
except _mysql_exceptions.Warning:
pass
except Exception, e1:
failed.append(l.reason)
if param_exist('subCategory.id', req) and not req['subCategory.id'] == '0':
try:
subCategory = SubCategory.objects.get(pk=req['subCategory.id'])
pt = getattr(settings,'LOAN_PAYMENT_TYPE', None)
if pt:
paymentType = PaymentType.objects.get(pk=pt)
Expense.objects.create(amount=-1*amount,
text=subCategory.name,
date=DateService.parseDate(req['date']),
subCategory=subCategory,
paymentType=paymentType)
except Exception, e2:
failed.append(e2)
if len(failed) > 0:
return '{"success":false, "msg": "Failed to save %s"}' % ",".join(failed)
return data
#deprecated
@json_response
def save_or_update_old(request):
data = '{"success":true}'
req = request.REQUEST
amount=req['amount']
def current_date(request):
from pycash.services import DateService
return {'today': DateService.todayDate()}
