class OutputWorkbook:
CONTRACT_SHEET = u"合同"
INVOICE_SHEET = u"箱单发票"
DETAILS_SHEET = u"出仓明细"
def __init__(self,template, **kwargs):
self.template = template
#self.dest = dest
self.wb = load_workbook(template)
self.contract = Contract(self.wb.get_sheet_by_name(self.CONTRACT_SHEET))
self.invoice = Invoice(self.wb.get_sheet_by_name(self.INVOICE_SHEET))
self.details = Details(self.wb.get_sheet_by_name(self.DETAILS_SHEET))
def get_contract_sheet(self):
return self.contract
def get_invoice_sheet(self):
return self.invoice
def get_detail_sheet(self):
return self.details
def save(self,dest=None):
if dest is None:
dest = self.template
self.contract.fix_borders()
self.details.fix_borders()
#save here
self.contract.remove_empty_rows()
self.invoice.remove_empty_rows()
self.details.remove_empty_rows()
self.wb.save(dest)
def test_initialize_default_folders_and_files_where_home_path_exist_but_not_folder_dot_invoice(
self):
# initialize
dir = tempfile.mkdtemp()
invoice = Invoice()
# test
result = invoice.initialize_default_folders_and_files(dir)
# verify
self.assertEqual(len(result), 6)
try:
self.assertTrue(result.index("HOME_PATH_DOES_NOT_EXIST") >= 0)
self.fail("ValueError expected.")
except ValueError:
pass
self.assertTrue(result.index("HOME_PATH_DOES_EXIST") >= 0)
dot_invoice_folder_path = join(dir, ".invoice")
self.assertEqual(exists(dot_invoice_folder_path), True)
self.assertTrue(result.index("DOT_INVOICE_FOLDER_CREATED") >= 0)
invoice_file_path = join(dot_invoice_folder_path, "invoice.txt")
self.assertEqual(exists(invoice_file_path), True)
self.assertTrue(result.index("INVOICE_FILE_CREATED") >= 0)
company_file_path = join(dot_invoice_folder_path, "company.txt")
self.assertEqual(exists(company_file_path), True)
self.assertTrue(result.index("COMPANY_FILE_CREATED") >= 0)
automatic_invoice_file_path = join(dot_invoice_folder_path,
"automatic_invoice.txt")
self.assertEqual(exists(automatic_invoice_file_path), True)
self.assertTrue(result.index("AUTOMATIC_INVOICE_FILE_CREATED") >= 0)
periodic_invoice_file_path = join(dot_invoice_folder_path,
"periodic_invoice.txt")
self.assertEqual(exists(periodic_invoice_file_path), True)
self.assertTrue(result.index("PERIODIC_INVOICE_FILE_CREATED") >= 0)
# cleanup
shutil.rmtree(dir)
return
def testSendInvoice(self):
"""Asserting the invoiced_dt value is weird, like what am I
trying to prove? So far, it's only use is being printed in
text; of interest for future record keeping? I don't
really have a personal need for send(), so it's just this
kinda-academic thing I thought an invoice should have. And
I think that uncertainty shows in this lame test.
"""
filtered_entries = TimeEntry.query(self.entries, 'Company1')
invoice = Invoice(filtered_entries, None, (None, None), self.company1_jobs)
send_start = _dt.now()
invoice.send()
send_end = _dt.now()
self.assertLess(send_start, invoice.invoiced_dt)
self.assertGreater(send_end, invoice.invoiced_dt)
for entry in invoice.entries:
self.assertFalse(entry.can_be_invoiced())
self.assertEqual(entry.invoiced_dt, invoice.invoiced_dt)
self.assertTrue(invoice.sent)
def calculateSaldos(request):
if request.method == 'POST':
form = DatePickerForm(request.POST)
if form.is_valid():
month = request.POST['month']
year = request.POST['year']
invoice = Invoice(int(year), int(month))
invoices = invoice.calculateSaldos()
clientFormSet = modelformset_factory(Client)
return render_to_response('saldos.html', {
'invoices': invoices,
'title': 'Saldos'
},
context_instance=RequestContext(request))
else:
form = DatePickerForm()
return render_to_response('date-picker.html', {
'form': form,
'formAction': '/admin/newspaper/saldos/',
'title': 'Saldos'
},
context_instance=RequestContext(request))
def invoice_create():
raw_receiver = ''
raw_date = ''
raw_net_price = ''
raw_tax = ''
raw_vat_id = ''
try:
raw_receiver = request.form.get('receiver')
raw_date = request.form.get('date')
raw_net_price = request.form.get('net')
raw_tax = request.form.get('tax')
raw_vat_id = request.form.get('vatid')
except ValueError:
return 'parameter is missing', 500
check_parameter_string_empty(raw_receiver)
check_parameter_string_empty(raw_date)
check_parameter_string_empty(raw_net_price)
check_parameter_string_empty(raw_tax)
check_parameter_string_empty(raw_vat_id)
net_price = float(raw_net_price)
value_added_tax = float(raw_tax)
invoice_date = raw_date
receiver = raw_receiver
vat_id = raw_vat_id
invoice = Invoice(receiver, net_price, invoice_date=invoice_date, vat_id=vat_id, value_added_tax=value_added_tax)
invoice.apply_vat_regulation()
response = make_response(create_PDF(invoice))
response.headers.set('Content-Disposition', 'attachment', filename='invoice' + '.pdf')
response.headers.set('Content-Type', 'application/pdf')
return response
def test_is_invoice_released_dao_raises_value_error(self) -> None:
mock_dao = Mock(spec=InvoiceDataAccessObject)
mock_dao.lookup_status.side_effect = ValueError(
'No invoice with ID 1234')
invoice = Invoice(1234, date.today(), mock_dao)
assert not invoice.is_invoice_released()
def lambda_handler(event, context):
invoice = Invoice(event)
es_response = invoice.send_to_elastic()
print(es_response.text)
return {
'statusCode': 200,
'doc': invoice.es_doc,
'es_response': es_response.text
}
def main():
i = Invoice()
data = i.get_processed_data()
b = Bundle()
# Create separate files split by sender IBAN
for send_iban in settings.SENDER_IBAN:
content = b.generate(data, send_iban)
b.save_to_disk(send_iban, content)
def test_is_invoice_released_status_0_yesterday(self) -> None:
cutoff = date.today() + timedelta(days=-1)
mock_dao = Mock(spec=InvoiceDataAccessObject)
mock_dao.lookup_status.return_value = 0
invoice = Invoice(1234, cutoff, mock_dao)
assert not invoice.is_invoice_released()
def test_is_invoice_released(self, status: int, time_delta: int,
expected: bool) -> None:
cutoff = date.today() + timedelta(days=time_delta)
mock_dao = Mock(spec=InvoiceDataAccessObject)
mock_dao.lookup_status.return_value = status
invoice = Invoice(1234, cutoff, mock_dao)
assert invoice.is_invoice_released() == expected
def test_validate_args_where_item_and_action_are_none(self):
# initialize
expected_result = "NO_ITEM"
invoice = Invoice()
invoice.args = ArgsMock()
# test
result = invoice.validate_args()
# verify
self.assertEqual(result, expected_result)
return
def __init__(self, template, **kwargs):
self.template = template
#self.dest = dest
self.wb = load_workbook(template)
self.contract = Contract(self.wb.get_sheet_by_name(
self.CONTRACT_SHEET))
self.invoice = Invoice(self.wb.get_sheet_by_name(self.INVOICE_SHEET))
self.details = Details(self.wb.get_sheet_by_name(self.DETAILS_SHEET))
def test_initialize_default_folders_and_files_where_home_path_does_not_exist(
self):
# initialize
dir = dirname("/THIS/PATH/DOES/NOT/EXIST")
invoice = Invoice()
# test
result = invoice.initialize_default_folders_and_files(dir)
# verify
self.assertTrue(result.index("HOME_PATH_DOES_NOT_EXIST") >= 0)
return
def test_create_pdf(self):
invoice_doc = self.wb.WorkSheets("請求書テンプレート")
iv_data = invoice_util.get_excel_data(self.ws)
iv = Invoice(iv_data[0])
iv_detail = InvoiceDetail(iv_data[0])
iv.add_detail(iv_detail)
invoice_util.create_invoice_pdf(self.app, self.wb, invoice_doc, iv,
"../pdf")
f_list = glob.glob('../pdf/XXX株式会社*.pdf')
self.assertEqual(len(f_list), 1)
def test_validate_args_where_action_is_none(self):
# initialize
expected_result = "NO_ACTION"
invoice = Invoice()
invoice.args = ArgsMock()
invoice.args.item = "company"
# test
result = invoice.validate_args()
# verify
self.assertEqual(result, expected_result)
return
def testCreateInvoice(self):
filtered_entries = TimeEntry.query(self.entries, 'Company1')
invoice = Invoice(filtered_entries, None, (None, None), self.company1_jobs)
self.assertEqual(invoice.hours_total, 3)
filtered_entries = TimeEntry.query(self.entries, 'Company2')
invoice = Invoice(filtered_entries, None, (None, None), self.company2_jobs)
self.assertEqual(invoice.hours_total, 4.9)
filtered_entry_ids = [e.id for e in filtered_entries]
self.assertEqual(sorted(invoice.entry_ids), sorted(filtered_entry_ids))
def test_select_strategy_where_args_item_is_i(self):
# initialize
expected_result = ""
invoice = Invoice()
invoice.args = ArgsMock()
invoice.args.item = "i"
# test
invoice.select_strategy()
# verify
self.assertTrue(isinstance(invoice.strategy, InvoiceStrategy))
return
def test_parse_args_where_action_is_list_and_item_is_company(self):
# initialize
action = "list"
item = "company"
invoice = Invoice()
args = [self.INVOICE_PY, "--action", action, "--item", item]
# test
invoice.parse_args(args)
# verify
self.assertEqual(invoice.args.action, action)
self.assertEqual(invoice.args.item, item)
return
def test_validate_args_where_item_and_action_are_set_to_valid_values(self):
# initialize
expected_result = ""
invoice = Invoice()
invoice.args = ArgsMock()
invoice.args.item = "company"
invoice.args.action = "add"
# test
result = invoice.validate_args()
# verify
self.assertEqual(result, expected_result)
return
def testInvoicePayperiod(self):
invoice = Invoice([],
_dt(2019,2,18),
(_dt(2019,2,4), _dt(2019,2,17)), self.company1_jobs)
self.assertEqual(invoice.payperiod_start, _dt(2019,2,4))
self.assertEqual(invoice.payperiod_end, _dt(2019,2,17))
invoice = Invoice([],
None,
(_dt(2019,2,1), _dt(2019,2,28)), self.company1_jobs)
self.assertEqual(invoice.payperiod_start, _dt(2019,2,1))
self.assertEqual(invoice.payperiod_end, _dt(2019,2,28))
def test_parse_args_where_action_is_delete_and_item_is_automatic_invoice(
self):
# initialize
action = "delete"
item = "automatic-invoice"
invoice = Invoice()
args = [self.INVOICE_PY, "--action", action, "--item", item]
# test
invoice.parse_args(args)
# verify
self.assertEqual(invoice.args.action, action)
self.assertEqual(invoice.args.item, item)
return
def test_init(self):
"""Ensure that the invoice acquires the correct attributes from the __init__ method
Also ensure an error is raised if an invalid ID is used"""
invoice = Invoice(424)
self.assertEqual(invoice.pdf_file, 'pdfs/424.pdf')
self.assertEqual(invoice.date, datetime.date(1990, 2, 5))
# TODO: After implementation of __eq__ in Person
# self.assertEqual(invoice.payer, Person('test_payer'))
# self.assertEqual(invoice.payee, Person('test_payee'))
self.assertEqual(invoice.amount, 40.7)
self.assertEqual(invoice.name, '0424')
with self.assertRaises(KeyError):
Invoice(9895)
def test_is_invoice_exist(self):
iv_data = invoice_util.get_excel_data(self.ws)
invoices = []
for row in iv_data:
id = row[1]
exist_invoice = invoice_util.get_invoice_from_list(invoices, id)
if not exist_invoice:
invoice_data = Invoice(row)
invoice_data.add_detail(InvoiceDetail(row))
invoices.append(invoice_data)
else:
exist_invoice.add_detail(InvoiceDetail(row))
self.assertEqual(invoice_util.is_invoice_exist(invoices, 1), True)
self.assertEqual(invoice_util.is_invoice_exist(invoices, 5), False)
def invoices(page):
invoices_per_page = 5
invoice_count = Invoice.get_invoice_count()
page_count = invoice_count // invoices_per_page + int(
invoice_count % invoices_per_page > 0)
start = max(invoice_count - (page * invoices_per_page), 0)
end = max(invoice_count - ((page - 1) * invoices_per_page), 0)
return render_template('invoices.html',
invoices=list(
reversed(Invoice.get_all(start=start,
end=end))),
page_count=page_count,
page=page)
def test_Calculate_GivenSubtotalAndPostalCode_SetsCorrectTaxAmount():
# Arrange
invoice = Invoice()
invoice.subTotal = 5.00
invoice.postalCode = '75111'
taxRateHelper = Mock()
taxRateHelper.getTaxRate = Mock(return_value=.08)
invoiceCalculator = InvoiceCalculator(taxRateHelper)
# Act
invoiceCalculator.calculate(invoice)
# Assert
assert invoice.taxAmount == .4
def test_get_mean_rounded_up(self):
"""
It should compute the mean of the added invoices.
Here, the raw mean is 4.8375, so `get_mean` should return 4.84.
"""
invoices = [
Invoice(1, 23),
Invoice(3, 45),
Invoice(6, 78),
Invoice(7, 89)
]
invoice_stats = InvoiceStats()
invoice_stats.add_invoices(invoices)
mean = invoice_stats.get_mean()
self.assertEqual(mean, 4.84)
def __init__(self, filename, **kwargs):
self.filename = filename
self.wb = load_workbook(filename)
self.contract = Contract(self.wb.get_sheet_by_name(self.CONTRACT))
self.invoice = Invoice(self.wb.get_sheet_by_name(self.INVOICE))
self.details = Details(self.wb.get_sheet_by_name(self.DETAILS))
def getInvoice(self,
rid,
client,
invoice_state="unpaid",
invoice_date=None):
client = self.client_dao.getClient(client)
return Invoice(rid, client, invoice_state, invoice_date)
def test_get_median_rounded_down(self):
"""
It should compute the median of the added invoices.
Half a cent should round down.
Here, the raw median is 5.115, so `get_median` should return 5.11.
"""
invoices = [
Invoice(1, 23),
Invoice(3, 45),
Invoice(6, 78),
Invoice(7, 89)
]
invoice_stats = InvoiceStats()
invoice_stats.add_invoices(invoices)
median = invoice_stats.get_median()
self.assertEqual(median, 5.11)
def generate_statistics_invoices():
canvas = Invoice.statistics()
canvas.savefig('invoices.svg')
with open('invoices.svg', 'rb') as img:
return img.read(), 200, {
'Content-Type': 'image/svg+xml',
'Content-Disposition': 'attachment; filename="invoices.svg"'
}
def add_invoice(self, invoice: Invoice) -> None:
"""
Add a single invoice, a tuple of dollars and cents
Arguments:
- `invoice`: an invoice
Examples:
- Invoice(dollars=10_000, cents=0)
- Invoice(10, 20)
"""
self._raise_for_max_invoices_reached()
invoice.raise_for_invalid_amounts()
self._invoices.append(invoice)
self._current_invoices_size += 1
def __init__(self,template, **kwargs):
self.template = template
#self.dest = dest
self.wb = load_workbook(template)
self.contract = Contract(self.wb.get_sheet_by_name(self.CONTRACT_SHEET))
self.invoice = Invoice(self.wb.get_sheet_by_name(self.INVOICE_SHEET))
self.details = Details(self.wb.get_sheet_by_name(self.DETAILS_SHEET))
def calculateSaldos(request):
if request.method == 'POST':
form = DatePickerForm(request.POST)
if form.is_valid():
month = request.POST['month']
year = request.POST['year']
invoice = Invoice(int(year), int(month))
invoices = invoice.calculateSaldos()
clientFormSet= modelformset_factory(Client)
return render_to_response('saldos.html', {'invoices': invoices, 'title': 'Saldos'}, context_instance=RequestContext(request))
else:
form = DatePickerForm()
return render_to_response('date-picker.html', {'form': form, 'formAction': '/admin/newspaper/saldos/', 'title': 'Saldos'}, context_instance=RequestContext(request))
def store_a_value(self, tag, value):
try:
config = json.loads(value)
id = self.getLastKey()+1
id_driver = str(config["id_con"])
id_vehicle = str(config["id_veh"])
id_dispatcher = str(config["id_des"])
id_gasStation = str(config["id_gas"])
gas = str(config["litros"])
total = str(config["total"])
date = time.strftime("%d/%m/%Y")
code = str(id) + id_driver + id_vehicle + id_dispatcher + id_gasStation
entry = Invoice(id = id, id_driver = id_driver, id_vehicle = id_vehicle, id_dispatcher = id_dispatcher, id_gasStation = id_gasStation, code = code, date = date, gas=gas, total = total)
entry.put()
value = code
except:
value = "Error:"+value
if self.request.get('fmt') == "html":
json.dump({"result": True, "message": value}, self.response.out)
else:
self.WriteToPhoneAfterStore(self,tag,value)
def invoice(request):
if request.method == 'POST':
form = DatePickerForm(request.POST)
if form.is_valid():
month = request.POST['month']
year = request.POST['year']
client = request.POST['client']
if client:
client = Client.objects.filter(pk=client)
else:
client = None
invoice = Invoice(int(year), int(month))
invoice.calculateInvoice(client)
return render_to_response('invoice-success.html', {'listName': invoice.getListFilename(), 'invoiceName': invoice.getInvoiceFilename()}, context_instance=RequestContext(request))
else:
return HttpResponse('Invalid form data.' + str(form))
form = DatePickerForm()
return render_to_response('invoice.html', {'form': form}, context_instance=RequestContext(request))
def unlink(user_id, password, model, odoo_id):
_check_user(user_id, password)
if model not in MODELS_CLASS.keys():
raise Fault("unknown_model", "Reference model does not exist!")
mod_class = MODELS_CLASS[model]
try:
rec = mod_class.get(mod_class.odoo_id == odoo_id)
except mod_class.DoesNotExist:
pass
else:
if model == "customer":
for invoice in Invoice.select().where(Invoice.partner_id == rec.id):
invoice.delete_instance()
for rma in Rma.select().where(Rma.partner_id == rec.id):
for rma_product in RmaProduct.select().where(
RmaProduct.id_rma == rma.id):
rma_product.delete_instance()
rma.delete_instance()
elif model == 'product':
for rma_product in RmaProduct.select().where(
RmaProduct.product_id == rec.id):
rma_product.delete_instance()
elif model == 'rma':
for rma_product in RmaProduct.select().where(
RmaProduct.id_rma == rec.id):
rma_product.delete_instance()
elif model == 'rmastatus':
for rma_product in RmaProduct.select().where(
RmaProduct.status_id == rec.id):
rma_product.delete_instance()
elif model == 'rmastage':
for rma in Rma.select().where(
Rma.stage_id == rec.id):
rma.delete_instance()
elif model == 'customertagcustomerrel':
for customertagcustomerrel in CustomerTagCustomerRel.select().where(
CustomerTagCustomerRel.odoo_id == rec.odoo_id):
customertagcustomerrel.delete_instance()
elif model == 'producttagproductrel':
for producttagproductrel in ProductTagProductRel.select().where(
ProductTagProductRel.odoo_id == rec.odoo_id):
producttagproductrel.delete_instance()
elif model == 'order':
for order in Order.select().where(
Order.partner_id == rec.id):
order.delete_instance()
rec.delete_instance()
return True
def __init__(self, parent=None):
super(InvoiceForm, self).__init__(parent)
self.setupUi(self)
self.progressBar.setHidden(True)
self.invoice = Invoice(self)
self.tableView.setModel(self.invoice)
self.tableView.horizontalHeader().setResizeMode(QHeaderView.Stretch)
self.tableView.setAlternatingRowColors(True)
self.tableView.setSelectionBehavior(QAbstractItemView.SelectRows)
self.updateButton.clicked.connect(self.update_invoices)
self.tableView.selectionModel().selectionChanged.connect(self.invoice_selected)
self.webpage = QWebPage()
self.webpage.loadFinished.connect(self.save_invoice)
self.webpage.networkAccessManager().sslErrors.connect(self.allow_connection)
self.network_access_manager = QNetworkAccessManager()
self.network_access_manager.finished.connect(self.fetched_invoices)
self.network_access_manager.sslErrors.connect(self.allow_connection)
if outf:
outf.write(line.rstrip() + '\n')
# print 'skipped...'
pass
# logger.exception("failed to parse")
# raise
write_summary_line()
if outf:
outf.close()
print "{} hours uninvoiced currently...".format(format_hours(invoice_hours))
if args.invoice:
for i in invoices:
invoice = Invoice(i['id'], [], settings['client_name'], footer=settings['footer'], body=[i['description']])
for item in i['items']:
if settings['billcode']:
billcode_data = settings['billcodes'][item['billcode']]
invoice.add_item(
name=billcode_data['description'],
qty=round(item['hours'], 2),
unit_price=billcode_data['rate'],
description=billcode_data['description'])
invoice_filename_template = settings['invoice_filename_template']
invoice_filename = invoice_filename_template.format(
invoice_code=i['id'],
client_name=settings['client_name']
)
import sys from invoice import Invoice year = int(sys.argv[1]) month = int(sys.argv[2]) invoice = Invoice(year, month) invoice.calculateInvoice()
def invoice(self):
if self.invoice_id is None:
return False
return Invoice.fetch(self.invoice_id)
class InvoiceForm(QDialog, Ui_InvoiceDialog):
def __init__(self, parent=None):
super(InvoiceForm, self).__init__(parent)
self.setupUi(self)
self.progressBar.setHidden(True)
self.invoice = Invoice(self)
self.tableView.setModel(self.invoice)
self.tableView.horizontalHeader().setResizeMode(QHeaderView.Stretch)
self.tableView.setAlternatingRowColors(True)
self.tableView.setSelectionBehavior(QAbstractItemView.SelectRows)
self.updateButton.clicked.connect(self.update_invoices)
self.tableView.selectionModel().selectionChanged.connect(self.invoice_selected)
self.webpage = QWebPage()
self.webpage.loadFinished.connect(self.save_invoice)
self.webpage.networkAccessManager().sslErrors.connect(self.allow_connection)
self.network_access_manager = QNetworkAccessManager()
self.network_access_manager.finished.connect(self.fetched_invoices)
self.network_access_manager.sslErrors.connect(self.allow_connection)
def invoice_selected(self, new, old):
try:
row = self.invoice.invoices[new.indexes()[0].row()]
except IndexError:
return
if row[1].startswith('Invoice'):
self.invoice_filename = os.path.expanduser('~/.blusage/%s.png' % row[1].lower())
if os.path.exists(self.invoice_filename):
self.load_invoice()
else:
usage = self.parentWidget().usage_model
url = '%s%s' % (usage.user_endpoint[:-5], self.invoice.invoices[new.indexes()[0].row()][0])
self.webpage.mainFrame().load(QUrl(url))
self.webpage.mainFrame().setScrollBarPolicy(Qt.Vertical, Qt.ScrollBarAlwaysOff)
self.webpage.mainFrame().setScrollBarPolicy(Qt.Horizontal, Qt.ScrollBarAlwaysOff)
self.webpage.setViewportSize(QSize(800, 600))
self.enable_ui(False)
else:
self.invoiceLabel.setText("""
<center>
<table>
<tr>
<th>Payment #</th>
<td>{number}</td>
</tr>
<tr>
<th>Date</th>
<td>{date}</td>
</tr>
<tr>
<th>Credit</th>
<td>{credit}</td>
</tr>
<tr>
<th>Balance</th>
<td>{balance}</td>
</tr>
</table>
</center>
""".format(number=row[1][8:], date=row[2], credit=row[3], balance=row[5]))
def load_invoice(self):
pixmap = QPixmap(self.invoice_filename)
self.invoiceLabel.setPixmap(pixmap)
def update_invoices(self):
usage = self.parentWidget().usage_model
url = '%s?%s' % (usage.user_endpoint, self.invoice.post_data)
request = QNetworkRequest(QUrl(url))
self.network_access_manager.get(request)
self.enable_ui(False)
def enable_ui(self, value=True):
self.updateButton.setEnabled(value)
self.progressBar.setHidden(value)
self.tableView.setEnabled(value)
def save_invoice(self, ok):
self.enable_ui()
if ok:
frame = self.webpage.mainFrame()
image = QImage(frame.contentsSize(), QImage.Format_ARGB32_Premultiplied)
image.fill(Qt.transparent);
painter = QPainter(image)
painter.setRenderHint(QPainter.Antialiasing, True);
painter.setRenderHint(QPainter.TextAntialiasing, True);
painter.setRenderHint(QPainter.SmoothPixmapTransform, True);
frame.documentElement().render(painter);
painter.end();
image.save(self.invoice_filename)
self.load_invoice()
else:
title = "An error occured"
message = "Could not load invoice." \
+ "\nPlease check your internet connection."
QMessageBox.critical(self, title, message)
def fetched_invoices(self, reply):
self.enable_ui()
if reply.error() == QNetworkReply.NoError:
html = unicode(reply.readAll())
self.invoice.parse(html)
self.invoice.reset()
else:
title = "An error occured"
message = reply.errorString() \
+ ".\nPlease check your internet connection."
QMessageBox.critical(self, title, message)
reply.deleteLater()
def allow_connection(self, reply):
reply.ignoreSslErrors()
class TestInvoice(unittest.TestCase):
def setUp(self):
self.invoice = Invoice(2012, 1)
def test_getLastDayOfMonth(self):
self.assertEqual(31, self.invoice.getLastDayOfMonth(date(2012, 1, 1)))
self.assertEqual(29, self.invoice.getLastDayOfMonth(date(2012, 2, 1)))
self.assertEqual(31, self.invoice.getLastDayOfMonth(date(2012, 3, 1)))
self.assertEqual(30, self.invoice.getLastDayOfMonth(date(2012, 4, 1)))
self.assertEqual(31, self.invoice.getLastDayOfMonth(date(2012, 5, 1)))
self.assertEqual(31, self.invoice.getLastDayOfMonth(date(2012, 12, 1)))
def test_getBeginDatePreviousMonth(self):
self.assertEqual(date(2011, 12, 1), self.invoice.getBeginDatePreviousMonth(date(2012, 1, 25)))
self.assertEqual(date(2012, 1, 1), self.invoice.getBeginDatePreviousMonth(date(2012, 2, 25)))
self.assertEqual(date(2012, 11, 1), self.invoice.getBeginDatePreviousMonth(date(2012, 12, 25)))
def test_getBeginDateNextMonth(self):
self.assertEqual(date(2012, 1, 1), self.invoice.getBeginDateNextMonth(date(2011, 12, 3)))
self.assertEqual(date(2012, 2, 1), self.invoice.getBeginDateNextMonth(date(2012, 1, 3)))
self.assertEqual(date(2012, 3, 1), self.invoice.getBeginDateNextMonth(date(2012, 2, 3)))
self.assertEqual(date(2012, 4, 1), self.invoice.getBeginDateNextMonth(date(2012, 3, 3)))
self.assertEqual(date(2012, 5, 1), self.invoice.getBeginDateNextMonth(date(2012, 4, 3)))
self.assertEqual(date(2012, 6, 1), self.invoice.getBeginDateNextMonth(date(2012, 5, 3)))
self.assertEqual(date(2012, 7, 1), self.invoice.getBeginDateNextMonth(date(2012, 6, 3)))
self.assertEqual(date(2012, 8, 1), self.invoice.getBeginDateNextMonth(date(2012, 7, 3)))
self.assertEqual(date(2012, 9, 1), self.invoice.getBeginDateNextMonth(date(2012, 8, 3)))
self.assertEqual(date(2012, 10, 1), self.invoice.getBeginDateNextMonth(date(2012, 9, 3)))
self.assertEqual(date(2012, 11, 1), self.invoice.getBeginDateNextMonth(date(2012, 10, 3)))
self.assertEqual(date(2012, 12, 1), self.invoice.getBeginDateNextMonth(date(2012, 11, 3)))
def test_getEndDateQuarter(self):
self.assertEqual(date(2012, 3, 31), self.invoice.getEndDateQuarter(date(2011, 12, 31)))
self.assertEqual(date(2012, 6, 30), self.invoice.getEndDateQuarter(date(2012, 3, 31)))
self.assertEqual(date(2012, 9, 30), self.invoice.getEndDateQuarter(date(2012, 6, 30)))
self.assertEqual(date(2012, 12, 31), self.invoice.getEndDateQuarter(date(2012, 9, 3)))
def test_isDeliveryForMonth(self):
delivery = Delivery()
delivery.begindate = date(2012, 1, 10)
delivery.enddate = date(2012, 1, 20)
self.assertFalse(self.invoice.isDeliveryForMonth(delivery, date(2011, 12, 1), date(2011, 12, 31)));
self.assertTrue(self.invoice.isDeliveryForMonth(delivery, date(2012, 1, 1), date(2012, 1, 31)));
self.assertFalse(self.invoice.isDeliveryForMonth(delivery, date(2012, 2, 1), date(2012, 2, 28)));
def test_isHoliday(self):
holidays = list()
holiday = Holiday()
holiday.begindate = date(2012, 1, 20)
holiday.enddate = date(2012, 2, 4)
holidays.append(holiday)
holiday2 = Holiday()
holiday2.begindate = date(2012, 3, 2)
holiday2.enddate = date(2012, 3, 4)
holidays.append(holiday2)
self.assertFalse(self.invoice.isHoliday(holidays, date(2012, 1, 19)))
self.assertTrue(self.invoice.isHoliday(holidays, date(2012, 1, 20)))
self.assertTrue(self.invoice.isHoliday(holidays, date(2012, 1, 22)))
self.assertTrue(self.invoice.isHoliday(holidays, date(2012, 2, 3)))
self.assertTrue(self.invoice.isHoliday(holidays, date(2012, 2, 4)))
self.assertFalse(self.invoice.isHoliday(holidays, date(2012, 2, 5)))
self.assertFalse(self.invoice.isHoliday(holidays, date(2012, 3, 1)))
self.assertTrue(self.invoice.isHoliday(holidays, date(2012, 3, 2)))
self.assertTrue(self.invoice.isHoliday(holidays, date(2012, 3, 4)))
self.assertFalse(self.invoice.isHoliday(holidays, date(2012, 3, 5)))
def test_getWeekNumber(self):
self.assertEqual(1, self.invoice.getWeekNumber(date(2012, 9, 1)))
self.assertEqual(1, self.invoice.getWeekNumber(date(2012, 9, 2)))
self.assertEqual(1, self.invoice.getWeekNumber(date(2012, 9, 3)))
self.assertEqual(1, self.invoice.getWeekNumber(date(2012, 9, 9)))
self.assertEqual(2, self.invoice.getWeekNumber(date(2012, 9, 10)))
self.assertEqual(2, self.invoice.getWeekNumber(date(2012, 9, 16)))
self.assertEqual(3, self.invoice.getWeekNumber(date(2012, 9, 17)))
self.assertEqual(3, self.invoice.getWeekNumber(date(2012, 9, 23)))
self.assertEqual(4, self.invoice.getWeekNumber(date(2012, 9, 24)))
def setUp(self): self.invoice = Invoice(2012, 1)
