def update_other_parameters():
data = json.loads(request.form['data'])
if 'logo_quote' in request.files:
pdf_logo_quote = request.files['logo_quote']
else:
pdf_logo_quote = None
if 'logo_order' in request.files:
pdf_logo_order = request.files['logo_order']
else:
pdf_logo_order = None
if 'logo_invoice' in request.files:
pdf_logo_invoice = request.files['logo_invoice']
else:
pdf_logo_invoice = None
update_config_other_parameters(data)
query.insert_log("Les paramètres divers ont été mis à jour", "settings")
__update_logo_if_necessary(pdf_logo_quote, pdf_logo_order, pdf_logo_invoice)
resp = jsonify({'success': True})
resp.status_code = 200
return resp
def update_order(id_order):
data = json.loads(request.form['data'])
data["orderDate"] = convert_date_string_to_datetime(data["orderDate"])
order = query.get_order_by_id(id_order)
if order is None:
return "Order not found", 404
if order.orderNumber != data['orderNumber']:
if query.order_exist_by_number(data['orderNumber']):
return "This order number already exists", 400
query.update_order(order, data["orderNumber"], data["orderDate"],
data["orderTotalAmount"], data["quoteNumber"],
data["clientNumber"])
query_log.insert_log(
'La commande ' + str(data['orderNumber']) + ' a été mise à jour',
'database')
resp = jsonify({"success": True})
resp.status_code = 201
return resp
def validate_quote_referenced_by_order(order_quote_reference,
order_number):
""" Changes the state of the quote in the database from waiting to validated when an order
is processed.
:param order_quote_reference: The number of the quote referenced by an order
:param order_number: The number of the order
"""
quote_referenced = query_quote.get_quote_by_number(
order_quote_reference)
if quote_referenced is not None:
query_quote.update_quote_state(quote_referenced, "validated")
query_log.insert_log(
"Le devis " + str(quote_referenced.quoteNumber) +
" référencé par la " + "commande " + str(order_number) +
" est passé à l'état Validé", 'pdf-processing')
Quote.delete_quote_pdf_file_reminder(quote_referenced.quotePdfName,
'validated')
else:
query_log.insert_log(
"Impossible de passer le devis " + str(order_quote_reference) +
" référencé par la " + "commande " + str(order_number) +
" à l'état Validé - Le document n'a pas été " +
"trouvé dans la base de données",
'pdf-processing',
error=True)
def quote_cancellation():
""" Function used in a scheduler to run everyday.
Take information from config.json for the number of days before a quote is expired.
Loop through every quotes in waiting state and check how long it has been in this state.
Change the state to cancelled of every quote exceeding the number of days before a quote is expired.
If a quote has its state changed, it also deletes the quote pdf file in the 'reminder' folder.
"""
with db.app.app_context():
number_of_quote_cancelled = 0
config = get_config_dict()
days_before_quote_cancellation = config['other_parameters']['days_before_quote_cancellation']
quotes_in_waiting_state = get_quote_by_state_only("waiting")
today_date = datetime.datetime.today()
for quote in quotes_in_waiting_state:
days_elapsed_since_quote_sent = (today_date - quote.quoteDate).days
if days_elapsed_since_quote_sent >= days_before_quote_cancellation:
query_quote.update_quote_state(quote, 'cancelled')
query_log.insert_log('Le devis ' + str(quote.quoteNumber) + ' est passé à l\'état Annulé suite à son ' +
'expiration', 'quote_cancellation_scheduler')
Quote.delete_quote_pdf_file_reminder(quote.quotePdfName, 'cancelled')
number_of_quote_cancelled += 1
# We wait 1 second to be sure that the last log of the scheduler is the summary
time.sleep(1)
query_log.insert_log("Le programme d'annulation automatique de devis expirés s'est exécuté - Nombre de devis "
+ "expirés : " + str(number_of_quote_cancelled), 'quote_cancellation_scheduler')
def insert_document():
data = json.loads(request.form['data'])
data['documentData']['creationDate'] = convert_date_string_to_datetime(
data['documentData']['creationDate'])
document = pdf.get_object_from_document_type(
data['documentData']['documentType'], data)
# If the document already exists in the database, return 400 BAD REQUEST
if document.exist_in_database():
return "This document is already in the database", 400
document_client = client.Client(data['clientData']['clientNumber'],
data['clientData']['clientName'],
data['clientData']['clientMail'])
document_client.insert_or_update_if_exists_database()
document.insert_database()
query.insert_log(
"Les données du document " + data["documentData"]["documentName"] +
" ont été insérées dans la base de données", 'pdf-processing')
response = {
"documentNumber": data["documentData"]["documentNumber"],
"type": data["documentData"]["documentType"]
}
return jsonify(response), 201
def update_quote(id_quote):
data = json.loads(request.form['data'])
data["quoteDate"] = convert_date_string_to_datetime(data["quoteDate"])
quote = query.get_quote_by_id(id_quote)
if quote is None:
return "Quote not found", 404
if quote.quoteNumber != data['quoteNumber']:
if query.quote_exist_by_number(data['quoteNumber']):
return "This quote number already exists", 400
old_quote_state = quote.quoteState
quote_pdf_name = quote.quotePdfName
query.update_quote(quote,
data['quoteNumber'],
data["quoteDate"],
data["quoteTotalAmount"],
data["quoteState"],
data["clientNumber"])
if old_quote_state == 'waiting' and (data["quoteState"] == 'validated' or data["quoteState"] == 'cancelled'):
Quote.delete_quote_pdf_file_reminder(quote_pdf_name, data['quoteState'])
query_log.insert_log('Le devis ' + str(data['quoteNumber']) + ' a été mis à jour', 'database')
resp = jsonify({"success": True})
resp.status_code = 200
return resp
def update_pdf_processing_parameters():
data = json.loads(request.form['data'])
update_config_pdf_processing_parameters(data)
query.insert_log("Les paramètres de traitement de fichiers PDF ont été mis à jour", "settings")
resp = jsonify({'success': True})
resp.status_code = 200
return resp
def update_mail_sending_parameters():
data = json.loads(request.form['data'])
update_config_mail_sending_parameters(data)
query.insert_log("Les paramètres d'envoi d'e-mail ont été mis à jour", "settings")
resp = jsonify({'success': True})
resp.status_code = 200
return resp
def update_mail_signature():
data = json.loads(request.form['data'])
signature = data['signature']
update_signature(signature)
query.insert_log("La signature des e-mails a été mis à jour", "settings")
resp = jsonify({'success': True})
resp.status_code = 200
return resp
def import_data_csv(data_to_insert, data_to_update, keep_database):
""" Import Order data into the database from a CSV file that has been
processed by the function 'process_csv' below.
Insert new data or update existing one.
If the boolean 'keep_database' is False, the data imported completely
overwrite current data in the database.
:param data_to_insert: Array of Order data to insert into the database
(cf. Section VIII - C in Documentation backend routes)
:param data_to_update: Array of Order data to update in the database
(cf. Section VIII - C in Documentation backend routes)
:param keep_database: Boolean used to delete the database or not before importing the data
"""
if not keep_database:
query_order.delete_all_orders()
order_formatted = []
for order in data_to_insert:
new_order = dict(orderNumber=order['number'],
orderDate=convert_date_string_to_datetime(
order['date']),
orderTotalAmount=order['totalAmount'],
clientNumber=order['clientNumber'],
quoteNumber=order['quoteNumber'])
order_formatted.append(new_order.copy())
query_order.bulk_insert_orders(order_formatted)
for order in data_to_update:
order_to_update = query_order.get_order_by_number(order['number'])
if order_to_update is not None:
query_order.update_order(
order_to_update, order['number'],
convert_date_string_to_datetime(order['date']),
order['totalAmount'], order['quoteNumber'],
order['clientNumber'])
if keep_database:
query_log.insert_log(
'Des données ont été ajoutées et/ou remplacées dans la base de données de commandes',
'database')
else:
query_log.insert_log(
'La base de données de commandes à été supprimée et remplacée par une autre',
'database')
def import_data_csv(data_to_insert, data_to_update, keep_database):
""" Import Invoice data into the database from a CSV file that has been
processed by the function 'process_csv' below.
Insert new data or update existing one.
If the boolean 'keep_database' is False, the data imported completely
overwrite current data in the database.
:param data_to_insert: Array of Invoice data to insert into the database
(cf. Section VIII - C in Documentation backend routes)
:param data_to_update: Array of Invoice data to update in the database
(cf. Section VIII - C in Documentation backend routes)
:param keep_database: Boolean used to delete the database or not before importing the data
"""
if not keep_database:
query_invoice.delete_all_invoices()
invoice_formatted = []
for invoice in data_to_insert:
new_invoice = dict(invoiceNumber=invoice['number'],
invoiceDate=convert_date_string_to_datetime(
invoice['date']),
clientNumber=invoice['clientNumber'],
orderNumber=invoice['orderNumber'])
invoice_formatted.append(new_invoice.copy())
query_invoice.bulk_insert_invoices(invoice_formatted)
for invoice in data_to_update:
invoice_to_update = query_invoice.get_invoice_by_number(
invoice['number'])
if invoice_to_update is not None:
query_invoice.update_invoice(
invoice_to_update, invoice['number'],
convert_date_string_to_datetime(invoice['date']),
invoice['orderNumber'], invoice['clientNumber'])
if keep_database:
query_log.insert_log(
'Des données ont été ajoutées et/ou remplacées dans la base de données de factures',
'database')
else:
query_log.insert_log(
'La base de données de factures à été supprimée et remplacée par une autre',
'database')
def save_pdf():
pdf_file = request.files['pdf']
data = json.loads(request.form['data'])
config = get_config_dict()
document = pdf.get_object_from_document_type(
data['documentData']['documentType'], data)
save_file_path_archive = config["pdf_processing_parameters"]["save_file_path_archive"] + "\\" \
+ data["documentData"]["documentName"]
save_file_path_reminder = config["pdf_processing_parameters"]["save_file_path_reminder"] + "\\" \
+ data["documentData"]["documentName"]
try:
if config["other_parameters"]["add_girbau_logo_pdf"]:
pdf_file_with_girbau_logo = pdf.merge_two_pdf(
pdf_file, document.get_overlay_logo_girbau_pdf())
with open(save_file_path_archive, 'wb') as new_pdf_archive:
new_pdf_archive.write(pdf_file_with_girbau_logo.getbuffer())
if data['documentData']['documentType'] == "quote":
pdf_file_with_girbau_logo.seek(0)
with open(save_file_path_reminder, 'wb') as new_pdf_reminder:
new_pdf_reminder.write(
pdf_file_with_girbau_logo.getbuffer())
pdf_file_with_girbau_logo.close()
else:
pdf_file.save(save_file_path_archive)
if data['documentData']['documentType'] == "quote":
pdf_file.seek(0)
pdf_file.save(save_file_path_reminder)
pdf_file.close()
query.insert_log(
"Le document " + data["documentData"]["documentName"] +
" a été sauvegardé sur le serveur", 'pdf-processing')
response = {"success": True}
return jsonify(response), 200
except FileNotFoundError:
query.insert_log(
"Une erreur est survenue lors de la sauvegarde du document " +
data["documentData"]["documentName"] + " sur le serveur",
'pdf-processing',
error=True)
return "An error has occurred while saving the file. Problem with the save path", 400
def delete_quote(id_quote):
quote = query.get_quote_by_id(id_quote)
if quote is None:
return "Quote not found", 404
quote_number = quote.quoteNumber
query.delete_quote(quote)
query_log.insert_log('Le devis ' + str(quote_number) + ' a été supprimé', 'database')
resp = jsonify({"success": True})
resp.status_code = 200
return resp
def delete_client(id_client):
client = query.get_client_by_id(id_client)
if client is None:
return "Client not found", 404
client_number = client.clientNumber
query.delete_client(client)
query_log.insert_log('Le client ' + str(client_number) + ' a été supprimé',
'database')
resp = jsonify({"success": "yes"})
resp.status_code = 200
return resp
def insert_client():
data = json.loads(request.form['data'])
if query.client_exist_by_number(data['clientNumber']):
return "This client number already exists", 400
query.insert_client(data["clientName"], data["clientMail"],
data["clientNumber"])
query_log.insert_log(
'Un nouveau client ' + str(data['clientNumber']) +
' a été inséré manuellement dans la base de données', 'database')
resp = jsonify({"success": True})
resp.status_code = 201
return resp
def delete_order(id_order):
order = query.get_order_by_id(id_order)
if order is None:
return "Order not found", 404
order_number = order.orderNumber
query.delete_order(order)
query_log.insert_log(
'La commande ' + str(order_number) + ' a été supprimée', 'database')
resp = jsonify({"success": "yes"})
resp.status_code = 200
return resp
def import_data_csv(data_to_insert, data_to_update, keep_database):
""" Import Client data into the database from a CSV file that has been
processed by the function 'process_csv' below.
Insert new data or update existing one.
If the boolean 'keep_database' is False, the data imported completely
overwrite current data in the database.
:param data_to_insert: Array of Client data to insert into the database
(cf. Section VIII - C in Documentation backend routes)
:param data_to_update: Array of Client data to update in the database
(cf. Section VIII - C in Documentation backend routes)
:param keep_database: Boolean used to delete the database or not before importing the data
"""
if not keep_database:
query_client.delete_all_clients()
client_formatted = []
for client in data_to_insert:
new_client = dict(clientNumber=client['number'],
clientName=client['name'],
mailAddress=client['mail'])
client_formatted.append(new_client.copy())
query_client.bulk_insert_clients(client_formatted)
for client in data_to_update:
client_to_update = query_client.get_client_by_number(client['number'])
if client_to_update is not None:
query_client.update_client(client_to_update, client['number'],
client['name'], client['mail'])
if keep_database:
query_log.insert_log(
'Des données ont été ajoutées et/ou remplacées dans la base de données de clients',
'database')
else:
query_log.insert_log(
'La base de données de clients à été supprimée et remplacée par une autre',
'database')
def update_template_mail(email_type):
data = json.loads(request.form['data'])
subject = data['subject']
body = data['body']
if email_type == 'quote':
Quote.update_email_subject(subject)
Quote.update_email_body(body)
query.insert_log("Le modèle d'e-mail pour les devis a été mis à jour", "settings")
elif email_type == 'order':
Order.update_email_subject(subject)
Order.update_email_body(body)
query.insert_log("Le modèle d'e-mail pour les commandes a été mis à jour", "settings")
elif email_type == 'invoice':
Invoice.update_email_subject(subject)
Invoice.update_email_body(body)
query.insert_log("Le modèle d'e-mail pour les factures a été mis à jour", "settings")
elif email_type == 'first_reminder':
Quote.update_first_reminder_email_subject(subject)
Quote.update_first_reminder_email_body(body)
query.insert_log("Le modèle d'e-mail pour la première relance de devis a été mis à jour", "settings")
elif email_type == 'second_reminder':
Quote.update_second_reminder_email_subject(subject)
Quote.update_second_reminder_email_body(body)
query.insert_log("Le modèle d'e-mail pour la deuxième relance de devis a été mis à jour", "settings")
else:
return "Email type not recognized. The email type must be 'quote', 'order', 'invoice', 'first_reminder' or " \
"'second_reminder'", 400
resp = jsonify({'success': True})
resp.status_code = 200
return resp
def send_mail():
pdf_file = request.files['pdf']
data = json.loads(request.form['data'])
config = get_config_dict()
document = pdf.get_object_from_document_type(
data['documentData']['documentType'], data)
client_mail = data['clientData']['clientMail']
email_subject = document.get_email_subject()
email_body = document.get_email_body()
try:
if config["other_parameters"]["add_girbau_logo_pdf"]:
pdf_file_with_girbau_logo = pdf.merge_two_pdf(
pdf_file, document.get_overlay_logo_girbau_pdf())
send_email_to_client(client_mail, email_subject, email_body,
pdf_file_with_girbau_logo, pdf_file.filename)
pdf_file_with_girbau_logo.close()
else:
send_email_to_client(client_mail, email_subject, email_body,
pdf_file, pdf_file.filename)
query.insert_log(
"Un e-mail a été envoyé au client " +
data['clientData']['clientName'] + " avec le document " +
data["documentData"]["documentName"], 'pdf-processing')
pdf_file.close()
response = {"success": True}
return jsonify(response), 200
except smtplib.SMTPException:
query.insert_log(
"Une erreur est survenue lors de l'envoi de l'e-mail au client " +
data["clientData"]["clientName"] + " avec le document " +
data["documentData"]["documentName"],
'pdf-processing',
error=True)
return "An error has occurred when sending the email", 400
def insert_order():
data = json.loads(request.form['data'])
data["orderDate"] = convert_date_string_to_datetime(data["orderDate"])
if query.order_exist_by_number(data['orderNumber']):
return "This order number already exists", 400
query.insert_order(data["orderNumber"], data["orderDate"],
data["orderTotalAmount"], data["clientNumber"],
data["quoteNumber"])
query_log.insert_log(
'Une nouvelle commande ' + str(data['orderNumber']) +
' a été insérée manuellement dans la base de données', 'database')
resp = jsonify({"success": True})
resp.status_code = 200
return resp
def insert_quote():
data = json.loads(request.form['data'])
data["quoteDate"] = convert_date_string_to_datetime(data["quoteDate"])
if query.quote_exist_by_number(data['quoteNumber']):
return "This quote number already exists", 400
query.insert_quote(data['quoteNumber'],
data["quoteDate"],
data["quoteTotalAmount"],
data["clientNumber"])
query_log.insert_log('Un nouveau devis ' + str(data['quoteNumber']) +
' a été inséré manuellement dans la base de données', 'database')
resp = jsonify({"success": True})
resp.status_code = 201
return resp
def backup_data():
""" Function used in a scheduler to run every month.
Take information from config.json for :
- The current backup number
- The total number of backups
- The backups saving path
Saves all data up to date from the database in the backups saving path.
When the current backup number exceed the total number of backups, it
cycles back to 0, overwriting the oldest backup saved.
Data saved:
- Clients
- Quotes
- Orders
- Invoices
"""
with db.app.app_context():
config = get_config_dict()
current_backup_number = config['current_backup_number']
number_of_backups = config['other_parameters']['number_of_backups']
backup_path = config['other_parameters']['save_file_path_backups']
current_backup_path = backup_path + "\\" + str(current_backup_number)
try:
if not os.path.exists(current_backup_path):
os.mkdir(current_backup_path)
__delete_previous_backup(current_backup_path)
__make_data_backup(current_backup_path)
update_config_backup_number((current_backup_number + 1) % number_of_backups)
query_log.insert_log('Une sauvegarde des données a été réalisée', 'database')
except IOError:
query_log.insert_log('Une erreur est survenue lors de l\'exécution de la sauvegarde des données - '
'Veuillez vérifier le chemin de sauvegarde des backups', 'database', error=True)
def update_client(id_client):
data = json.loads(request.form['data'])
client = query.get_client_by_id(id_client)
if client is None:
return "Client not found", 404
if client.clientNumber != data['clientNumber']:
if query.client_exist_by_number(data['clientNumber']):
return "This client number already exists", 400
query.update_client(client, data["clientNumber"], data["clientName"],
data["clientMail"])
query_log.insert_log(
'Le client ' + str(data['clientNumber']) + ' a été mis à jour',
'database')
resp = jsonify({"success": True})
resp.status_code = 200
return resp
def __update_logo_if_necessary(pdf_logo_quote, pdf_logo_order, pdf_logo_invoice):
if pdf_logo_quote is not None:
Quote.update_overlay_logo_girbau_pdf(pdf_logo_quote)
query.insert_log("Le logo pour les devis a été mis à jour", "settings")
if pdf_logo_order is not None:
Order.update_overlay_logo_girbau_pdf(pdf_logo_order)
query.insert_log("Le logo pour les commandes a été mis à jour", "settings")
if pdf_logo_invoice is not None:
Invoice.update_overlay_logo_girbau_pdf(pdf_logo_invoice)
query.insert_log("Le logo pour les factures a été mis à jour", "settings")
def delete_quote_pdf_file_reminder(quote_pdf_filename, quote_state):
""" Try to delete the quote_pdf_filename in the 'reminder' folder if it exists.
:param quote_pdf_filename: The PDF file to delete
:param quote_state: The state's quote used to know which log to insert
"""
if quote_pdf_filename is not None:
config = get_config_dict()
path_pdf_file = config['pdf_processing_parameters'][
'save_file_path_reminder'] + "\\" + quote_pdf_filename
try:
os.remove(path_pdf_file)
if quote_state == 'validated':
query_log.insert_log(
"Le devis " + quote_pdf_filename +
" a été supprimé du dossier de relance " +
"de devis suite à sa validation", 'unarchive')
if quote_state == 'cancelled':
query_log.insert_log(
"Le devis " + quote_pdf_filename +
" a été supprimé du dossier de relance " +
"de devis suite à son annulation", 'unarchive')
except FileNotFoundError:
if quote_state == 'validated':
query_log.insert_log(
"Impossible de supprimer le devis " +
quote_pdf_filename + " du dossier de " +
"relance de devis suite à sa validation - Le document n'a pas été trouvé "
"dans le dossier",
'unarchive',
error=True)
if quote_state == 'cancelled':
query_log.insert_log(
"Impossible de supprimer le devis " +
quote_pdf_filename + " du dossier de " +
"relance de devis suite à son annulation - Le document n'a pas été trouvé "
"dans le dossier",
'unarchive',
error=True)
def quote_reminder():
""" Function used in a scheduler to run everyday.
Take information from config.json for :
- The path for the 'reminder' folder where the quote pdf files are
- The number of days before the first reminder is sent
- The number of days before the second reminder is sent
Loop through every quotes in waiting state and check how long it has been in this state.
Send an email with the quote in PDF format in attachment to the client of the quote if
it exceeds the time before the first reminder or second reminder is sent.
Uses the pdf file in the folder 'reminder' given by the path in the config.json
"""
with db.app.app_context():
number_of_mail_sent = 0
config = get_config_dict()
path_folder_reminder = config['pdf_processing_parameters'][
'save_file_path_reminder']
days_before_first_reminder = config['other_parameters'][
'days_before_first_reminder']
days_before_second_reminder = config['other_parameters'][
'days_before_second_reminder']
first_reminder_email_subject = Quote.get_first_reminder_email_subject()
first_reminder_email_body = Quote.get_first_reminder_email_body()
second_reminder_email_subject = Quote.get_second_reminder_email_subject(
)
second_reminder_email_body = Quote.get_second_reminder_email_body()
quotes_in_waiting_state = get_quote_by_state_only("waiting")
today_date = datetime.datetime.today()
try:
smtp_server = connect_to_smtp_server()
for quote in quotes_in_waiting_state:
if __has_got_all_reminders(quote):
continue
days_elapsed_since_quote_sent = (today_date -
quote.quoteDate).days
if __can_send_first_reminder(quote,
days_elapsed_since_quote_sent,
days_before_first_reminder):
if __try_sending_reminder(smtp_server,
quote,
first_reminder_email_subject,
first_reminder_email_body,
path_folder_reminder,
quote.quotePdfName,
is_first_reminder=True):
number_of_mail_sent += 1
elif __can_send_second_reminder(quote,
days_elapsed_since_quote_sent,
days_before_second_reminder):
if __try_sending_reminder(smtp_server,
quote,
second_reminder_email_subject,
second_reminder_email_body,
path_folder_reminder,
quote.quotePdfName,
is_first_reminder=False):
number_of_mail_sent += 1
smtp_server.quit()
# We wait 1 second to be sure that the last log of the scheduler is the summary
time.sleep(1)
query_log.insert_log(
"Le programme de relance automatique de devis s'est exécuté - Nombre d'e-mails "
+ "envoyés : " + str(number_of_mail_sent), 'scheduler')
except Exception as e:
print(e)
query_log.insert_log(
"Une erreur est survenue lors du programme de relance automatique des devis "
+
"- Impossible de se connecter au serveur SMTP, veuillez vérifier les paramètres "
+ "d'envoi d'e-mail dans l'onglet \"Paramètres\"",
'scheduler',
error=True)
def __try_sending_reminder(smtp_server, quote, email_subject, email_body,
path_folder_reminder, pdf_file_name,
is_first_reminder):
client = get_client_by_number(quote.clientNumber)
if client is None:
query_log.insert_log(
"Une erreur est survenue lors de l'envoi d'un e-mail de relance du devis "
+ str(quote.quoteNumber) + " pour le client " +
str(quote.clientNumber) +
" - Ce numéro de client n'existe pas dans la base de données",
'scheduler',
error=True)
return False
else:
path_quote_pdf_file = path_folder_reminder + "\\" + quote.quotePdfName
try:
quote_pdf_file = open(path_quote_pdf_file, "rb")
try:
send_mail(smtp_server, client.mailAddress, email_subject,
email_body, quote_pdf_file, pdf_file_name)
if is_first_reminder:
update_quote_has_first_reminder(quote,
has_first_reminder=True)
query_log.insert_log(
"Un premier e-mail de relance pour le devis " +
str(quote.quoteNumber) + " a été envoyé au client " +
client.clientName, 'scheduler')
else:
update_quote_has_second_reminder(quote,
has_second_reminder=True)
query_log.insert_log(
"Un deuxième e-mail de relance pour le devis " +
str(quote.quoteNumber) + " a été envoyé au client " +
client.clientName, 'scheduler')
except smtplib.SMTPRecipientsRefused:
query_log.insert_log(
"Une erreur est survenue lors de l'envoi d'un e-mail de relance du devis "
+ str(quote.quoteNumber) + " pour le client " +
str(quote.clientNumber) +
" - L'adresse e-mail du client est invalide",
'scheduler',
error=True)
return False
quote_pdf_file.close()
return True
except IOError:
query_log.insert_log(
"Une erreur est survenue lors de l'envoi d'un e-mail de relance du devis "
+ str(quote.quoteNumber) + " pour le client " +
str(quote.clientNumber) + " - Le document " +
quote.quotePdfName + " n'a pas été trouvé dans le dossier " +
path_folder_reminder,
'scheduler',
error=True)
return False
