def send_email(self):
if not authorized(ValidAuthKitUser()):
return { "failure" : Messages.invalidSession() }
try:
to_address = request.params['to_address']
subject = request.params['subject']
body = request.params['body']
except:
return { "failure" : Messages.invalidArguments() }
if to_address == "" or subject == "" or body == "":
return { "failure" : Messages.invalidArguments() }
from email.MIMEText import MIMEText
message = MIMEText(body.encode('utf-8'), 'plain', 'utf-8')
message['Subject'] = subject
message['From'] = config['from_address']
message['To'] = to_address
try:
from fivecents.lib.mail import EmailSender
ms = EmailSender(to_addresses = to_address)
ms.send_mime(message)
except Exception, e:
return { "failure" : Messages.failedToSendEmail(exception=e) }
def add(self):
model = request.environ["sqlalchemy.model"]
db = request.environ["sqlalchemy.session"]
try:
name = request.params['name']
except:
return { "failure": Messages.invalidArguments() }
if name == "":
return { "failure": Messages.invalidArguments() }
try:
user = db.query(model.AuthenticatedUser).filter_by(uid = h.authenticated_user().uid).one()
balance = model.Balance(name = name,)
user_balance = model.UserBalance(user_uid=h.authenticated_user().uid, writable=True)
balance.users.append(user_balance)
user.balances.append(user_balance)
db.save(balance)
# ensure we set writable to true (needed only with sqlite3)
#ub = db.query(model.UserBalance).filter_by(user_uid=session[BaseController.AUTHENTICATED_USER], balance_uid=balance.uid).one()
#ub.writable = True
#db.save(ub)
db.commit()
except IntegrityError, e:
return { "failure": Messages.primaryKeyViolation() }
def send_email(self):
"""
Will send an e-mail with to a given address.
Only authenticated users can use it.
"""
if not authorized(ValidAuthKitUser()):
return { "failure" : Messages.invalidSession() }
to_address = request.params.get('to_address')
subject = request.params.get('subject')
body = request.params.get('body')
if not to_address or not subject or not body:
return { "failure" : Messages.invalidArguments() }
from email.MIMEText import MIMEText
message = MIMEText(body.encode('utf-8'), 'plain', 'utf-8')
message['Subject'] = subject
message['From'] = config['from_address']
message['To'] = to_address
try:
self.emailSender().send_mime(to_address, config['from_address'], message)
except Exception, e:
return { "failure" : Messages.failedToSendEmail(exception=e) }
def category(self):
dbFacade = self.dbFacade()
result = {}
category = dbFacade.balances.categoryDao.find_by_name(request.params.get('category'))
if category is None:
return { "failure": Messages.invalidArguments() }
for id in request.params.getall('id'):
try:
item = dbFacade.balances.changeDao.find_by_uid(id, options=[eagerload('balance')])
if item is None:
result[id] = {
"deleted" : False,
"message": Messages.elementNotFound(key=id)
}
continue
if not item.balance or not item.balance.can_modify_balance(h.authenticated_user().uid):
result[id] = {
"deleted" : False,
"message": Messages.permissionDenied()
}
continue
item.category = category.name
dbFacade.db.commit()
result[id] = { "modified" : True }
except Exception, e:
result[id] = {
"deleted" : False,
"message" : Messages.failedToDelete(exception=e),
}
def send_invitation(self):
model = self.get_sa_model()
db = self.get_sa_session()
if not authorized(ValidAuthKitUser()):
return { "failure" : Messages.invalidSession() }
to_address = request.params.get('to_address')
body = request.params.get('body')
if not to_address or not body:
return { "failure" : Messages.invalidArguments() }
invitation = db.query(model.Invitation).filter_by(to_address = to_address).filter_by(sender_uid=h.authenticated_user().uid).first()
if invitation:
invitation.message = body
invitation.sent = False
invitation.sent_on = datetime.today()
else:
invitation = model.Invitation(
sender_uid = h.authenticated_user().uid,
to_address = to_address,
message = body
)
db.save(invitation)
db.commit()
return { "success" : Messages.messageWasSent() }
def edit_many(self):
model = request.environ["sqlalchemy.model"]
db = request.environ["sqlalchemy.session"]
modified = []
if not request.params.has_key("uids"):
return {"failure": Messages.invalidArguments()}
for uid in request.params.getall("uids"):
try:
if not Operations(db, model).can_modify_balance(h.authenticated_user().uid, uid):
continue
balance = db.query(model.Balance).filter_by(uid=uid).one()
name = request.params["name_%s" % (uid)]
if name == "":
continue
balance.name = name
db.commit()
modified.append({"uid": uid})
except:
# if it fails just skip it and go for next
continue
return modified
def add(self):
db = request.environ['sqlalchemy.session']
model = request.environ['sqlalchemy.model']
try:
name = request.params['name']
except:
return { "failure": Messages.invalidArguments() }
if name == "":
return { "failure": Messages.invalidArguments() }
try:
ec = model.ExpenseCategory(name = name,)
db.save(ec)
db.commit()
except IntegrityError, e:
return { "failure": Messages.primaryKeyViolation() }
def add(self):
db = self.get_sa_session()
model = self.get_sa_model()
try:
name = request.params['name']
except:
return { "failure": Messages.invalidArguments() }
if name == "":
return { "failure": Messages.invalidArguments() }
try:
ec = model.ChangeCategory(name = name,)
db.save(ec)
db.commit()
except IntegrityError, e:
return { "failure": Messages.primaryKeyViolation() }
def send_feedback(self):
try:
from_address = request.params['from_address']
subject = _("Feedback about %s " % h.site_name())
body = request.params['body']
except:
return { "failure" : Messages.invalidArguments() }
if from_address == "" or subject == "" or body == "":
return { "failure" : Messages.invalidArguments() }
from email.MIMEText import MIMEText
message = MIMEText(body.encode('utf-8'), 'plain', 'utf-8')
message['Subject'] = subject
message['From'] = from_address
message['To'] = config['email_to']
try:
from fivecents.lib.mail import EmailSender
ms = EmailSender(to_addresses = message['To'])
ms.send_mime(message)
except Exception, e:
return { "failure" : Messages.failedToSendEmail(exception=e) }
def send_invitation(self):
model = request.environ["sqlalchemy.model"]
db = request.environ["sqlalchemy.session"]
if not authorized(ValidAuthKitUser()):
return { "failure" : Messages.invalidSession() }
try:
to_address = request.params['to_address']
subject = _("You have been invited to %s " % h.site_name())
body = request.params['body']
except:
return { "failure" : Messages.invalidArguments() }
if to_address == "" or subject == "" or body == "":
return { "failure" : Messages.invalidArguments() }
invitation = model.Invitation(
sender_uid = h.authenticated_user().uid,
to_address = to_address,
)
db.save(invitation)
db.commit()
c.invitation_link = h.site_url() + h.url_for(controller='signup', action='invitation', id=invitation.token)
from email.MIMEText import MIMEText
body = body + render_jinja('messages/invitation_footer.jinja')
message = MIMEText(body.encode('utf-8'), 'plain', 'utf-8')
message['Subject'] = subject
message['From'] = config['from_address']
message['To'] = to_address
try:
from fivecents.lib.mail import EmailSender
ms = EmailSender(to_addresses = to_address)
ms.send_mime(message)
except Exception, e:
return { "failure" : Messages.failedToSendEmail(exception=e) }
def add(self, balance_uid):
model = request.environ['sqlalchemy.model']
db = request.environ['sqlalchemy.session']
balance = db.query(model.Balance).filter_by(uid = balance_uid).first()
if not balance or not balance.can_modify_balance(h.authenticated_user().uid):
return { "failure": Messages.permissionDenied() }
try:
with localcontext() as ctx:
ctx.prec = 2
try:
amount = h.parse_decimal(request.params['amount'])
except:
log.error("Invalid number: %s" % request.params.get('amount'), exc_info=1)
return { "failure": Messages.invalidCurrencyFormat() }
expense_date = h.parse_date(request.params['occurred_on'])
income_category_uid = None
expense_category_uid = None
if (int(request.params['is_income']) >= 0):
income_category_uid = int(request.params['income_category_uid'])
is_income = True
else:
expense_category_uid = int(request.params['expense_category_uid'])
is_income = False
except:
log.error("Failed to parse arguments %s" % str(request.params), exc_info=1)
return { "failure": Messages.invalidArguments() }
tags = request.params.get('tags', '')
description = request.params.get('description', '')
bc = model.BalanceChange(
amount = amount,
description = description,
user_uid = h.authenticated_user().uid,
expense_category_uid = expense_category_uid,
occurred_on = expense_date,
is_income = is_income,
income_category_uid = income_category_uid
)
balance.changes.append(bc)
db.flush()
ops = Operations(db, model)
ops.change_tags_from_string(bc, tags)
ops.save_balance_change(bc)
return { "id" : bc.uid }
def add(self, balance_uid):
model = request.environ['sqlalchemy.model']
db = request.environ['sqlalchemy.session']
if not Operations(db, model).can_modify_balance(h.authenticated_user().uid, balance_uid):
return { "failure": Messages.permissionDenied() }
try:
with localcontext() as ctx:
ctx.prec = 2
try:
amount = h.parse_decimal(request.params['amount'])
except NumberFormatError:
return { "failure": Messages.invalidCurrencyFormat() }
expense_date = parser.parse(request.params['occurred_on'])
income_category_uid = None
expense_category_uid = None
if (int(request.params['is_income']) >= 0):
income_category_uid = int(request.params['income_category_uid'])
is_income = True
else:
expense_category_uid = int(request.params['expense_category_uid'])
is_income = False
except:
return { "failure": Messages.invalidArguments() }
tags = request.params.get('tags', '')
try:
description = request.params['description']
except:
description = ""
try:
bc = model.BalanceChange(
amount = amount,
description = description,
balance_uid = balance_uid,
user_uid = h.authenticated_user().uid,
expense_category_uid = expense_category_uid,
occurred_on = expense_date,
is_income = is_income,
income_category_uid = income_category_uid
)
ops = Operations(db, model)
ops.change_tags_from_string(bc, tags)
ops.save_balance_change(bc)
except IntegrityError, e:
return { "failure": Messages.primaryKeyViolation() }
def add(self):
model = request.environ["sqlalchemy.model"]
db = request.environ["sqlalchemy.session"]
name = request.params.get('name')
if not name:
return { "failure": Messages.invalidArguments() }
try:
ec = model.IncomeCategory(name = name,)
db.save(ec)
db.commit()
except IntegrityError, e:
return { "failure": Messages.primaryKeyViolation() }
def _edit_stock(self, stock):
try:
stock.ticker = request.params['ticker'][0:50].upper()
except:
return { "failure": Messages.invalidArguments() }
try:
stock.count = int(request.params['count'])
except:
return { "failure": Messages.invalidArguments() }
try:
stock.buy = asbool(request.params['buy'])
except:
return { "failure": Messages.invalidArguments() }
try:
with localcontext() as ctx:
ctx.prec = 2
stock.price = h.parse_decimal(request.params['price'])
except:
log.error("Invalid number: %s" % request.params.get('amount'), exc_info=1)
return { "failure": Messages.invalidCurrencyFormat() }
try:
stock.occurred_on = h.parse_date(request.params['occurred_on'])
except:
return { "failure": Messages.invalidDate() }
if stock.user is None:
stock.user = h.authenticated_user()
self.dbFacade().stocks.changeDao.save(stock)
self.dbFacade().db.commit()
return { "id" : stock.uid }
def add(self, balance_uid):
dbFacade = DbFacade(request.environ['sqlalchemy.session'], request.environ['sqlalchemy.model'])
balance = dbFacade.balances.balanceDao.find_by_uid(balance_uid)
if not balance or not balance.can_modify_balance(h.authenticated_user().uid):
return { "failure": Messages.permissionDenied() }
try:
with localcontext() as ctx:
ctx.prec = 2
try:
amount = h.parse_decimal(request.params['amount'])
except:
log.error("Invalid number: %s" % request.params.get('amount'), exc_info=1)
return { "failure": Messages.invalidCurrencyFormat() }
expense_date = h.parse_date(request.params['occurred_on'])
income_category_uid = None
expense_category_uid = None
if (int(request.params['is_income']) >= 0):
income_category_uid = int(request.params['income_category_uid'])
is_income = True
else:
expense_category_uid = int(request.params['expense_category_uid'])
is_income = False
except:
log.error("Failed to parse arguments %s" % str(request.params), exc_info=1)
return { "failure": Messages.invalidArguments() }
tags = request.params.get('tags', '')
description = request.params.get('description', '')
bc = dbFacade.model.BalanceChange(
amount = amount,
description = description,
user_uid = h.authenticated_user().uid,
expense_category_uid = expense_category_uid,
occurred_on = expense_date,
is_income = is_income,
income_category_uid = income_category_uid
)
bc.tags = dbFacade.balances.find_or_create_tags(balance,
dbFacade.balances.elements_from_string(tags))
dbFacade.balances.add_balance_change(balance, bc)
dbFacade.db.commit()
return { "id" : bc.uid }
def send_feedback(self):
from_address = request.params.get('from_address')
subject = _("Feedback about %s ") % h.site_name()
body = request.params.get('body')
if not from_address or not subject or not body:
return { "failure" : Messages.invalidArguments() }
from email.MIMEText import MIMEText
message = MIMEText(body.encode('utf-8'), 'plain', 'utf-8')
message['Subject'] = subject
message['From'] = from_address
message['To'] = config['email_to']
try:
self.emailSender().send_mime(config['email_to'], from_address, message)
except Exception, e:
return { "failure" : Messages.failedToSendEmail(exception=e) }
def add(self):
model = request.environ["sqlalchemy.model"]
db = request.environ["sqlalchemy.session"]
name = request.params.get("name")
if not name:
return {"failure": Messages.invalidArguments()}
try:
user = db.query(model.AuthenticatedUser).filter_by(uid=h.authenticated_user().uid).one()
balance = model.Balance(name=name)
user_balance = model.UserBalance(user_uid=h.authenticated_user().uid, writable=True)
balance.users.append(user_balance)
user.balances.append(user_balance)
db.save(balance)
db.commit()
except IntegrityError, e:
return {"failure": Messages.primaryKeyViolation()}
def _edit_balance(self, balance):
if balance.uid is not None:
if not balance.can_modify_balance(h.authenticated_user().uid):
return { "failure": Messages.permissionDenied() }
try:
balance.name = request.params['name'][0:25]
except:
return { "failure": Messages.invalidArguments() }
if len(balance.users.all()) == 0:
user_balance = self.dbFacade().model.UserBalance(user_uid=h.authenticated_user().uid, writable=True)
balance.users.append(user_balance)
h.authenticated_user().balances.append(user_balance)
self.dbFacade().balances.balanceDao.save(balance)
self.dbFacade().db.commit()
return { "id" : balance.uid }
def edit_many(self):
model = request.environ["sqlalchemy.model"]
db = request.environ["sqlalchemy.session"]
modified = []
if not request.params.has_key('uids'):
return { "failure": Messages.invalidArguments() }
for uid in request.params.getall("uids"):
try:
ec = db.query(model.IncomeCategory).filter_by(uid=uid).one()
name = request.params['name_%s' % (uid)]
if name == "":
continue
ec.name = name
db.commit()
modified.append({"uid" : uid})
except:
# if it fails just skip it and go for next
continue
return modified
def edit_many(self):
db = self.get_sa_session()
model = self.get_sa_model()
modified = []
if not request.params.has_key('uids'):
return { "failure": Messages.invalidArguments() }
for uid in request.params.getall("uids"):
try:
ec = db.query(model.ChangeCategory).filter_by(uid=uid).one()
name = request.params.get('name_%s' % (uid))
if not name:
continue
ec.name = name
db.commit()
modified.append({"uid" : uid})
except:
# if it fails just skip it and go for next
continue
return modified
def list_months(self, balance_uid):
model = request.environ['sqlalchemy.model']
db = request.environ['sqlalchemy.session']
try:
user_uid = h.authenticated_user().uid
except:
return { "failure": Messages.invalidArguments() }
if not Operations(db, model).can_see_balance(user_uid, balance_uid):
return { "failure": Messages.permissionDenied() }
months = db.execute(
select(
[extract('year', model.BalanceChange.c.occurred_on).label('year'), extract('month', model.BalanceChange.c.occurred_on).label('month')],
model.BalanceChange.c.balance_uid==balance_uid,
from_obj=[model.balance_changes_table],
group_by=[extract('year', model.BalanceChange.c.occurred_on), extract('month', model.BalanceChange.c.occurred_on)])).fetchall()
total = len(months)
try:
page_nr = request.params['page_nr']
except:
page_nr = 1
try:
items_per_page = int(request.params['items_per_page'])
except:
items_per_page = 15
subset = Page(months, item_count=total, current_page=page_nr, items_per_page=items_per_page)
return {
"totalItems" : total,
"itemsFound" : len(subset),
"items" : [{
"year" : int(item.year),
"month": int(item.month) } for item in subset ]
}
def _edit_category(self, category_tc, is_new = True):
dbFacade = self.dbFacade();
new_category_name = request.params.get('name');
parent_name = request.params.get('parent');
if dbFacade.balances.categoryDao.find_by_name(new_category_name, h.authenticated_user().uid):
return { "failure" : Messages.categoryAlreadyExists(name=new_category_name) }
parent_tc = dbFacade.balances.categoryDao.find_by_name(parent_name, h.authenticated_user().uid)
if not parent_tc or parent_tc.name == '' or not new_category_name:
return { "failure" : Messages.invalidArguments() }
if not hasattr(parent_tc, 'subcats') or not parent_tc.subcats:
return { "failure" : Messages.wrongParentCategory(name=parent_name) }
category_tc.name = new_category_name
category_tc.parent = parent_tc.key
category_tc.user_uid = h.authenticated_user().uid
dbFacade.balances.categoryDao.save(category_tc)
if not is_new:
self._change_changes_category(request.params.get('old_name'), new_category_name)
dbFacade.db.commit()
return { "id" : category_tc.uid }
def _edit_change(self, to_bc):
dbFacade = self.dbFacade()
if to_bc.uid is not None:
if not to_bc.balance or not to_bc.balance.can_modify_balance(h.authenticated_user().uid):
return { "failure": Messages.permissionDenied() }
# If it's a transfer check if user can modify the other balance
if to_bc.transfer:
old_from_balance = dbFacade.balances.balanceDao.find_by_uid(to_bc.transfer.balance_uid)
if not old_from_balance or not old_from_balance.can_modify_balance(h.authenticated_user().uid):
return { "failure": Messages.permissionDenied() }
to_balance_uid = request.params.get('to_balance_uid')
to_balance = dbFacade.balances.balanceDao.find_by_uid(to_balance_uid)
if not to_balance or not to_balance.can_modify_balance(h.authenticated_user().uid):
return { "failure": Messages.permissionDenied() }
try:
with localcontext() as ctx:
ctx.prec = 2
to_bc.amount = h.parse_decimal(request.params['amount'])
except:
log.error("Invalid number: %s" % request.params.get('amount'), exc_info=1)
return { "failure": Messages.invalidCurrencyFormat() }
try:
to_bc.occurred_on = h.parse_date(request.params['occurred_on'])
except:
return { "failure": Messages.invalidDate() }
try:
to_bc.change_category_uid = int(request.params['change_category_uid'])
except:
log.error("Failed to parse arguments %s" % str(request.params), exc_info=1)
return { "failure": Messages.invalidArguments() }
to_bc.balance = to_balance
to_bc.tags = [dbFacade.model.ChangeTag(tag=tag) for tag in dbFacade.balances.elements_from_string(request.params.get('tags', ''))]
to_bc.description = request.params.get('description', '')
to_bc.user_uid = h.authenticated_user().uid
from_balance_uid = request.params.get('from_balance_uid')
if from_balance_uid is not None:
if from_balance_uid == to_balance_uid:
return { "failure": Messages.pleaseSelectDifferentAccounts() }
from_balance = dbFacade.balances.balanceDao.find_by_uid(from_balance_uid)
if not from_balance or not from_balance.can_modify_balance(h.authenticated_user().uid):
return { "failure": Messages.permissionDenied() }
from_bc = to_bc.transfer and to_bc.transfer or dbFacade.model.BalanceChange()
to_bc.amount = abs(to_bc.amount)
from_bc.amount = -to_bc.amount
from_bc.occurred_on = to_bc.occurred_on
from_bc.change_category_uid = to_bc.change_category_uid
from_bc.balance = from_balance
from_bc.tags = [dbFacade.model.ChangeTag(tag=tag) for tag in dbFacade.balances.elements_from_string(request.params.get('tags', ''))]
from_bc.description = to_bc.description
from_bc.user_uid = h.authenticated_user().uid
from_bc.transfer = to_bc
to_bc.transfer = from_bc
elif to_bc.transfer is not None:
from_bc = to_bc.transfer
from_bc.transfer = None
to_bc.transfer = None
dbFacade.db.flush()
dbFacade.db.delete(from_bc)
dbFacade.balances.changeDao.save(to_bc)
dbFacade.db.commit()
return { "id" : to_bc.uid }
