def test_return_the_difference_between_the_two_same_nationality_money(self):
        money_yen1 = Money.yen(20)
        money_yen2 = Money.yen(5)

        expected = Money.yen(15)
        money_diff = money_yen1 - money_yen2
        self.assertTrue(expected == money_diff)
    def test_return_the_sum_of_two_same_nationality_money(self):
        money_yen1 = Money.yen(10)
        money_yen2 = Money.yen(5)

        expected = Money.yen(15)
        money_sum = money_yen1 + money_yen2
        self.assertTrue(expected == money_sum)
    def test_less_equal_with_two_different_nationality_money(self):
        greatest = Money.dollar(20.1)
        median = Money.yen(10)
        median.set_exchanger(DummyExchanger())
        least = Money.dollar(19.9)

        self.check_less_operator_of_rich_comparison(median.__le__, greatest, median, least, True)
Example #4
0
	def testMixedAddition(self):
		fiveBucks = Money.dollar(5)
		tenFrancs = Money.franc(10)
		bank = Bank()
		bank.addRate('CHF', 'USD', 2)
		result = bank.reduce(fiveBucks.plus(tenFrancs), 'USD')
		self.assertEquals(Money.dollar(10), result)
Example #5
0
    def load_from_db(self, id):
        rows = self.select_by_id('player', id)
        for row in rows:
            self.id = row[0]
            self.name = row[1]
            self.password = row[2]
            self.email = row[3]

            with self.connection:
                cursor = self.connection.cursor()
                cursor.execute(
                    "select achievement_id from achievement_player where player_id={}".format(id))

                for achievement_player_row in cursor.fetchall():
                    achievement_id = achievement_player_row[0]
                    achievement = Achievement(self.connection)
                    self.achievements.append(achievement.load_from_db(achievement_id))

                cursor.execute(
                    "select counter_id from counter_player where player_id={}".format(id))

                for counter_player_row in cursor.fetchall():
                    counter_id = counter_player_row[0]
                    counter = Counter(self.connection)
                    self.counters.append(counter.load_from_db(counter_id))

                cursor.execute("select id from money where player_id={}".format(id))
                for money_row in cursor.fetchall():
                    money_id = money_row[0]
                    money = Money(self.connection)
                    money.load_from_db(money_id)
                    self.wallet[money.type] = money
Example #6
0
	def testSumTimes(self):
		fiveBucks = Money.dollar(5)
		tenFrancs = Money.franc(10)
		bank = Bank()
		bank.addRate('CHF', 'USD', 2)
		sum = Sum(fiveBucks, tenFrancs).times(2)
		result = bank.reduce(sum, 'USD')
		self.assertEquals(Money.dollar(20), result)
    def test_return_the_difference_between_the_different_nationality_money(self):
        money_yen = Money.yen(10)
        money_yen.set_exchanger(DummyExchanger())
        money_dollar = Money.dollar(2)

        expected = Money.yen(9)
        money_diff = money_yen - money_dollar
        self.assertTrue(expected == money_diff)
    def test_return_the_sum_of_two_different_nationality_money(self):
        money_yen = Money.yen(10)
        money_yen.set_exchanger(DummyExchanger())
        money_dollar = Money.dollar(5)

        expected = Money.yen(12.5)
        money_sum = money_yen + money_dollar
        self.assertTrue(expected == money_sum)
    def test_return_the_money_that_aligned_the_unit_to_currency_of_each_nationality(self):
        money_yen = Money.yen(10.2)
        expected = (10, 0)
        self.assertTrue(expected == money_yen.currency())

        money_dollar = Money.dollar(10.2)
        expected = (10, 20)
        self.assertTrue(expected == money_dollar.currency())
    def test_money_exchange_yen_to_dollar(self):
        money = Money.yen(10)
        money.set_exchanger(DummyExchanger())

        expected = Money.dollar(20)
        result_money = money.exchange("dollar")

        self.assertTrue(expected == result_money)
Example #11
0
 def testMoney(self):
     """"""
     USD100 = Money(100, "USD")
     EUR100 = Money(100, "EUR")
     self.assertEquals(Decimal(139),EUR100.convert_to_default())
     self.assertEquals(Decimal(100),EUR100.convert_to_default() - 39)
     Currency.objects.set_currency('1.5', 'EUR')
     exc2 = Currency.objects.get_currency("EUR")
     self.assertEquals(Decimal('1.5'), exc2.exchange_rate)
     EUR1000 = Money(1000, "EUR")
     self.assertEquals(Decimal(1500),EUR1000.convert_to_default())
     self.assertNotEquals(Decimal(150),EUR100.convert_to_default())
Example #12
0
    def __init__(self, amount=Decimal("0.0"), currency=None):
        if isinstance(amount, OriginalMoney):
            try:
                amount = amount.amount
            except AttributeError: # just in case python-money is not installed (Decimal assumes as OriginalMoney)
                pass
        currency = currency or settings.DEFAULT_CURRENCY

        if OriginalMoney == Decimal:
            OriginalMoney.__init__(self, amount)
            self.amount = amount
            self.currency = currency
        else:
            OriginalMoney.__init__(self, str(amount).replace(get_format('THOUSAND_SEPARATOR'),''), currency)
Example #13
0
    def convert(self, value, currency):

        currency = str(currency).upper()
        if currency != "USD":
            if currency not in self.currencies:
                print("Currency: " + str(currency))
            assert currency in self.currencies, "ERROR: currency is not in listed currencies."

            value = float(value) / 100.0
            val_money = Money(value, currency)

            return float(val_money.to("USD"))

        # Does this only for USD
        return float(value) / 100.0
Example #14
0
    def test_price_attribute(self):
        e = SimpleMoneyModel()
        e.price = Money(3, "BGN")
        self.assertEqual(e.price, Money(3, "BGN"))

        e.price = Money.from_string("BGN 5.0")
        self.assertEqual(e.price, Money(5, "BGN"))
Example #15
0
 def test_both_fixed_currency_and_default_valid(self):
     testfield = MoneyField(
         name='testfield',
         decimal_places=2,
         max_digits=8,
         currency='USD',
         default=Money('1234.00', 'USD'),
     )
Example #16
0
 def __get__(self, instance, owner):
     if instance:
         if instance._values.get(self.name, self.default) is None:
             return None
         return Money(instance._values.get(self.name, self.default),
                      getattr(instance, self.currency_field))
     else:
         return self
Example #17
0
 def test_too_much_withdraw(self):
     """ test that raise the ValueError after withdraw higher than available. """
     bank_account = set_up()
     bank_account.deposit(Money(9000))
     ck = Check(10000)
     bank_account.deposit(ck)
     with self.assertRaises(ValueError):
         bank_account.withdraw(10000)
Example #18
0
class ParametrizedDefaultAsMoneyModel(models.Model):
    """ The simplest possible declaration with a Money object """
    value = fields.MoneyField(max_digits=12,
                              decimal_places=3,
                              default=Money(100, 'JPY'))

    def expected_value(self):
        return Money('100', 'JPY')
Example #19
0
def _combine_payments(*payment_groups):
    combined_payments = {}
    for payments in payment_groups:
        for a, p in payments.items():
            if a not in combined_payments:
                combined_payments[a] = Money(0)
            combined_payments[a] += p
    return combined_payments
Example #20
0
 def weekly_money_recovered_in_dollars(self):
     weekly_money_recovered_in_dollars = float(
         self.get_percent_time_spent() -
         self.IDEAL_PERCENT_TIME_IN_MEETINGS)
     weekly_money_recovered_in_dollars /= 100
     weekly_money_recovered_in_dollars *= self.COST_PER_SECOND
     weekly_money_recovered_in_dollars *= self.PERSON_SECONDS_PER_WEEK
     return Money(weekly_money_recovered_in_dollars, self.CURRENCY)
    def test_greater_equal_with_money_and_real_number(self):
        greatest = 10.1
        median = Money.yen(10)
        least = 9.9

        self.check_greater_operator_of_rich_comparison(median.__ge__, greatest,
                                                       median.value, least,
                                                       True)
Example #22
0
 def __get__(self, obj, model):
     """Return a Money object if called in a model instance"""
     if obj is None:
         return self.field
     amount, currency = self._get_values(obj)
     if amount is None or currency is None:
         return None
     return Money(amount, currency)
Example #23
0
    def test_converts_amount_field_into_money_object(self, mocks):
        mocks.reader.return_value = [[
            'accountName', 'goalName', 'total', 'startDate'
        ], ['biz', 'baz', '5000,50', '06.06.2017']]
        gc = GoalConnector()
        gc_entry = list(gc.all())[0]

        assert gc_entry['total'] == Money('5000.50', 'RUR')
Example #24
0
def getamount():
    id = request.form['itemid']
    amt = db.session.query(Items).get(id)
    if amt != None:
        formatted = Money(amount=amt.item_amt, currency='NGN')
        return str(formatted)
    else:
        return "You have to make a choice"
Example #25
0
    def calculate_prices(self, country):
        """
        Calculate shipping price, shipping discount and set a flag if the product qualifies for
        free shipping

        @param country:
        @return: None
        """
        rule_price = None
        rule_price_extra = None

        for current_rule in self.shipping_profile.shipping_rules.all():
            if country in current_rule.countries.all():
                rule_price = current_rule.rule_price
                rule_price_extra = current_rule.rule_price_extra
                break

        # no country found, use rest of the world
        if not rule_price or not rule_price_extra:
            rule_price = self.shipping_profile.others_price
            rule_price_extra = self.shipping_profile.others_price_extra

        self.shipping_prices[country] = rule_price, rule_price_extra

        #
        # check for free shipping
        #

        # set default values
        self.shipping_discounts[country] = (
            Money(amount="0", currency=purchase_settings.DEFAULT_CURRENCY),
            Money(amount="0", currency=purchase_settings.DEFAULT_CURRENCY))
        self.free_shippings[country] = False

        free_shippings = FreeShipping.objects.filter(shipping_to=country)
        if rule_price and rule_price_extra:
            if rule_price.amount == 0:
                self.free_shippings[country] = True
            elif free_shippings:
                free_shipping = free_shippings[0]
                discount_amount = self.price.amount * free_shipping.percent_discount

                if rule_price < discount_amount:
                    self.shipping_discounts[
                        country] = rule_price, rule_price_extra
                    self.free_shippings[country] = True
Example #26
0
 def total_gmv(self):
     """Total Gross Merchandise Value of sales
     See also: UserProfile.total_gmv
     """
     orders = self.orders
     paid_orders = orders.filter(Q(is_joomla_order=True) | ~Q(payment=None))
     return Money(0, purchase_settings.DEFAULT_CURRENCY) + sum(
         [obj.total() for obj in paid_orders])
Example #27
0
    def test_creation_unspecified_amount(self):
        """
        Same thing as above but with the unspecified 'xxx' currency
        """

        result = Money(currency='USD')
        self.assertEqual(result.amount, 0)
        self.assertEqual(result.currency.code, 'USD')
Example #28
0
def load():
    id = request.form['itemid']
    amt = db.session.query(Items).get(id)
    if amt != None:
        formatted = Money(amount=amt.item_amt, currency="NGN")
        return str(formatted)
    else:
        return "YOU need to make a choice"
Example #29
0
 def test_data_decompressed(self):
     form = self.Form(data={
         'price_0': Decimal('1234.00'),
         'price_1': 'EUR',
     })
     self.assertTrue(form.is_valid())
     obj = form.save()
     self.assertEqual(obj.price, Money('1234.00', 'EUR'))
Example #30
0
	def setUp( self ) :
		'''Optional.  Run before for each test.'''
		self.u1 = Money( 13, 'USD' )
		self.u1copy = Money( 13, 'USD' )
		self.u2 = Money(  8, 'USD' )
		self.u2copy = Money(  8, 'USD' )
		self.p1 = Money( 13, 'PLN' )
		self.n1 = Money( -13, 'USD' )
		self.n2 = Money( -18, 'USD' )
		self.n2copy = Money( -18, 'USD' )
 def load(self, file_object):
     object_as_dict = json.load(file_object)
     self.id = object_as_dict["id"]
     self.type = object_as_dict["type"]
     self.nickname = object_as_dict["nickname"]
     self.email = object_as_dict["email"]
     self.password = object_as_dict["password"]
     gold = Money(code=object_as_dict["wallet"]["gold"]["code"],
              amount=object_as_dict["wallet"]["gold"]["amount"])
     silver= Money(code=object_as_dict["wallet"]["silver"]["code"],
              amount=object_as_dict["wallet"]["silver"]["amount"])
     copper = Money(code=object_as_dict["wallet"]["copper"]["code"],
              amount=object_as_dict["wallet"]["copper"]["amount"])
     self.wallet = Wallet(gold, silver, copper)
     self.session = object_as_dict["session"]
     self.created = object_as_dict["created"]
     self.updated = object_as_dict["updated"]
     return object_as_dict
Example #32
0
 def to_python(self, value):
     if isinstance(value, str):
         try:
             (currency, value) = value.split()
             if currency and value:
                 return Money(value, currency)
         except ValueError:
             pass
     return value
Example #33
0
 def apply(self, div: Dividend, pf: Portfolio):
     for account in pf.get_accounts():
         for position in account.get_positions():
             if position.get_tradable().get_ticker_id() == div.get_tradable(
             ).get_ticker_id():
                 qty = position.get_qty()
                 amt_paid = Money(qty * div.get_amount().amount,
                                  div.get_amount().currency)
                 account.get_cash_balance().deposit(amt_paid)
Example #34
0
    def __get__(self, obj, type=None):
        if obj is None:
            return self

        amount = obj.__dict__[self.field.name]
        if amount is None:
            return None
        else:
            return Money(amount, getattr(obj, self.currency_name))
Example #35
0
def model_from_db_view(request, amount='0', currency='XXX'):
    # db roundtrip
    instance = SimpleMoneyModel.objects.create(price=Money(amount, currency))
    instance = SimpleMoneyModel.objects.get(pk=instance.pk)

    print instance, instance.pk

    money = instance.price
    return render_to_response('view.html', {'money': money})
Example #36
0
    def test_backend_not_set(self):
        with pytest.raises(ExchangeBackendNotSet):
            _ = xrates.backend_name

        with pytest.raises(ExchangeBackendNotSet):
            xrates.base = 'USD'

        with pytest.raises(ExchangeBackendNotSet):
            Money('4', 'USD').to('JPY')
Example #37
0
    def send_donation_confirmation(self, donation):
        """Method to send a confirmation to a donor

        Args:
            donation(int): Donation amount in cents

        Returns:
            None
        """
        donation = Money(amount=(donation / 100), currency="USD")
        donation = donation.format('en_US').split(".")[0]

        email_msg = u"Thank you for your donation of {}!\r\n We've added it to the match campaign and have let the matcher know as well.".format(donation)
        email_msg += u"\r\n\r\nThanks!\r\n - Donatemates"

        subject = u"Donatemates: Donation confirmation"

        self.send_email(self.donor_address, subject, email_msg, self.lame_html(email_msg))
Example #38
0
    def test_equality(self):
        ten_bucks = Money(10, 'USD')
        a_hamilton = Money(10, 'USD')

        juu_en = Money(10, 'JPY')

        nada = Money(0, 'USD')

        # Scalars cannot be compared to Money class
        self.assertFalse(ten_bucks == 10)
        # unless it is 0
        self.assertTrue(nada == 0)

        # Money is equal to money of the same type
        self.assertTrue(ten_bucks == a_hamilton)

        # But not different currencies
        self.assertFalse(ten_bucks == juu_en)
    def load(self, file_object):
        object_as_dict = json.load(file_object)
        self.name = object_as_dict["name"]
        self.email = object_as_dict["email"]
        self.password = object_as_dict["password"]
        self.password = object_as_dict["session"]

        gold = Money(code=object_as_dict["wallet"]["gold"]["code"],
                     amount=object_as_dict["wallet"]["gold"]["amount"])

        silver = Money(code=object_as_dict["wallet"]["silver"]["code"],
                       amount=object_as_dict["wallet"]["silver"]["amount"])

        copper = Money(code=object_as_dict["wallet"]["copper"]["code"],
                       amount=object_as_dict["wallet"]["copper"]["amount"])

        self.wallet = Wallet(gold, silver, copper)
        return object_as_dict
Example #40
0
 def test_both_default_and_currency_default(self):
     with self.assertRaises(FieldError):
         testfield = MoneyField(
             name='testfield',
             decimal_places=2,
             max_digits=8,
             currency_default='EUR',
             default=Money('1234.00', 'EUR'),
         )
Example #41
0
    def calculate_receive_amount(transfer_details, sender_account, send_amount,
                                 receive_currency) -> [Money, Money]:
        percentage = transfer_details['commission']['percentage']
        fix = transfer_details['commission']['fix']

        send_amount = Money(send_amount, sender_account.currency)
        commission = InternalTransfer.calculate_commission(
            send_amount,
            percentage,
            fix,
            transfer_details['min_commission'],
            transfer_details['max_commission'],
        )
        receive_amount = (send_amount - commission).to(receive_currency)
        if receive_amount.amount < 0:
            receive_amount = Money(0, receive_currency)

        return receive_amount, commission
Example #42
0
 def __init__(
     self,
     name: str,
     amount: Union[str, int, Decimal],
     code: str = "",
     comment: str = "",
     currency: Optional[str] = None,
 ):
     """
     Initialize a Entry instance with the default currency of the project.
     Use the currency parameter to alter the currency for this entry.
     """
     self.name = name
     if currency:
         self.currency = currency
     self.amount = Money(amount, self.currency)
     self.code = code
     self.comment = comment
Example #43
0
 def parse(cls, amount):
     """Attempt to turn a string into a Money object."""
     currency = cls.DEFAULT_CURRENCY
     if not amount:
         amount = '0'
     if amount[0] == '$':
         currency = 'USD'
         amount = amount[1:]
     return Money(amount, currency)
Example #44
0
 def append_logs(self):
     # I wanted this to be able to record the transactions so the business could then model their metrics
     # Ideally, the program should export to a table format, but I was having issues with the CSV export
     # Also, it'd be a good idea to create an inventory system to know how many items we have on hand.
     with open("log_book.txt", "a+") as log_book:
         if os.stat("log_book.txt").st_size == 0:
             log_book.write("-" * 71 + "\n")
             log_book.write(
                 "| {:<20} | {:>12} | {:>12} | {:>14} |\n".format(
                     "Date", "Net Income", "Sales Tax", "Total Payment"))
             log_book.write("-" * 71 + "\n")
         log_book.write("| {:<20} | {:>12} | {:>12} | {:>14} |\n".format(
             datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S"),
             Money(sum(self.total_price), "USD").format('en_US'),
             Money((sum(self.total_price) * self.sales_tax),
                   "USD").format('en_US'),
             Money(sum(self.total_price) * (1 + self.sales_tax),
                   "USD").format('en_US')))
Example #45
0
 def to_python(self, value):
     if value is None:
         return value
     if isinstance(value, Money):
         return value
     elif isinstance(value, Decimal):
         return Money(value)
     else:
         m = self.postgres_money_re.match(value)
         if m is not None:
             return Money(amount=m.group(1), currency=m.group(2))
         else:
             return Money.from_string(value)
Example #46
0
 def load_from_db(self, email):
     cur = con.cursor()
     sql_data_email = {
         "email": email
     }
     sql_query = """SELECT id, type, name, email, password, created, updated FROM player WHERE email=%(email)s"""
     cur.execute(sql_query, sql_data_email)
     row = cur.fetchone()
     self.player_id = row[0]
     self.name = row[2]
     self.email = row[3]
     self.password = row[4]
     self.created = row[5]
     self.updated = row[6]
     if row[1] == 'Player':
         self.__class__ = Player
     elif row[1] == 'Admin':
         self.__class__ = Admin
     else:
         self.__class__ = Moder
     self.sessions = Session().load_from_db_player(self.player_id)
     self.wallet = Money().load_from_db_player(self.player_id)
     self.achievements = Achievement().load_from_db_player(self.player_id)
     self.counter = Counter().load_from_db_player(self.player_id)
Example #47
0
 def __rmod__(self, other):
     return Money(OriginalMoney.__rmod__(self, other))
Example #48
0
 def __div__(self, other):
     return Money(OriginalMoney.__div__(self, other))
Example #49
0
 def __neg__(self):
     return Money(OriginalMoney.__neg__(self))
Example #50
0
 def __pos__(self):
     return Money(OriginalMoney.__pos__(self))
Example #51
0
	def testSimpleAddition(self):
		five = Money.dollar(5)
		sum = five.plus(five)
		bank = Bank()
		reduced = bank.reduce(sum, 'USD')
		self.assertEquals(Money.dollar(10), reduced)
Example #52
0
	def testMultiplication(self):
		five = Money.dollar(5)
		self.assertEquals(Money.dollar(10), five.times(2))
		self.assertEquals(Money.dollar(15), five.times(3))
Example #53
0
	def testReduceMoneyDifferentCurrency(self):
		bank = Bank()
		bank.addRate('CHF', 'USD', 2)
		result = bank.reduce(Money.franc(2), 'USD')
		self.assertEquals(Money.dollar(1), result)
Example #54
0
	def testReduceSum(self):
		sum = Sum(Money.dollar(3), Money.dollar(4))
		bank = Bank()
		result = bank.reduce(sum, 'USD')
		self.assertEquals(Money.dollar(7), result)
Example #55
0
	def testPlusReturnsSum(self):
		five = Money.dollar(5)
		sum = five.plus(five)
		self.assertEquals(five, sum.augend)
		self.assertEquals(five, sum.addend)
Example #56
0
 def convert_to_default(self):
     return Money(OriginalMoney.convert_to_default(self))
Example #57
0
	def testEquality(self):
		self.assertTrue(Money.dollar(5) == Money.dollar(5))
		self.assertFalse(Money.dollar(5) == Money.dollar(6))
		self.assertFalse(Money.franc(5) == Money.dollar(5))
Example #58
0
	def testCurrency(self):
		self.assertEquals('USD', Money.dollar(1).currency)
		self.assertEquals('CHF', Money.franc(1).currency)
Example #59
0
	def testReduceMoney(self):
		bank = Bank()
		result = bank.reduce(Money.dollar(1), 'USD')
		self.assertEquals(Money.dollar(1), result)
Example #60
0
 def test_multiply(self):
     money = Money(2)
     money.multiply(3)
     self.assertEqual(6, money.get_amount())