from splitwise.debt import Debt
from splitwise.user import User, ExpenseUser
from splitwise.receipt import Receipt
from splitwise.category import Category
[docs]class Expense(object):
""" Expense in Splitwise
Attributes:
id(long, optional): ID of the expense
group_id(long, optional): GroupID of the expense
description(str, optional): Description of the expense
repeats(bool, optional): True if expense repeats, false otherwise
repeat_interval(str, optional): Repeat interval of the expense
email_reminder(bool, optional): True if email reminder is set, false otherwise
email_reminder_in_advance(int, optional): Days of email reminder
next_repeat(str, optional): Date of next repeat
details(str, optional): Additional details of the expense
comments_count(int, optional): Comment count of the expense
payment(bool, optional): Is payment done
creation_method(str, optional): Creation method
transaction_method(str, optional): Transaction method
transaction_confirmed(bool, optional): Is Transaction confirmed or not
cost(str, optional): Amount of the expense
currency_code(str, optional): Currency code of the expense
created_by(:obj:`splitwise.user.User`, optional): User who created the expense
date(str, optional): Date of the expense
created_at(str, optional): Creation date of the expense
updated_at(str, optional): Last updation date of the expense
deleted_at(str, optional): Deletion date of the expense
receipt(:obj:`splitwise.receipt.Receipt`, optional): Receipt of the expense
category(:obj:`splitwise.category.Category`, optional): Category of the expense
updated_by(:obj:`splitwise.user.User`, optional): User who updated the expense
deleted_by(:obj:`splitwise.user.User`, optional): User who deleted the expense
friendship_id(long, optional): Friendship id of the users in expense
expense_bundle_id(long, optional): Expense bundle id of the expense
repayments(:obj:`list` of :obj:`splitwise.debt.Debt`, optional): List of repayments expressed as Debt
user(:obj:`list` of :obj:`splitwise.user.ExpenseUser`, optional): List of users with balances
transaction_id(long, optional): Transaction id of the expense
"""
def __init__(self, data=None):
"""
Args:
data(:obj:`json`, optional): JSON object representing expense
"""
if data:
self.id = data["id"]
self.group_id = data["group_id"]
self.description = data["description"]
self.repeats = data["repeats"]
self.repeat_interval = data["repeat_interval"]
self.email_reminder = data["email_reminder"]
self.email_reminder_in_advance = data["email_reminder_in_advance"]
self.next_repeat = data["next_repeat"]
self.details = data["details"]
self.comments_count = data["comments_count"]
self.payment = data["payment"]
self.creation_method = data["creation_method"]
self.transaction_method = data["transaction_method"]
self.transaction_confirmed = data["transaction_confirmed"]
self.cost = data["cost"]
self.currency_code = data["currency_code"]
self.created_by = User(data["created_by"])
self.date = data["date"]
self.created_at = data["created_at"]
self.updated_at = data["updated_at"]
self.deleted_at = data["deleted_at"]
self.receipt = Receipt(data["receipt"])
self.category = Category(data["category"])
if data["updated_by"] is not None:
self.updated_by = User(data["updated_by"])
else:
self.updated_by = None
if data["deleted_by"] is not None:
self.deleted_by = User(data["deleted_by"])
else:
self.deleted_by = None
if "friendship_id" in data:
self.friendship_id = data["friendship_id"]
else:
self.friendship_id = None
if "expense_bundle_id" in data:
self.expense_bundle_id = data["expense_bundle_id"]
else:
self.expense_bundle_id = None
self.repayments = []
for repayment in data["repayments"]:
self.repayments.append(Debt(repayment))
self.users = []
for user in data["users"]:
self.users.append(ExpenseUser(user))
if "transaction_id" in data:
self.transaction_id = data["transaction_id"]
else:
self.transaction_id = None
[docs] def getId(self):
""" Returns the ID of the expense
Returns:
long: ID of the expense
"""
return self.id
[docs] def getGroupId(self):
""" Returns the GroupID of the expense
Returns:
long: GroupID of the expense
"""
return self.group_id
[docs] def getDescription(self):
""" Returns the Description of the expense
Returns:
str: Description of the expense
"""
return self.description
[docs] def isRepeat(self):
""" Returns if expense repeats
Returns:
bool: True if expense repeats, False otherwise
"""
return self.repeats
[docs] def getRepeatInterval(self):
""" Returns the repeat interval of the expense
Returns:
str: Repeat interval of expense
"""
return self.repeat_interval
[docs] def getEmailReminder(self):
""" Returns if email reminder is set
Returns:
bool: True if email reminder is set, False otherwise
"""
return self.email_reminder
[docs] def getEmailReminderInAdvance(self):
""" Returns the email reminder in advance of the expense
Returns:
int: email reminder in advance of expense
"""
return self.email_reminder_in_advance
[docs] def getNextRepeat(self):
""" Returns the next repeat of the expense
Returns:
str: next repeat of expense
"""
return self.next_repeat
[docs] def getDetails(self):
""" Returns the details of the expense
Returns:
str: details of expense
"""
return self.details
[docs] def getPayment(self):
""" Returns if payment is done in expense
Returns:
bool: True if payment done, False otherwise
"""
return self.payment
[docs] def getCreationMethod(self):
""" Returns the creation method of the expense
Returns:
str: creation method of expense
"""
return self.creation_method
[docs] def getTransactionMethod(self):
""" Returns the transaction method of the expense
Returns:
str: transaction method of expense
"""
return self.transaction_method
[docs] def getTransactionConfirmed(self):
""" Returns if transaction is confirmed in expense
Returns:
bool: True if transaction confirmed, False otherwise
"""
return self.transaction_confirmed
[docs] def getCost(self):
""" Returns the amount of the expense
Returns:
str: amount of expense
"""
return self.cost
[docs] def getCurrencyCode(self):
""" Returns the currency code of the expense
Returns:
str: currency code of expense
"""
return self.currency_code
[docs] def getCreatedBy(self):
""" Returns the user who created the expense
Returns:
:obj:`splitwise.user.User`: User who created the expense
"""
return self.created_by
[docs] def getDate(self):
""" Returns the date of the expense
Returns:
str: date of expense
"""
return self.date
[docs] def getCreatedAt(self):
""" Returns the created at date of the expense
Returns:
str: created at date of expense
"""
return self.created_at
[docs] def getUpdatedAt(self):
""" Returns the updated at date of the expense
Returns:
str: updated at date of expense
"""
return self.updated_at
[docs] def getDeletedAt(self):
""" Returns the deleted at date of the expense
Returns:
str: deleted at date of expense
"""
return self.deleted_at
[docs] def getReceipt(self):
""" Returns the receipt of the expense
Returns:
:obj:`splitwise.receipt.Receipt`: receipt of the expense
"""
return self.receipt
[docs] def getCategory(self):
""" Returns the category of the expense
Returns:
:obj:`splitwise.category.Category`: category of the expense
"""
return self.category
[docs] def getUpdatedBy(self):
""" Returns the user who updated the expense
Returns:
:obj:`splitwise.user.User`: User who updated the expense
"""
return self.updated_by
[docs] def getDeletedBy(self):
""" Returns the user who deleted the expense
Returns:
:obj:`splitwise.user.User`: User who deleted the expense
"""
return self.deleted_by
[docs] def getUsers(self):
""" Returns the list of users in the expense along with balance
Returns:
:obj:`list` of :obj:`splitwise.user.ExpenseUser`: list of users in the expense along with balance
"""
return self.users
[docs] def getExpenseBundleId(self):
""" Returns the expense bundle id of the expense
Returns:
long: expense bundle id of expense
"""
return self.expense_bundle_id
[docs] def getFriendshipId(self):
""" Returns the friendship id of the expense
Returns:
long: friendship id of expense
"""
return self.friendship_id
[docs] def getRepayments(self):
""" Returns the list of repayments
Returns:
:obj:`list` of :obj:`splitwise.debt.Debt`: list of debts
"""
return self.repayments
[docs] def getReceiptPath(self):
""" Returns the receipt of the expense
Returns:
string: path to the receipt file
"""
return self.receiptPath
[docs] def getTransactionId(self):
""" Returns the transaction id of the expense
Returns:
long: Transaction ID of the expense
"""
return self.transaction_id
[docs] def setId(self, id):
""" Sets the id of the expense
Args:
id(long): ID of the expense
"""
self.id = id
[docs] def setGroupId(self, id):
""" Sets the group id of the expense
Args:
id(long): Group ID of the expense
"""
self.group_id = id
[docs] def setDescription(self, desc):
""" Sets the description of the expense
Args:
desc(str): description of the expense
"""
self.description = desc
[docs] def setPayment(self, payment):
""" Sets the payment of the expense
Args:
payment(bool): payment of the expense
"""
self.payment = payment
[docs] def setCost(self, cost):
""" Sets the cost of the expense
Args:
cost(str): cost of the expense
"""
self.cost = cost
[docs] def setFriendshipId(self, f_id):
""" Sets the friendship id of the expense
Args:
f_id(long): friendship id of the expense
"""
self.friendship_id = f_id
[docs] def setCreationMethod(self, creation_method):
""" Sets the creation method of the expense
Args:
creation_method(str): creation method of the expense
"""
self.creation_method = creation_method
[docs] def setDate(self, date):
""" Sets the date of the expense
Args:
date(str): date of the expense
"""
self.date = date
[docs] def setRepeatInterval(self, repeat_interval):
""" Sets to repeat the interval of expense
Args:
repeat_interval(str): repeat interval of the expense
"""
self.repeat_interval = repeat_interval
[docs] def setCurrencyCode(self, currency_code):
""" Sets the currency code of the expense
Args:
currency_code(str): currency code of the expense
"""
self.currency_code = currency_code
[docs] def setCategory(self, category):
""" Sets to category of the expense
Args:
category(:obj:`splitwise.category.Category`): category of the expense
"""
self.category = category
[docs] def setUsers(self, users):
""" Sets to users of the expense
Args:
users(:obj:`list` of :obj:`splitwise.user.ExpenseUser`): List of users
"""
self.users = users
[docs] def addUser(self, user):
""" Add a user to the expense
Args:
user(:obj:`splitwise.user.ExpenseUser`): user to add to expense
"""
if not self.users:
self.users = []
self.users.append(user)
[docs] def setSplitEqually(self, should_split=True):
""" Set if expense should be split equally. Note that group_id should be set to use this
Args:
should_split(bool, optional): Should the expense be split equally. Default value is True
"""
self.split_equally = should_split
[docs] def setReceipt(self, receipt):
""" Sets the receipt of the expense
Args:
receipt(string): path to the receipt file
"""
self.receiptPath = receipt
[docs] def setDetails(self, details):
""" Sets the details of the expense
Returns:
details(string): details of the expense
"""
self.details = details
def __getattr__(self, item):
return None
