def export_backup(folder=None, dst_folder=None):
print("Exporting ...")
directory = str(QFileDialog.getExistingDirectory(
QWidget(), "Select Directory"))
path_backup = u"{path}-{date}-{name}".format(path=os.path.join(
directory, 'BACKUP'), date=DATETIME, name=Organization.get(id=1).name_orga)
if not directory:
return None
try:
# TODO Savegarde version incremat de in db
shutil.copyfile(DB_FILE, os.path.join(path_backup, DB_FILE))
v = Version().get(id=1).update_v()
except IOError:
print("Error of copy database file")
except Exception as e:
print(e)
try:
if folder:
copyanything(folder, os.path.join(path_backup, dst_folder))
raise_success(u"Le backup à été fait correctement.",
u"""Conservez le dossier {} précieusement car il contient
toutes vos données. Exportez vos données régulièrement.
""".format(path_backup))
except OSError as e:
raise_error(u"Le backup n'a pas pu être fait correctement.",
u"Vérifiez le chemin de destination puis re-essayez.\n\n \
Demandez de l'aide si le problème persiste.")
def popup(self, pos):
from ui.ligne_edit import EditLigneViewWidget
from ui.deleteview import DeleteViewWidget
from data_helper import check_befor_update_data
row = self.selectionModel().selection().indexes()[0].row()
if (len(self.data) - 1) < row:
return False
menu = QMenu()
editaction = menu.addAction("Modifier cette ligne")
delaction = menu.addAction("Supprimer cette ligne")
action = menu.exec_(self.mapToGlobal(pos))
report = Report.get(id=self.data[row][-1])
if action == editaction:
try:
self.parent.open_dialog(EditLigneViewWidget, modal=True,
table_p=self, report=report)
except IndexError:
pass
if action == delaction:
list_error = check_befor_update_data(report)
if list_error == []:
if len(self.data) < 2:
self.parent.cancellation()
else:
self.parent.open_dialog(
DeleteViewWidget, modal=True, obj=report, table_p=self,)
else:
from Common.ui.util import raise_error
raise_error(u"Impossible de supprimer", """<h3>L'article {} :</h3>
Aura <b>{}</b> comme dernier restant.""".format(
report.product.name, list_error[-1]))
def popup(self, pos):
from ui.ligne_edit import EditLigneViewWidget
from ui.deleteview import DeleteViewWidget
from data_helper import check_befor_update_data
row = self.selectionModel().selection().indexes()[0].row()
if (len(self.data) - 1) < row:
return False
menu = QMenu()
editaction = menu.addAction("Modifier cette ligne")
delaction = menu.addAction("Supprimer cette ligne")
action = menu.exec_(self.mapToGlobal(pos))
report = Report.get(id=self.data[row][-1])
if action == editaction:
try:
self.parent.open_dialog(EditLigneViewWidget, modal=True,
table_p=self, report=report)
except IndexError:
pass
if action == delaction:
list_error = check_befor_update_data(report)
if list_error == []:
if len(self.data) < 2:
self.parent.cancellation()
else:
self.parent.open_dialog(
DeleteViewWidget, modal=True, obj=report, table_p=self,)
else:
from Common.ui.util import raise_error
raise_error(u"Impossible de supprimer", """<h3>L'article {} :</h3>
Aura <b>{}</b> comme dernier restant.""".format(
report.product.name, list_error[-1]))
def prod_del(self, store):
if not store.get_report_or_none():
self.parent.open_dialog(ConfirmDeletionDiag, modal=True,
obj_delete=store,
msg="{}".format(store.name),
table_p=self.parent.store_table)
else:
raise_error(u"Suppresion impossible",
u"<h2>Il y a eu au moins un rapport dans ce magasin"
u"</h2></br><i>IL faut les supprimés d'abord</i>")
def prod_del(self, product):
if not product.last_report:
self.parent.open_dialog(ConfirmDeletionDiag, modal=True,
obj_delete=product,
msg="{}".format(product.display_name()),
table_p=self.parent.table_prod)
else:
raise_error(u"Suppresion impossible",
u"<h2>Il y a eu au moins un rapport pour cet article"
u"</h2></br><i>IL faut les supprimés d'abord</i>")
def import_backup(folder=None, dst_folder=None):
path_db_file = os.path.join(os.path.dirname(
os.path.abspath('__file__')), DB_FILE)
shutil.copy(path_db_file, "{}__{}.old".format(DB_FILE, DATETIME))
name_select_f = QFileDialog.getOpenFileName(
QWidget(), "Open Data File", "", "CSV data files (*.db)")
shutil.copy(name_select_f, path_db_file)
raise_error(u"Restoration des Donnée.",
u"""Les données ont été correctement restorée
La version actualle de la base de donnée est {}
""".format(Version().get(id=1).display_name()))
def del_report(self, report):
remaining, nb = report.store.get_remaining_and_nb_parts(report.product)
remaining -= report.remaining
if remaining >= 0:
self.parent.open_dialog(ConfirmDeletionDiag, modal=True,
obj_delete=report,
msg="Magasin : {}\nProduit: {}\nQuantité: {}".format(report.store,
report.product,
report.qty_use),
table_p=self.parent.table_op)
rep = Reports.select().where(Reports.date <
report.date).order_by(Reports.date.desc()).get()
rep.save()
else:
raise_error(u"Erreur", u"Impossible de supprimer ce rapport car"
u" le restant sera : <b>%s</b> qui est < 0"
% remaining)
def save_b(self):
''' add operation '''
# entete de la facture
if not self.table_buy.isvalid:
return False
owner = Owner.get(Owner.islog == True)
date = str(self.date.text())
values_t = self.table_buy.get_table_items()
buy = Buy()
# buy.date = datetime_
buy.provd_or_clt = \
ProviderOrClient.get_or_create(
"Fournisseur", 000000, ProviderOrClient.FSEUR)
buy.owner = owner
try:
buy.save()
err = False
except:
raise
raise_error("Erreur",
u"Impossible d'enregistrer l'entête de la facture")
return False
for name, qty, cost_buying, selling_price in values_t:
rep = Report()
rep.buy = buy
rep.type_ = Report.E
rep.store = 1
rep.date = date_to_datetime(date)
rep.product = Product.get(name=name)
rep.qty = int(qty)
rep.cost_buying = int(cost_buying)
rep.selling_price = int(selling_price)
try:
rep.save()
except Exception as e:
print(e)
err = True
if err:
buy.delete_instance()
raise_error(
"Erreur", u"Ce mouvement n'a pas pu etre "
u"enregistré dans les rapports")
return False
else:
self.parent.Notify(u"L'entrée des articles avec succès", "success")
self.change_main_context(BuyShowViewWidget, buy=buy)
def save_b(self):
''' add operation '''
# entete de la facture
if not self.table_buy.isvalid:
return False
owner = Owner.get(Owner.islog == True)
date = str(self.date.text())
values_t = self.table_buy.get_table_items()
buy = Buy()
# buy.date = datetime_
buy.provd_or_clt = \
ProviderOrClient.get_or_create(
"Fournisseur", 000000, ProviderOrClient.FSEUR)
buy.owner = owner
try:
buy.save()
err = False
except:
raise
raise_error(
"Erreur", u"Impossible d'enregistrer l'entête de la facture")
return False
for name, qty, cost_buying, selling_price in values_t:
rep = Report()
rep.buy = buy
rep.type_ = Report.E
rep.store = 1
rep.date = date_to_datetime(date)
rep.product = Product.get(name=name)
rep.qty = int(qty)
rep.cost_buying = int(cost_buying)
rep.selling_price = int(selling_price)
try:
rep.save()
except Exception as e:
print(e)
err = True
if err:
buy.delete_instance()
raise_error("Erreur", u"Ce mouvement n'a pas pu etre "
u"enregistré dans les rapports")
return False
else:
self.parent.Notify(u"L'entrée des articles avec succès", "success")
self.change_main_context(BuyShowViewWidget, buy=buy)
def export_database_as_file():
destination = QFileDialog.getSaveFileName(
QWidget(), u"Sauvegarder la base de Donnée.",
u"Sauvegarde du {} {}.db".format(DATETIME, Organization.get(id=1).name_orga), "*.db")
if not destination:
return None
try:
shutil.copyfile(DB_FILE, destination)
Version().get(id=1).update_v()
raise_success(
u"Les données ont été exportées correctement.",
u"Conservez ce fichier précieusement car il contient \
toutes vos données.\n Exportez vos données régulièrement.")
except IOError:
raise_error(u"La base de données n'a pas pu être exportée.",
u"Vérifiez le chemin de destination puis re-essayez.\n\n \
Demandez de l'aide si le problème persiste.")
def save(self):
"""
Calcul du remaining en stock après une operation."""
from Common.ui.util import raise_error
# print("SAVE BEGIN")
try:
try:
last_reports = self.last_report()
# print("LAST REPORT: ", last_reports)
previous_remaining = last_reports.remaining
# print("previous_remaining: ", previous_remaining)
except Exception as e:
# print("last_reports", e)
previous_remaining = 0
if self.type_ == self.E:
self.remaining = int(previous_remaining) + int(self.qty_use)
if self.type_ == self.S:
self.remaining = int(previous_remaining) - int(self.qty_use)
if self.remaining < 0:
raise_error(u"Erreur",
u"On peut pas utilisé %d puis qu'il ne reste que %d"
% (self.qty_use, previous_remaining))
return False
except Exception as e:
# print(e)
if self.type_ == self.S:
raise_error(u"Erreur",
u"Il n'existe aucun %s dans le store %s"
% (self.product.name, self.store.name))
return False
super(Reports, self).save()
try:
next_rpts = self.report.order_by(Reports.date.asc())
next_rpt = next_rpts.get()
next_rpt.save()
except Exception as e:
# print("next_rpt", e)
pass
def save_b(self):
''' add operation '''
# entete de la facture
if not self.table_invoice.isvalid:
return False
try:
num_invoice = int(self.num_invoice.text())
self.num_invoice_error.setText(u"")
except:
self.pixmap = QPixmap(u"{img_media}{img}".format(img_media=Config.img_media,
img="warning.png"))
self.num_invoice.setStyleSheet("background-color: rgb(255, 235, 235);")
self.num_invoice_error.setToolTip(u"Le numero de facture est obligatoire.")
self.num_invoice_error.setPixmap(self.pixmap)
invoice_date = str(self.invoice_date.text())
name_client = str(self.name_client.text())
datetime_ = date_to_datetime(invoice_date)
values_t = self.table_invoice.get_table_items()
if name_client == "":
self.name_client.setStyleSheet("background-color: rgb(255, 235, 235);")
self.pixmap = QPixmap(u"{img_media}{img}".format(img_media=Config.img_media,
img="decline.png"))
self.name_client_error.setToolTip(u"Nom du client est obligatoire.")
self.name_client_error.setPixmap(self.pixmap)
return False
# if num_invoice > Config.credit:
# raise_error(("Avertisement"), u"<h2>Veuillez payer la reste de la licence</h2>")
# return False
invoice = Invoice()
try:
invoice.owner = Owner.get(islog=True)
except:
if Config.DEBUG:
invoice.owner = Owner.get(username='******')
else:
return False
invoice.number = num_invoice
invoice.date_ord = datetime_
invoice.client = name_client.capitalize()
invoice.location = "Bamako"
invoice.type_ = "Facture"
invoice.subject = ""
invoice.tax = False
invoice.otax_rate = 18
try:
invoice.save()
except:
raise_error("Erreur", u"Impossible d'enregistrer l'entête de la facture")
return False
# Save orderitems
try:
order = Invoice.get(number=num_invoice)
except:
return False
for i in values_t:
qty, name, price = i
description = Product.filter(name=name).get()
item = InvoiceItem()
item.invoices = invoice.id
item.quantity = int(i[0])
item.description = description
item.price = int(i[2])
try:
item.save()
self.name_client.clear()
self.num_invoice.clear()
except Exception as e:
print(e)
invoice.delete_instance()
raise_error("Erreur", u"Ce mouvement n'a pas pu etre "
u"enregistré dans les rapports")
return False
self.change_main_context(ShowInvoiceViewWidget,
invoice=invoice)
def pdf_view(filename, invoice):
"""
cette views est cree pour la generation du PDF
"""
if not filename:
filename = get_temp_filename('pdf')
# print(filename)
# on recupere les items de la facture
items_invoice = Report.filter(invoice=invoice)
# Static source pdf to be overlayed
PDFSOURCE = Config.INV_TEMPLATE_PDF
TMP_FILE = os.path.join(Config.ROOT_DIR, 'tmp.pdf')
DATE_FORMAT = u"%d/%m/%Y"
DEFAULT_FONT_SIZE = 11
FONT = 'Times-Roman'
# PDF en entrée
input1 = PdfFileReader(file(PDFSOURCE, "rb"))
# PDF en sortie
output = PdfFileWriter()
# Récupération du nombre de pages
n_pages = input1.getNumPages()
# Pour chaque page
for i in range(n_pages):
# Récupération de la page du doc initial (input1)
page = input1.getPage(i)
p = canvas.Canvas(TMP_FILE, pagesize=A4)
p.setFont(FONT, DEFAULT_FONT_SIZE)
p.drawString(115, 639, str(invoice.number))
p.drawString(82, 625, (invoice.client.name))
p.drawString(445, 625, str(invoice.date.strftime(DATE_FORMAT)))
# On ecrit les invoiceitem
x, y = 122, 574
x_qty = x
x_description = x + 10
x_price = x + 340
x_amount = x + 433
for i in items_invoice:
p.drawRightString(x_qty, y, str(i.qty))
p.drawString(x_description, y, str(i.product.name))
p.drawRightString(x_price, y, str(
formatted_number(i.selling_price)))
p.drawRightString(x_amount, y, str(formatted_number(
i.selling_price * i.qty)))
y -= 17
# On calcul le montant total hors taxe et sa conversion en lettre
ht = sum([(val.selling_price * val.qty) for val in items_invoice])
tax_rate = invoice.tax_rate if invoice.tax else 0
mt_tax = int((ht * tax_rate) / 100)
htt = mt_tax + ht
ht_en_lettre = num2words(ht, lang="fr")
ht_en_lettre1, ht_en_lettre2 = controle_caratere(
ht_en_lettre + " francs CFA", 50, 50)
p.drawString(260, 191, (ht_en_lettre1))
p.drawString(50, 175, (ht_en_lettre2))
p.setFont('Times-Bold', 11)
p.drawString(52, 639, "Facture N° :")
p.drawString(x_price - 20, 248, str(tax_rate) + "%")
# TVA
p.drawRightString(x_amount, 248, device_amount(mt_tax))
# Hors Taxe
p.drawRightString(x_amount, 265, str(device_amount(ht)))
# Tout Taxe
p.drawRightString(x_amount, 232, str(device_amount(htt)))
x_foot = 145
p.drawString(50, x_foot, "Acceptation" if invoice.type_ ==
"Proforma" else "Acquit")
p.drawString(490, x_foot, "Fournisseur")
p.showPage()
# Sauvegarde de la page
p.save()
# Création du watermark
watermark = PdfFileReader(file(TMP_FILE, "rb"))
# Création page_initiale+watermark
page.mergePage(watermark.getPage(0))
# Création de la nouvelle page
output.addPage(page)
# Nouveau pdf
file_dest = filename + ".pdf"
try:
outputStream = file(file_dest, u"wb")
output.write(outputStream)
outputStream.close()
return file_dest
except OSError as e:
from Common.ui.util import raise_error
raise_error(u"Impossible de lancer le PDF", """
Car un autre en cours d'utilistation. Kill le \n{}""".format(e))
return
