def GET(self):
context = Storage(
title=_("List of points"),
status=Storage(
add="add",
loc=location_indicator(), # !!! define better later
hom="home",
sea="search",
inf="info",
),
)
page_nav_data = Storage(
nav_data = nav_data(
add=links.add_point,
loc=links.place,
hom=links.home,
sea=links.search,
inf=None,
),
)
context.page_nav_data = page_nav_data
context.about = model.doc_helper(context, "about", i18n.getLanguage())
get_page('info', context)
def get(self):
# Get user, group and user membership
user = users.get_current_user()
lang = getLanguage(self, user)
group = Group.get(self.request.get("group"))
groupMemberships = group.memberships
userMembership = findMembershipForUser(groupMemberships, user)
# Go to homepage if someone is trying to acces this group
# without being a member
if not userMembership:
self.redirect('/')
return
# Get memberships of the current user
userMemberships = membershipsOfUser(user)
userMemberships.sort(cmp = compareMembershipsByGroupNick)
hasUserMemberships = len(userMemberships) > 0
# Get user balance in this group
[balanceSign, balance] = self.getBalance(userMembership, groupMemberships, lang)
# Get user's transaction history for the "History" tab
try:
transactionCount = int(self.request.get('transactionCount', default_value=10))
transactions = self.getTransactionHistory(transactionCount, userMembership, lang)
transactionCount = len(transactions)
validationError = False
validationMessage = ''
except BaseException, e:
transactionCount = 0
transactions = []
validationError = True
validationMessage = '(' + _('This should be a number', lang) + ')'
def get(self):
user = users.get_current_user()
if user:
lang = getLanguage(self, user)
userMemberships = membershipsOfUser(user)
userMemberships.sort(cmp = compareMembershipsByGroupNick)
hasUserMemberships = len(userMemberships) > 0
if hasUserMemberships:
group = userMemberships[0].group
else:
group = 0
debts = self.getDebts(user, userMemberships, lang)
message = self.request.get('msg')
hasMessage = len(message) > 0
model = {
'username': user.nickname(),
'signout_url': users.create_logout_url("/"),
'debts': debts,
'hasUserMemberships': hasUserMemberships,
'userMemberships': userMemberships,
'group': group,
'hasMessage': hasMessage,
'message': message,
# i18n
'DontBelong': _("You don't belong to any group. You can create your own and invite your friends.", lang),
'Name': _('Name', lang),
'YouOweNobody': _('You owe nobody, and nobody owes you. Hurray!', lang),
'GoToGroup': _('Go to group', lang),
'SelectGroup': _('select group', lang),
'CreateGroup': _('Create Group', lang),
}
addMasterKeys(model, lang)
path = os.path.join(os.path.dirname(__file__), 'dashboard.html')
self.response.out.write(template.render(path, model))
else:
lang = getDefaultLanguage(self)
model = {
'loginurl': users.create_login_url("/"),
# i18n
'introduction': _('introduction', lang),
}
addMasterKeys(model, lang)
path = os.path.join(os.path.dirname(__file__), 'introduction.html')
self.response.out.write(template.render(path, model))
def post(self):
if not userIsLoggedIn(self):
return
user = users.get_current_user()
lang = getLanguage(self, user)
groupName = self.request.get('name').strip()
escapedGroupName = escape(groupName)
# Verificar que el nombre no sea vacio
if groupName == "":
error = _('You must enter a group name.', lang)
alertMessage(self,error)
return
group = self.createGroupAndInsertMember(groupName)
# Si el usuario es miembro de un grupo con alias igual al nombre
# del grupo que quiere crear, no dejarlo
if group is None:
error = _('You already belong to a group with the name %s.', lang) % escapedGroupName
error += '\\n';
error += _('Please select another name.', lang)
alertMessage(self,error)
return
location = '/group?group=%s&msg=%s' % (group.key(), _('Group successfully created', lang))
redirectPage(self,location)
def post(self):
if not userIsLoggedIn(self):
return
user = users.get_current_user()
lang = getLanguage(self, user)
groupKey = self.request.get('group').strip()
if groupKey == "":
error = _('Group is required', lang)
alertMessage(self,error)
return
group = Group.get(groupKey)
memberships = Membership.gql("WHERE group = :1 AND user = :2", group, user)
if memberships.count() <> 1:
error = _('You don\'t belong to this group.', lang)
alertMessage(self,error)
return
membership = memberships.get()
if not abs(membership.balance) <= 1e-07:
error = _('You cannot leave this group, your balance must be zero.', lang)
alertMessage(self,error)
return
membership.delete()
if Membership.gql("WHERE group = :1", group).count() == 0:
group.delete()
msg = _('You have been succesfully unsubscribed from the group %s!', lang) % escape(group.name)
location = '/?msg=' + msg
redirectPage(self,location)
def post(self):
if not userIsLoggedIn(self):
return
user = users.get_current_user()
lang = getLanguage(self, user)
type = self.request.get('type')
fromMember = Membership.get(self.request.get('fromMember'))
toMember = Membership.get(self.request.get('toMember'))
amount = self.request.get('amount')
reason = self.request.get('reason')
# See which one is the creator
if fromMember.user == user:
creatorMember = fromMember
elif toMember.user == user:
creatorMember = toMember
else:
# Can't happen, only with hackery
return
# Check that the amount is a valid number
try:
amount = float(amount)
except BaseException, e:
error = _('Invalid amount: %s.', lang) % amount
alertMessage(self, error)
return
def post(self):
if not userIsLoggedIn(self):
return
rejectPath = UrlBuilder(self.request).buildUrl('/reject')
user = users.get_current_user()
lang = getLanguage(self, user)
group = Group.get(self.request.get("group"))
creatorMember = Membership.gql("WHERE group = :1 AND user = :2", group, user)[0]
if not creatorMember:
return
command = self.request.get("cow")
members = group.memberships
parser = CowParser()
parser.lang = lang
transaction = parser.parse(members, command)
if transaction.error:
alertMessage(self, transaction.error)
return
result = transaction.getResult()
# Update balance and send mails
for member, balance in result.balanceChange.iteritems():
balanceBefore = member.balance
balanceNow = member.balance + balance
# Balance
member.balance += balance
member.put()
# Send mail, but not to the creator of this mail
if member.user != creatorMember.user:
message = createCowMail(creatorMember, transaction, result, member, balanceBefore, balanceNow, lang)
sendEmail(message)
# Create transactions
for debt in result.debts:
for singleDebt in debt.singleDebts:
tr = Transaction(
group = group,
creatorMember = creatorMember,
fromMember = debt.fromMember,
toMember = singleDebt.toMember,
type = 'debt',
amount = singleDebt.money,
reason = transaction.reason,
isRejected = False
)
tr.put()
location = '/group?group=%s&msg=%s' % (group.key(), _('Debts saved!', lang))
redirectPage(self,location)
def render(self):
import fckeditor, view, links, i18n
sBasePath = links.pc_links.fckeditor_base
oFCKeditor = fckeditor.FCKeditor(self.name)
oFCKeditor.BasePath = sBasePath
oFCKeditor.Value = view.render_text(self.value or "")
oFCKeditor.Config = {"CustomConfigurationsPath":
links.pc_links("editor_base_url",
AutoDetectLanguage="false",
DefaultLanguage=i18n.getLanguage())
}
return oFCKeditor.Create()
def render_editor(name, value):
import fckeditor, i18n
sBasePath = links.pc_links.fckeditor_base
oFCKeditor = fckeditor.FCKeditor(name)
oFCKeditor.BasePath = sBasePath
oFCKeditor.Value = render_text(value or "")
oFCKeditor.Config = {
"CustomConfigurationsPath":
links.pc_links("editor_base_url",
AutoDetectLanguage="false",
DefaultLanguage=i18n.getLanguage())
}
return oFCKeditor.Create()
def post(self):
if not userIsLoggedIn(self):
return
user = users.get_current_user()
lang = getLanguage(self, user)
userMembership = Membership.get(self.request.get('userMembership'))
# Verificar que la membership que se paso sea efectivamente del usuario
if not self.isMember(userMembership):
return
newGroupNick = self.request.get('groupNick').strip()
newUserNick = self.request.get('userNick').strip()
# Verificar que el nombre de grupo no sea vacio
if newGroupNick == "":
error = _('The name by which you want to see this group is required.', lang)
alertMessage(self,error)
return
# Verificar que no exista un alias del usuario con el mismo nombre
if self.isGroupNickTaken(newGroupNick, userMembership.group):
error = _('You already have a Group with the selected name, please select another name.', lang)
alertMessage(self,error)
return
# Verificar que el nickname no sea vacio
if newUserNick == "":
error = _('The name by which you want others to see you in this group is required.', lang)
alertMessage(self,error)
return
# Verificar que el nickname no este tomado
for other in Membership.gql("WHERE group = :1 AND user != :2", userMembership.group, userMembership.user):
if other.userNick == newUserNick:
error = _('The name by which you want others to see you in this group is already used by another member.', lang)
alertMessage(self,error)
return
userMembership.alias = newGroupNick
userMembership.nickname = newUserNick
userMembership.put()
location = '/group?group=%s&msg=%s' % (userMembership.group.key(), _('Properties changed!', lang))
redirectPage(self,location)
def post(self):
if not userIsLoggedIn(self):
return
user = users.get_current_user();
lang = getLanguage(self, user)
group = Group.get(self.request.get("group"))
creatorMember = Membership.gql("WHERE group = :1 AND user = :2", group, user)[0]
if not creatorMember:
return
command = self.request.get("command")
members = group.memberships
parser = OrderParser()
parser.lang = lang
transaction = parser.parse(members, command)
if transaction.error:
alertMessage(self, transaction.error)
return
elems = {}
total = 0.0
for debt in transaction.debts:
total += debt.money
razon = debt.reason
comidas = razon.split(',')
for comida in comidas:
comida = comida.strip()
[cantidad, comida2] = quantity(comida)
elems[comida2] = elems.get(comida2, 0) + cantidad
result = ''
for comida, cantidad in elems.items():
result += ' - %s %s\\n' % (cantidad, comida)
result += '\\n';
result += _('Total', lang)
result += ': $%s'% total;
alertMessage(self, result)
def _doc_render(template_name):
lang_specific_template = template_name + "_%s" % i18n.getLanguage()
default_lang_template = template_name + "_en"
render = None
# 1. local doc render with specific language
if local_doc_render:
render = getattr(local_doc_render, lang_specific_template, None)
if render is not None:
return render
# 2. doc render with specific language
render = getattr(doc_render, lang_specific_template, None)
if render is not None:
return render
# 3. local doc english
if local_doc_render:
render = getattr(local_doc_render, default_lang_template, None)
if render is not None:
return render
# 4. doc english
render = getattr(doc_render, default_lang_template, None)
if render is not None:
return render
return None
# 5. local doc no language
if local_doc_render:
render = getattr(local_doc_render, template_name, None)
if render is not None:
return render
# 6. doc no language
render = getattr(pc_render, template_name, None)
if render is not None:
return render
def get(self):
key = self.request.get('key')
hash = self.request.get('h')
cancel = self.request.get('cancel')
trCount = self.request.get('trcount')
user = users.get_current_user()
lang = getLanguage(self, user)
# Check that all is ok
tr = isValidTransaction(key, hash, user)
if not tr:
self.redirect('/')
return
template_values = {
'key' : key,
'h' : hash,
'group' : tr.group,
'showCancel' : cancel,
'trCount' : trCount,
'username' : user.nickname(),
'transactionDescription': descriptionOfTransaction(tr, user, lang),
'transactionIsBenefical': transactionIsBenefical(tr, user),
'alreadyRejected': tr.isRejected,
# i18n
'YouAreRejecting': _('You are rejecting a transaction that says that', lang),
'ButThatTransaccionWasAlreadyRejected': _('But that transaccion was already rejected.', lang),
'Why': _('Please enter the reason why you are rejecting it', lang),
'RejectTransaction': _('Reject transaction', lang),
'Cancel': _('Cancel', lang)
}
addMasterKeys(template_values, lang)
path = os.path.join(os.path.dirname(__file__), 'reject.html')
self.response.out.write(template.render(path, template_values))
return
def post(self):
if not userIsLoggedIn(self):
return
user = users.get_current_user()
lang = getLanguage(self, user)
groupKey = self.request.get('group')
group = Group.get(groupKey)
invitationText = self.request.get('invitationText')
emails = self.request.get('emails')
emails = emails.split(',')
urlBuilder = UrlBuilder(self.request)
# Check that all emails are valid
for email in emails:
if not mail.is_email_valid(email.strip()):
alertMessage(self, _('%s is not a valid email address', lang) % email)
return
for email in emails:
self.sendInvitation(user, email.strip(), group, invitationText, urlBuilder, lang)
redirectPage(self, "/group?group=%s&msg=%s" % (groupKey, escape(_('Your invite has been sent!', lang))))
def GET(self):
context = Storage(
title=_("List of points"),
status=Storage(
add="add",
loc=location_indicator(), # !!! define better later
hom="home",
sea="search",
inf="info",
),
)
page_nav_data = Storage(nav_data=nav_data(
add=links.add_point,
loc=links.place,
hom=links.home,
sea=links.search,
inf=None,
), )
context.page_nav_data = page_nav_data
context.about = model.doc_helper(context, "about", i18n.getLanguage())
get_page('info', context)
def post(self):
if not userIsLoggedIn(self):
return
rejectPath = UrlBuilder(self.request).buildUrl('/reject')
user = users.get_current_user()
lang = getLanguage(self, user)
group = Group.get(self.request.get("group"))
creatorMember = Membership.gql("WHERE group = :1 AND user = :2", group, user)[0]
if not creatorMember:
return
command = self.request.get("command")
members = group.memberships
parser = OrderParser()
parser.lang = lang
transaction = parser.parse(members, command)
if transaction.error:
alertMessage(self, transaction.error)
return
payersBalanceBefore = transaction.payer.balance
for debt in transaction.debts:
debtor = debt.member
payer = transaction.payer
debtorLang = getLanguage(self, debtor.user)
if debtor.user.email().lower() == payer.user.email().lower():
continue
debtorsBalanceBefore = debtor.balance
# Adjust balance
debtor.balance -= debt.money
debtor.put()
payer.balance += debt.money
debtorsBalanceNow = debtor.balance
# Create transaction
tr = Transaction(
group = group,
creatorMember = creatorMember,
fromMember = debtor,
toMember = payer,
type = 'debt',
amount = debt.money,
reason = debt.reason,
isRejected = False
)
tr.put()
# If the one that created this transaction is the one that owes,
# don't sent a mail to him/her
if creatorMember.user == debtor.user:
continue
# Build the reject url
rejectUrl = UrlBuilder(self.request).buildUrl('/reject')
rejectUrl += "?key=%s&h=%s" % (str(tr.key()), tr.hash)
# Try send email to the debtor
if creatorMember.user == transaction.payer.user:
message = createActionMail(payer, debtor, debt.money, debt.reason, debtorsBalanceBefore, debtorsBalanceNow, rejectUrl, youOwedSomeone(debtorLang), debtorLang)
else:
message = createThirdPartyActionMail(creatorMember, payer, debtor, debt.money, debt.reason, debtorsBalanceBefore, debtorsBalanceNow, rejectUrl, creatorSaysYouOwedSomeone(debtorLang), debtorLang)
sendEmail(message)
transaction.payer.put()
payersBalanceNow = transaction.payer.balance
# Now try send email to the payer with a summary
if not creatorMember.user == transaction.payer.user:
payerLang = getLanguage(self, transaction.payer.user)
message = createBulkMail(transaction, creatorMember, payersBalanceBefore, payersBalanceNow, payerLang)
sendEmail(message)
location = '/group?group=%s&msg=%s' % (group.key(), _('Debts saved!', lang))
redirectPage(self,location)
def get(self):
user = users.get_current_user()
lang = getLanguage(self, user)
groupKey = self.request.get("group")
try:
group = Group.get(groupKey)
email = self.request.get("user")
invitation = GroupInvitation(group, email, UrlBuilder(self.request))
# Verificar que la invitacion es valida (coinciden los hashes)
isValidInvitation = invitation.makeHash() == self.request.get("hash")
# Verificar que el usuario logueado coincide con el mail de la invitacion
isValidUser = user.email().lower() == email.lower()
except:
group = None
isValidInvitation = False
isValidUser = False
if not isValidInvitation or not isValidUser:
template_values = {
'isValidInvitation': isValidInvitation,
'isValidUser': isValidUser,
'group': group,
'username': user.nickname(),
'signout_url': users.create_logout_url("/"),
# i18n
'ThisInvitationIsNotForYou': _('This invitation is not for you.', lang),
'TheInvitationIsInvalid': _('The invitation is invalid.', lang)
}
addMasterKeys(template_values, lang)
path = os.path.join(os.path.dirname(__file__), 'acceptInvitationError.html')
self.response.out.write(template.render(path, template_values))
return
# Verificar que el usuario no sea miembro del grupo
isMember = Membership.gql("WHERE user = :1 AND group = :2", user, group).count() > 0
# If he's already a member, don't bother showing her that.
# Just redirect to the group page with an appropriate message.
if not isMember:
msg = _('You are now a member of %s group', lang) % group.name
# Join the user into the group. If later she finds out she has two
# groups with the same name, she'll already know she can change the name
# because she already belonged to another group... so she must know the site
Membership(
user = user,
group = group,
balance = 0.0,
alias = group.name
).put()
else:
msg = _('You are already a member of this group', lang)
self.redirect('/group?group=%s&msg=%s' % (group.key(), msg))
def post(self):
if not userIsLoggedIn(self):
return
user = users.get_current_user();
lang = getLanguage(self, user)
group = Group.get(self.request.get("group"))
creatorMember = Membership.gql("WHERE group = :1 AND user = :2", group, user)[0]
if not creatorMember:
return
command = self.request.get("cow")
members = group.memberships
parser = CowParser()
parser.lang = lang
transaction = parser.parse(members, command)
if transaction.error:
alertMessage(self, transaction.error)
return
result = transaction.getResult()
msg = ''
msg += _('Total', lang)
msg += ': $%s\\n'% result.total;
msg += _('Each', lang)
msg += ': $%s\\n\\n'% round(result.each, 2);
for debt in result.debts:
i = 0
msg += ' - '
for singleDebt in debt.singleDebts:
tuple = { 'from': debt.fromMember.userNick, 'to': singleDebt.toMember.userNick, 'amount': round(singleDebt.money, 2) }
if i == 0:
if debt.fromMember.user == creatorMember.user:
msg += _('You owe %(to)s $%(amount)s', lang) % tuple
elif singleDebt.toMember.user == creatorMember.user:
msg += _('%(from)s owes you $%(amount)s', lang) % tuple
else:
msg += _('%(from)s owes %(to)s $%(amount)s', lang) % tuple
elif i < len(debt.singleDebts) - 1:
msg += ', '
if singleDebt.toMember.user == creatorMember.user:
msg += _('you $%(amount)s', lang) % tuple
else:
msg += _('%(to)s $%(amount)s', lang) % tuple
else:
msg += ' '
msg += _('and', lang)
msg += ' '
if singleDebt.toMember.user == creatorMember.user:
msg += _('you $%(amount)s', lang) % tuple
else:
msg += _('%(to)s $%(amount)s', lang) % tuple
i = i + 1
msg += '\\n'
alertMessage(self, msg)
def post(self):
if not userIsLoggedIn(self):
return
key = self.request.get('key')
hash = self.request.get('h')
reason = self.request.get('reason').strip()
user = users.get_current_user()
lang = getLanguage(self, user)
# Check that all is ok
tr = isValidTransaction(key, hash, user)
if not tr:
self.redirect('/')
return
# Check that the transaction is not rejected
if tr.isRejected:
self.redirect('/')
return
# Reject it and everything else...
tr.isRejected = True
compensateTr = tr.getCompensateFor(user)
# See who is me, and who is someone
if compensateTr.creatorMember == compensateTr.fromMember:
me = compensateTr.fromMember
someone = compensateTr.toMember
else:
me = compensateTr.toMember
someone = compensateTr.fromMember
someoneLang = getLanguage(self, someone.user)
balanceBefore = someone.balance
# ========================================================= #
# See what's the type of the transaction and adjust balance
# ========================================================= #
if tr.type == 'debt':
# If it's a debt, fromMember always wins
tr.fromMember.balance += tr.amount
tr.toMember.balance -= tr.amount
if compensateTr.creatorMember.user == tr.fromMember.user:
# I owe someone
mailBody = someoneOwedYou(someoneLang, reject = True)
else:
# Someone owes me
mailBody = youOwedSomeone(someoneLang, reject = True)
elif tr.type == 'payment':
# If it's a payment, fromMember always looses
tr.fromMember.balance -= tr.amount
tr.toMember.balance += tr.amount
if compensateTr.creatorMember.user == tr.fromMember.user:
# I paid someone
mailBody = someonePayedYou(someoneLang, reject = True)
else:
# Someone paid me
mailBody = youPayedSomeone(someoneLang, reject = True)
else:
# Can't happen, only with hackery
return
tr.fromMember.put()
tr.toMember.put()
tr.put()
compensateTr.put()
balanceNow = someone.balance
# ========================== #
# Try send notification mail #
# ========================== #
# Try send mail
message = createRejectionMail(me, someone, tr, reason, balanceBefore, balanceNow, mailBody, someoneLang)
sendEmail(message)
location = '/group?group=%s&msg=%s' % (tr.group.key(), _('You rejected the transaction', lang))
redirectPage(self,location)
if title:
title = [title]
else:
title = []
addendum = conf.get("vi.name")
if addendum:
title.append(addendum)
document.title = conf["vi.title.delimiter"].join(title)
def setPath(self, path=""):
#history = eval("history")
#history.pushState(path, )
window = eval("window")
window.top.location.hash = path
if __name__ == '__main__':
pyjd.setup("public/main.html")
# Configure vi as network render prefix
network.NetworkService.prefix = "/vi"
conf["currentlanguage"] = i18n.getLanguage()
# Application
app = Application()
html5.Body().appendChild(app)
pyjd.run()
