コード例 #1
0
ファイル: helpers.py プロジェクト: jeden/flexy-invoice
def create_dummy_currency(index, currency_manager = None):
    if currency_manager == None:
        currency_manager = CurrencyManager()
        
    return currency_manager.create_currency(
        name = 'US%i Dollar' % index,
        code = 'USD%i' % index,
        symbol = '$%i'  % index
    )
コード例 #2
0
    def create(self, client_id, invoice_no, invoice_date, sale_date, currency_id = None, language_id = None):
        '''
            Create a new invoice
        '''
        self._invoice_items = []
        
        client = ClientManager.find_by_id(client_id)
        
        if currency_id is None:
            currency = client.default_currency
        else:
            currency = CurrencyManager.find_by_id(currency_id)
        
        if language_id is None:
            language = client.default_language
        else:
            language = LanguageManager.find_by_id(language_id)
        
        self._invoice = InvoiceEntity.create(
                                       user = self._user,
                                       client = client,
                                       currency = currency,
                                       language = language,
                                       invoice_no = invoice_no,
                                       invoice_date = invoice_date,
                                       sale_date = sale_date
                                    )

        return self._invoice
コード例 #3
0
ファイル: invoice_view.py プロジェクト: jeden/flexy-invoice
    def get(self, invoice_form=None, invoice_item_forms=[InvoiceItemForm(index=1)]):
        if invoice_form == None:
            # Initialize the Invoice form

            clients = self._client_manager.listify_clients()
            currencies = CurrencyManager.listify_currencies()
            languages = LanguageManager.listify_languages()

            invoice_form = InvoiceForm(clients, currencies, languages)

        return render_template(
            self, "invoice_create.html", {"invoice_form": invoice_form, "invoice_item_forms": invoice_item_forms}
        )
コード例 #4
0
ファイル: client_view.py プロジェクト: jeden/flexy-invoice
    def __init__(self, *args, **kwargs):
        super(ClientForm, self).__init__(*args, **kwargs)

        # Initialize the currencies drop down
        currencies = CurrencyManager.list_currencies()
        currencies.insert(0, ("", ""))
        self.fields["default_currency"].choices = currencies

        # Initialize the languages drop down
        languages = LanguageManager.list_languages()
        languages.insert(0, ("", ""))
        self.fields["default_language"].choices = languages

        self.prefix = "client"
        self.auto_id = "%s"
コード例 #5
0
ファイル: invoice_view.py プロジェクト: jeden/flexy-invoice
    def post(self):
        commit = False

        clients = self._client_manager.listify_clients()
        currencies = CurrencyManager.listify_currencies()
        languages = LanguageManager.listify_languages()
        invoice_form = InvoiceForm(data=self.request.POST, clients=clients, currencies=currencies, languages=languages)

        items = invoice_form.fields["items"].to_python(self.request.POST["invoice-items"]) or 0
        max_item_index = int(self.request.POST["h-last-invoice-item-index"]) or 0

        invoice_item_forms = [
            InvoiceItemForm(index + 1, self.request.POST)
            for index in range(0, max_item_index)
            if self.request.POST.has_key("%i_invoice_item-description" % (index + 1))
        ]

        if items > max_item_index:
            commit = False
        elif items == 0:
            commit = False
        elif invoice_form.is_valid():
            # Validates the invoice items
            commit = True
            for form in invoice_item_forms:
                if not form.is_valid():
                    commit = False
                    break

        if commit:
            self._invoice_manager.create(
                client_id=invoice_form.cleaned_data["client"],
                currency_id=invoice_form.cleaned_data["currency"],
                invoice_no=invoice_form.cleaned_data["invoice_no"],
                invoice_date=invoice_form.cleaned_data["invoice_date"],
                sale_date=invoice_form.cleaned_data["sale_date"],
            )
            for invoice_item in invoice_item_forms:
                self._invoice_manager.add_invoice_item(
                    description=invoice_item.cleaned_data["description"],
                    quantity=invoice_item.cleaned_data["quantity"],
                    unit_price=invoice_item.cleaned_data["unit_price"],
                )

            self._invoice_manager.save()
        else:
            self.get(invoice_form, invoice_item_forms)
コード例 #6
0
ファイル: test_currency.py プロジェクト: jeden/flexy-invoice
 def setUp(self):
     super(Test_Currency, self).setUp()
     self.entity_manager = CurrencyManager()
コード例 #7
0
ファイル: test_currency.py プロジェクト: jeden/flexy-invoice
class Test_Currency(BaseAppengineDatastoreTester):
    """  Currency management tests """
    
    def setUp(self):
        super(Test_Currency, self).setUp()
        self.entity_manager = CurrencyManager()
    
    def test_create_currency(self):
        """ Test adding a currency """
        currency = helpers.create_dummy_currency(1)
        self.verify_entity_instance(currency, CurrencyEntity)
    
    def test_create_existing_currency(self):
        """ Verify that adding a currency with an already existing symbol generates an exception """
        currency = helpers.create_dummy_currency(1)
        try:
            currency = helpers.create_dummy_currency(1)
            self.fail('Added a duplicated currency symbol')
        except(CurrencyException):
            pass
    
    def test_add_exchange_rate_and_verify_conversion(self):
        """ Add an exchange rate from currency 1 to currency 2 and verify conversion occurs """
        currency1 = helpers.create_dummy_currency(1)
        currency2 = helpers.create_dummy_currency(2)
        self.entity_manager.add_exchange_rate(from_currency = currency1, to_currency = currency2, date = date.today(), rate = 1.2)
        
        value1 = 10.0
        value2 = self.entity_manager.convert_currency(from_currency = currency1, to_currency = currency2, date = date.today(), amount = value1)
        self.assertEqual(value2, 12.0)
    
    def test_exchange_rate_on_missing_day(self):
        """ Verify that a conversion using the rate of a day not inserted in the database generates an exception """
        currency1 = helpers.create_dummy_currency(1)
        currency2 = helpers.create_dummy_currency(2)
        value1 = 10.0
        
        try:
            self.entity_manager.convert_currency(from_currency = currency1, to_currency = currency2, date = date.today(), amount = value1)
            self.fail('Conversion occurred!!')
        except(CurrencyException):
            pass
    
    def test_exchange_rate_for_one_currency(self):
        """ Verify that an exchange rate cannot be created if the from and to currency are the same """
        currency1 = helpers.create_dummy_currency(1)
        try:
            self.entity_manager.add_exchange_rate(from_currency = currency1, to_currency = currency1, date = date.today(), rate = 1.2)
            self.fail('Added a conversion rate from and to the same currency')
        except(CurrencyException):
            pass

    def test_duplicated_exchange_rate(self):
        """ Verify that a conversion rate cannot be added twice for the same day """
        currency1 = helpers.create_dummy_currency(1)
        currency2 = helpers.create_dummy_currency(2)
        self.entity_manager.add_exchange_rate(from_currency = currency1, to_currency = currency2, date = date.today(), rate = 1.2)

        try:
            self.entity_manager.add_exchange_rate(from_currency = currency1, to_currency = currency2, date = date.today(), rate = 1.2)
            self.fail('Added an already existing conversion rate ')
        except(CurrencyException):
            pass
    
    def test_convert_as_list(self):
        """ Retrieve all currencies and convert to format usable in a dropdown as  a tuple of pairs (id, name) """
        for index in range (0, 5):
            helpers.create_dummy_currency(index)
        
        currencies = self.entity_manager.list_currencies()
        
        self.assertIsNotNone(currencies)
        self.assertEqual(len(currencies), 5)
        
        for currency in currencies:
            self.assertIsNotNone(currency)
            self.assertEqual(len(currency), 2)