def Connecter(self):
# Récupération des clés Mailjet
api_key = self.dict_parametres.get("api_key", None)
api_secret = self.dict_parametres.get("api_secret", None)
if api_key == None or api_secret == None:
raise ValueError(u"Les codes MAILJET ne sont pas valides.")
# Connexion à Mailjet
try:
from mailjet_rest import Client
self.connection = Client(auth=(api_key, api_secret), version='v3.1')
except Exception as err:
raise
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('namaPembeli', location='json', required=False)
parser.add_argument('emailtujuan', location='json', required=False)
parser.add_argument('Barang', location='json', required=False)
parser.add_argument('ID', location='json', required=False)
parser.add_argument('alamat', location='json', required=False)
parser.add_argument('total', location='json', required=False)
args = parser.parse_args()
api_key = '7d927645648521586a2e8def9ed3c828'
api_secret = '325f24a29a6132ba6b1baf30c6115e00'
mailjet = Client(auth=(api_key, api_secret), version='v3.1')
data = {
'Messages': [{
"From": {
"Email": "*****@*****.**",
"Name": "Beliaja"
},
"To": [{
"Email": args['emailtujuan'],
"Name": "passenger 1"
}],
"TemplateID":
974381,
"TemplateLanguage":
True,
"Subject":
"Transaksi BeliAja",
"Variables": {
"namaPembeli": args['namaPembeli'],
"Barang": args['Barang'],
"ID": args['ID'],
"alamat": args['alamat'],
"total": args['total']
}
}]
}
result = mailjet.send.create(data=data)
print(result.status_code)
print(result.json())
return result.json(), 200
def Email(fileToSend, To):
from mailjet_rest import Client
import os
api_key = '3e70858a7a5c5fbc245a662d5d9aa238' # API KEY of Mail Jet
api_secret = 'a337abcc84d8fb062f6f1597d966ae6f' # API SECRET KEY of Mail Jet
mailjet = Client(auth=(api_key, api_secret), version='v3.1')
import base64
with open(fileToSend, 'rb') as fp:
ki = base64.b64encode(fp.read())
data = {
'Messages': [{
"From": {
"Email": "*****@*****.**",
},
"To": [{
"Email": "%s" % To,
}],
"Subject":
"USER ACCOUNTS CONFIGURATIONS IN THE ENDPOINT\n",
"TextPart":
"Dear passenger 1, welcome to Mailjet! May the delivery force be with you!",
"HTMLPart":
"""<h3> Hi
Please find the attachment which contains the USER ACCOUNTS CONFIGURATIONS IN THE ENDPOINT
Thank you.</h3>""",
"Attachments": [{
"ContentType": "text/csv",
"Filename": "verifyaccounts.csv",
"Base64Content": "%s" % ki
}]
}]
}
result = mailjet.send.create(data=data)
ret = result.status_code
if ret == 200:
out = result.json()
out = str(out)
if "success" in out:
print "Email has been Sent Successfully to the following mail address:" + ' "' + emailto + '"'
else:
print "Error sending email"
def email(author, title, info):
print author, title, info
api_key = '3cd843aacb6625f1ff62522783ce7976'
api_secret = '9f1446e1e5abe54507504e7293c2c55f'
mailjet = Client(auth=(api_key, api_secret))
data = {
'FromEmail': '*****@*****.**',
'FromName': "josh: {}".format(author),
'Subject': "{}".format(title),
'Text-part': "info: {}".format(info),
'Html-part': '<h3>posted by: {} info: {}</h3>'.format(author, info),
'Recipients': [
{
"Email": "*****@*****.**"
}
]
}
result = mailjet.send.create(data=data)
def sendEmail(title, description):
mailjet = Client(auth=(api_key, api_secret), version='v3.1')
data = {
'Messages': [{
"From": {
"Email": email_sender,
"Name": "Notification"
},
"To": [{
"Email": email_recipient
}],
"Subject": title,
"TextPart": "Visit " + intra_url + "\n\n" + description,
}]
}
result = mailjet.send.create(data=data)
if (result.status_code == 200):
print("Success Sending Email")
else:
print("Failed to send email")
def emailer(self, body, email, name):
api_key = "#####################################"
api_secret = "#####################################"
mailjet = Client(auth=(api_key, api_secret), version="v3.1")
data = {
"Messages": [{
"From": {
"Email": "*****@*****.**",
"Name": "Ningthem"
},
"To": [{
"Email": email,
"Name": name
}],
"Subject": "Important: Current prices",
"HTMLPart": body,
"CustomID": "AppGettingStartedTest",
}]
}
result = mailjet.send.create(data=data)
def callback_customer(data):
t = time.process_time()
data = (json.loads(data))
api_key = os.environ.get('MAILJET_APIKEY')
api_secret = os.environ.get('MAILJET_APISECRET')
mailjet = Client(auth=(api_key, api_secret), version='v3.1')
mjdata = {
'Messages': [
{
"From": {
"Email": "*****@*****.**",
"Name": "UN DES SERVEURS D'UN DES CLUSTERS DE BWI"
},
"To": [
{
"Email": ALERT_EMAIL
}
],
"TemplateID": 1107138,
"TemplateLanguage": True,
"Subject": "Une nouvelle abeille s'est inscrite",
"Variables": {
"email": data['email'],
"firstname": data['first_name']
}
}
]
}
result = mailjet.send.create(data=mjdata)
bwi.logs.info("Sending alert signup email to " + ALERT_EMAIL)
if 200 <= result.status_code <= 299:
bwi.logs.info("Alert signup email has been sent to " + ALERT_EMAIL)
bwi.metrics.store("sent_email", 1)
bwi.metrics.counter("alert_signup", 1)
else:
bwi.logs.error("Alert signup email has not been sent to " + ALERT_EMAIL)
bwi.metrics.store("error_email", 1)
bwi.metrics.counter("fail_alert_signup", 1)
elapsed_time = time.process_time() - t
bwi.metrics.store("alert_signup_time", elapsed_time)
return json.dumps(data)
def post(self, request, format=None):
'''
Send email
'''
# Filter talents according to search condition
body = request.data
setting = MailSetting.objects.all().first()
if setting is None:
raise Response(data={
'error':
'API gateway don\'t have any mail settings, yet. Please contact administrator.'
},
status=503)
api_key = setting.api_key
secret_key = setting.secret_key
mailjet = Client(auth=(api_key, secret_key), version='v3.1')
body = request.data
to_name = body['to_name']
to_email = body['to_email']
data = {
'Messages': [{
'From': {
'Email': setting.from_email,
'Name': setting.from_name
},
'To': [{
'Email': to_email,
'Name': to_name
}],
'Subject': setting.subject,
'TextPart': setting.text_content,
'HTMLPart': setting.html_content
}]
}
result = mailjet.send.create(data=data)
response_data = {
'status': result.status_code,
'message': result.json()
}
return Response(data=response_data, status=result.status_code)
def callback_customer(data):
t = time.process_time()
data = (json.loads(data))
api_key = os.environ.get('MAILJET_APIKEY')
api_secret = os.environ.get('MAILJET_APISECRET')
mailjet = Client(auth=(api_key, api_secret), version='v3.1')
mjdata = {
'Messages': [{
"From": {
"Email": "*****@*****.**",
"Name": "Antoine de BWI"
},
"To": [{
"Email": data['email'],
"firstname": data['first_name']
}],
"TemplateID":
1106753,
"TemplateLanguage":
True,
"Subject":
"Bienvenue dans la Hive",
"Variables": {
"firstname": data['first_name']
}
}]
}
result = mailjet.send.create(data=mjdata)
bwi.logs.info("Sending signup email to " + data['email'])
if 200 <= result.status_code <= 299:
data['register_status'] = "SUCCESS"
bwi.logs.info("Signup email has been sent to " + data['email'])
bwi.metrics.counter("sent_signup_email", 1)
else:
data['register_status'] = "ERROR_SIGNUP"
bwi.logs.error("Signup email has not been sent to " + data['email'])
bwi.metrics.store("error_signup_email", 1)
elapsed_time = time.process_time() - t
bwi.metrics.store("signup_time", elapsed_time)
return json.dumps(data)
def create_suggestion_service(
suggestion_mailjet_rest_api_key: str,
suggestion_mailjet_rest_api_secret: str,
suggestion_sender_name: str,
suggestion_sender_email: str,
suggestion_recipient_name: str,
suggestion_recipient_email: str,
suggestion_mailjet_custom_id: str,
) -> SuggestionServiceInterface:
return MailjetSuggestionService(
mailjet_client=Client(
auth=(suggestion_mailjet_rest_api_key,
suggestion_mailjet_rest_api_secret),
version="v3.1",
),
suggestion_sender_name=suggestion_sender_name,
suggestion_sender_email=suggestion_sender_email,
suggestion_recipient_name=suggestion_recipient_name,
suggestion_recipient_email=suggestion_recipient_email,
suggestion_mailjet_custom_id=suggestion_mailjet_custom_id,
)
def mail_to_friend(form, user_id):
flat_id = req.select('flat_id', 'users', user_id=user_id)[0][0]
flat_name = req.select('name', 'flats', flat_id=flat_id)[0][0]
pwd = req.select('password', 'flats', flat_id=flat_id)[0][0]
response = 0
if 'friend_name' in form.keys() and 'friend_mail' in form.keys(
) and 'flat_password' in form.keys():
if crypted_string(form['flat_password']) != pwd:
response = 1
else:
mailjet = Client(auth=(api_key, api_secret), version='v3.1')
data = {
'Messages': [{
"From": {
"Email": "*****@*****.**",
"Name": "Api'Flat"
},
"To": [{
"Email": form['friend_mail'],
"Name": form['friend_name']
}],
"Subject":
"Invitation sur Api'flat",
"TextPart":
"Invitation",
"HTMLPart":
"<h3>Bonjour <em> " + form['friend_name'] +
"<em>,</h3><br><p>Vous êtes invité à rejoindre le gestionnaire de colocation Api'flat. <br>Veuillez trouver ci-dessous les identifiants à renseigner lors de votre inscription. <br> Nom de la colocation : <em> "
+ flat_name +
"<em> <br>Mot de passe de la colocation : <em> " +
form['flat_password'] + "<em></p>",
"CustomID":
"AppGettingStartedTest"
}]
}
mailjet.send.create(data=data)
response = 2
else:
response = 0
return response
def sendSMTPRelay(name: str) -> str:
"""To send mail using SMTP Relay Mailjet service."""
API_KEY = os.environ["MAILJET_API_KEY"]
API_SECRET = os.environ["MAILJET_API_SECRET"]
FROM_EMAIL = os.environ["MAILJET_FROM_EMAIL"]
FROM_EMAIL_USER = os.environ["MAILJET_FROM_EMAIL_NAME"]
TO_EMAIL = name['email']
TO_EMAIL_USER = name['user_name'].title()
EMAIL_SUBJECT = "Rohit's bot at your service!"
EMAIL_TEXT = "Rohit says hello!"
EMAIL_HTML_CONTENT = """\
<html>
<body>
<p>Thank you for checking out the website. Please connect on <a href="https://in.linkedin.com/in/rohitdiwakar">LinkedIn</a> and we can take things forward.</p>
<p>Cheers, <br>Rohit's Bot<p>
</body>
</html>
"""
mailjet = Client(auth=(API_KEY, API_SECRET), version='v3.1')
data = {
'Messages': [{
"From": {
"Email": FROM_EMAIL,
"Name": FROM_EMAIL_USER
},
"To": [{
"Email": TO_EMAIL,
"Name": TO_EMAIL_USER
}],
"Subject": EMAIL_SUBJECT,
"TextPart": EMAIL_TEXT,
"HTMLPart": EMAIL_HTML_CONTENT,
"CustomID": "AppGettingStartedTest"
}]
}
result = mailjet.send.create(data=data)
return True
def send_mail(
recipient,
subject,
content="<h3>Ouaf ouaf!</h3><br />",
sender_address=sender,
myname="Leximpact",
):
mailjet = Client(auth=(USER, PASSWD), version="v3.1")
data = {
"Messages": [
{
"From": {"Email": sender_address, "Name": myname},
"To": [{"Email": recipient}],
"Subject": subject,
"TextPart": "",
"HTMLPart": content,
}
]
}
result = mailjet.send.create(data=data)
if result.status_code != 200:
print("Error in sending email : ", result.json())
def send_mail(mail, name, subject, textPart, htmlPart): # pragma: no cover
api_key = os.environ.get('MAIL_API')
api_secret = os.environ.get('MAIL_KEY')
mailjet = Client(auth=(api_key, api_secret), version='v3.1')
data = {
'Messages': [{
"From": {
"Email": "*****@*****.**",
"Name": "Kalepa Info"
},
"To": [{
"Email": mail,
"Name": name
}],
"Subject": subject,
"TextPart": textPart,
"HTMLPart": htmlPart
}]
}
result = mailjet.send.create(data=data)
return result.json()
def handle_contact_request(template, subject_base, recipient):
if request.method == 'GET':
return render_template(template,
c=Common(),
result=('success' if 'success' in request.args else ''))
if get_secret('RECAPTCHA_SECRET_KEY'):
score = create_assessment(request.form['g-recaptcha-response'])
if score < 0.5:
return render_template(template, c=Common(), result='failure')
if get_secret('MAILJET_API_KEY') and get_secret('MAILJET_API_SECRET'):
mailjet = Client(auth=(get_secret('MAILJET_API_KEY'), get_secret('MAILJET_API_SECRET')),
version='v3.1')
subject = '[' + subject_base + '] Contact form submission by ' + request.form['name']
if request.form['wcaid']:
subject += ' (' + request.form['wcaid'] + ')'
data = {
'Messages': [
{
'From': {
'Email': '*****@*****.**',
'Name': 'CubingUSA Contact Form',
},
'To': [
{
'Email': recipient,
},
{
'Email': request.form['from-address'],
'Name': request.form['name'],
},
],
'Subject': subject,
'TextPart': request.form['contact-message'],
}
]
}
result = mailjet.send.create(data=data)
return redirect(request.root_path + request.path + '?success=1')
def sendemail():
mailjet = Client(auth=(api_key, api_secret), version='v3.1')
customername = request.json.get('customername', None)
email = request.json.get('email', None)
packagename = request.json.get('packagename', None)
data = {
'Messages': [{
"From": {
"Email": "*****@*****.**",
"Name": "AfterLife"
},
"To": [{
"Email": email,
"Name": customername
}],
"Subject":
"Your order is confirmed",
"HTMLPart":
"Dear " + customername +
",<br><br>We would like to inform you that the payment \
for \"" + packagename +
"\" has been received and your order is being processed.\
<br><br>Sincerely, <br>AfterLIFE",
"CustomID":
"AppGettingStartedTest"
}]
}
result = mailjet.send.create(data=data)
if (result.status_code != 200):
error = {
'status': result.status_code,
'message':
result.json()["Messages"][0]["Errors"][0]["ErrorMessage"]
}
send_error(error)
return (error), result.status_code
else:
return (result.json())
def send_knowledge():
subject = wikipedia.random(1)
summary = wikipedia.summary(subject)
email = request.form['email']
name = request.form['name']
body = "A brief summary of: {}\n{}".format(subject, summary)
bodyhtml = "<div><h2>A brief summary of: {}</h2><br /><p>{}</p></div><br /><br /><p>Your friend {} thought you should know<p>".format(
subject, summary, name)
api = '1b3a86b86c9b6d15fd254f2e5edcfe09'
secret = '6fa9ad8d7d8392adca139d7c587a6a3a'
mailjet = Client(auth=(api, secret), version='v3.1')
data = {
'Messages': [{
"From": {
"Email": "*****@*****.**",
"Name": "Random Info"
},
"To": [{
"Email": email,
"Name": "you"
}],
"Subject": "A little info about: {}".format(subject),
"TextPart": body,
"HTMLPart": bodyhtml
}]
}
result = mailjet.send.create(data=data)
status = result.status_code
if status == 200:
return render_template("knowledgesent.html",
subject=subject,
body=body)
else:
return render_template("error.html", status=status)
def send_mail(form):
mailjet = Client(auth=(api_key, api_secret), version='v3.1')
data = {
'Messages': [{
"From": {
"Email": "*****@*****.**",
"Name": "Api'Flat"
},
"To": [{
"Email": form['email'],
"Name": form['first_name']
}],
"Subject":
"Inscription",
"TextPart":
"Inscription",
"HTMLPart":
"<h3>Bienvenue sur Api'Flat, l'appli de gestion de votre colocation. Votre compte a été créé avec succès",
"CustomID":
"AppGettingStartedTest"
}]
}
mailjet.send.create(data=data)
def send_async():
mailjet = Client(auth=(app.config["MAILJET_API_KEY"],
app.config["MAILJET_API_SECRET"]))
# Response of send.create is this:
# {'Sent': [{'Email': '*****@*****.**', 'MessageID': 19421835755008714}]}
try:
response = mailjet.send.create(data=data)
result = response.json()
# We had issues where the message ID was already in our db
if not MailjetMessage.query.get(result['Sent'][0]['MessageID']):
db.session.add(
MailjetMessage(
id=result['Sent'][0]['MessageID'],
json_response=result,
message_reason=reason,
))
db.session.commit()
except Exception as e:
db.session.rollback()
# Mailjet can fail and we'd get an invalid json response, log that instead of throwing
LOG.warn("Mailjet failed in giving us info: %r - %r" %
(e, response.status_code))
def send_mail():
api_key = 'Mention your API key here'
api_secret = 'Mention your secret API key here'
mailjet = Client(auth=(api_key, api_secret), version='v3.1')
data = {
'Messages': [{
"From": {
"Email": "mention your sender mail here",
"Name": "PRICE_SCRAPER"
},
"To": [{
"Email": csv_email,
"Name": "USER"
}],
"Subject": msg,
"TextPart": URL,
#"HTMLPart": "<h3>Dear passenger 1, welcome to <a href='https://www.mailjet.com/'>Mailjet</a>!</h3><br />May the delivery force be with you!",
#"CustomID": "AppGettingStartedTest"
}]
}
result = mailjet.send.create(data=data)
print(result.status_code)
print(result.json())
def sent_mail(to, pdf_name, subject):
with open("test.pdf", "rb") as pdf_file:
encoded_string = base64.b64encode(pdf_file.read()).decode('utf-8')
api_key = API_KEY
api_secret = API_SECRET
mailjet = Client(auth=(api_key, api_secret), version='v3.1')
data = {
'Messages': [
{
"From": {
"Email": "*****@*****.**",
"Name": "SUSHANT"
},
"To": [
{
"Email": to,
"Name": "USER"
}
],
"Subject": subject,
"TextPart": "Greetings from COVIPS!",
"HTMLPart": "<h3>TICKET INFO </h3><br />PDF ATTACHED TO THIS MAIL PLEASE VIEW",
"Attachments": [
{
"ContentType": "application/pdf",
"Filename": pdf_name,
"Base64Content": encoded_string
}
]
}
]
}
result = mailjet.send.create(data=data)
print(result.status_code)
print(result.json())
def send_message(recipients):
"""Sends mail to project owners using Mailjet API endpoint
Args:
recipients ([dict()]): JSON-like recipient array
"""
data = open("../Data/Output/Production/predictions.csv", 'rb').read()
base64_encoded = base64.b64encode(data).decode('UTF-8')
api_key = '*****'
api_secret = '*****'
mailjet = Client(auth=(api_key, api_secret), version='v3.1')
data = {
'Messages': [{
"From": {
"Email": "*****@*****.**",
"Name": "Mogilno"
},
"To":
recipients,
"Subject":
"Prediction Vola Open pour le " + tradingDay,
"TextPart":
"Ceci est un mail automatique.\nTableau des résultats de prédictions par le réseau pour la journée du "
+ predictionDay +
".\nLa valeur de prédiction est comprise entre 0 et 1:\n1 étant fortement recommandé, 0 étant pas du tout recommandé.",
"Attachments": [{
"ContentType": "text/plain",
"Filename": "predictions.csv",
"Base64Content": base64_encoded
}],
"CustomID":
"AppPredictionData"
}]
}
result = mailjet.send.create(data=data)
print(result.status_code)
print(result.json())
def send_mail(subject, user, text_heading, payload):
mail_client = Client(
auth=(MAILJET_API_KEY, MAILJET_API_SECRET), version='v3.1')
data = data = {
'Messages': [
{
"From": {
"Email": REGISTERED_MAIL,
"Name": SITE_ADMIN
},
"To": [
{
"Email": user.email,
"Name": user.username
}
],
"Subject": subject,
"TextPart": text_heading,
"HTMLPart": payload
}
]
}
response = mail_client.send.create(data=data)
return response
def send_notification(query):
cfg = config['email']
msg = {}
msg['From'] = {
'Name': 'BITOUBI Notifications',
'Email': '<*****@*****.**>'
}
msg['To'] = [{'Name': 'Le Marché', 'Email': cfg['addr']}]
logger.info('connecting')
mailjet = Client(auth=(cfg['api_key'], cfg['api_secret']), version='v3.1')
data = {
'Messages': [{
'From': msg['From'],
'To': msg['To'],
'Subject':
f"C4 Notif: {MSG_LIST.get(query.action, 'action')} [{query.env}]",
'TextPart': write_notification(query)
}]
}
result = mailjet.send.create(data=data)
logger.info(result.status_code)
logger.info(result.json())
logger.info('Sent notification %s', data['Messages'][0]['Subject'])
def sendEmail(subject, mail):
format_email_cc = []
for email in emails_list:
format_email_cc.append(Client(email, email.split("@")[0]))
data = {
"Globals": {
"From": {
"Email": email_from,
"Name": email_from.split("@")[0]
},
"Cc": format_email_cc,
"Subject": subject,
"HTMLPart": mail
},
"Messages": [{
"To": [{
"Email": email_to,
"Name": email_to.split("@")[0]
}]
}]
}
result = mailjet.send.create(data=data)
return result
def emailforgotpassword(request):
data = request.data
recemail = data['email']
link = "www.vendorsin.com"
try:
user = UserRegistration.objects.get(user_mail=recemail)
if user:
api_key = '760b42c43a3522e91e004257a100d97e'
api_secret = 'a789bad80219938e51485b2d53db68d3'
mailjet = Client(auth=(api_key, api_secret), version='v3.1')
data1 = {'Messages': [
{"From": {"Email": "*****@*****.**", "Name": "Vendors In"}, "To": [{"Email": recemail}],
"Subject": "Password Change",
"TextPart": "Dear User,\n\nclick link here to change password: "******"\n\nThis is System Generated Email Please Don't Reply For This Mail"}]}
result = mailjet.send.create(data=data1)
if result.status_code == 200:
return Response({'status': 200, 'message': 'mail sent successfully'}, status=200)
else:
return Response({'status': 424, 'message': 'mail not sent'}, status=424)
except ObjectDoesNotExist as e:
return Response({'status': 404, 'error': "email not exist"}, status=404)
except Exception as e:
return Response({'status': 500, 'error': str(e)}, status=500)
def book():
MAILJET_KEY = os.getenv('MAILJET_KEY')
API_SECRET = os.getenv('API_SECRET')
mailjet = Client(auth=(MAILJET_KEY, API_SECRET), version='v3.1')
claim = get_jwt_identity()
data = request.json
student_id = claim.get('student')
logging.info(data, data.get('id', ''))
student = Student.query.filter_by(id=student_id)
yoga_class = Yogaclass.query.filter_by(id=data.get('id')).first()
yoga_class.student_id = student_id
data = {
'Messages': [{
"From": {
"Email": " " + yoga_class.teacher_id.email,
"Name": "Mai"
},
"To": [{
"Email": " " + student.email, #pass in the student email here
"Name":
" " + student.first_name, #pass in the student name here
}],
"Subject":
"Class booked for " + yoga_class.title,
"TextPart":
"Namaste",
"HTMLPart":
"<h3>Dear passenger 1, welcome to <a href='https://www.mailjet.com/'>Mailjet</a>!</h3><br />May the delivery force be with you!",
"CustomID":
"AppGettingStartedTest"
}]
}
result = mailjet.send.create(data=data)
db.session.commit()
return json.dumps({'confirmation': 'true'})
def envoi_mail_reset_mdp(email):
#définir les API_KEY
api_key = '3c7d767dbc11a8a4b0b53962cd823d23'
api_secret = '7761428aea9ca5e3e6cab1419c89389b'
mailjet = Client(auth=(api_key, api_secret), version='v3.1')
data = {
'Messages': [{
"From": {
"Email": "*****@*****.**",
"Name": "Sofiane"
},
"To": [{
"Email": email,
"Name": " "
}],
"Subject":
"Test Application FootEvent",
"HTMLPart":
"<h3>Bonjour, Veuillez réinitialiser votre mot de passe en cliquant sur le lien suivant <a href='http://127.0.0.1:5000/mdp_reset'>Mot_de_passe</a>!</h3><br /> Merci, en vous souhaitant une bonne journée"
}]
}
result = mailjet.send.create(data=data)
def emailNotification(toaddrs,subject, rssItems):
"""
emailNotification: Send email notification if provided. Using mailjet api
"""
logger.info('Send notification', extra={'toaddrs':toaddrs,'subject':subject, 'body':rssItems})
api_key = ''
api_secret = ''
mailjet = Client(auth=(api_key, api_secret), version='v3.1')
data = {
'Messages': [
{
"From": {
"Email": "*****@*****.**",
"Name": "email-notifier"
},
"To": [
{
"Email": toaddrs,
"Name": "recipient"
}
],
"Subject": subject,
"HTMLPart": rssItems,
"CustomID": "AppGettingStartedTest"
}
]
}
try:
result = mailjet.send.create(data=data)
logger.info('emailNotification', extra={'result': result.json()})
return result.json()
except Exception as e:
logger.info('emailNotification', extra={'exception': e})
return e
from mailjet_rest import Client
from check import checkAndBreak
import os
# Get your environment Mailjet keys
API_KEY = '4716c6d88b4d3d8a9ae3507ba834bb42'
API_SECRET = '30214f5c5ade691ae57e1c93144d0b81'
frommail = '*****@*****.**'
fromname = 'Mailjet Pilot'
subject = 'Your email flight plan!'
text = 'Dear passenger, welcome to Mailjet! May the delivery force be with you!'
htlm = '<h1>Testing</h1>'
mailjet = Client(auth=(API_KEY, API_SECRET), version='v3')
email_data = {
'FromEmail': '*****@*****.**',
'FromName': 'Mailjet Pilot',
'Subject': 'Your email flight plan!',
'Text-part':
'Dear passenger, welcome to Mailjet! May the delivery force be with you!',
'Html-part': '<h1>Testing</h1>',
'Recipients': [{
"Email": "*****@*****.**"
}]
}
result = mailjet.send.create(data=email_data)
if result.status_code == 200:
checkAndBreak(subject)
from class_data import GetInstitutionFromLectureId
from class_data import GetCourseNameFromLectureId
from class_data import GetDateOfLectureFromLectureId
from passlib.hash import sha256_crypt
from random import choice, randint
from mailjet_rest import Client
from google.cloud import storage
BUCKET_NAME = 'chalkboards_uploads'
MAILJET_API_KEY = 'bffc84aea3085b6e9ecd32dafe49d81e'
MAILJET_API_SECRET = 'bf4a0b01f8c476331d57396d24f8cc5d'
MAILJET_SENDER = '*****@*****.**'
MALFORMED_REQUEST = 'Malformed request. Operation could not be completed.'
UNAUTHORIZED_USER = '******'
mailjet = Client(auth=(MAILJET_API_KEY, MAILJET_API_SECRET), version='v3.1')
app = Flask(__name__)
users_by_user_id = {}
user_id_by_email = {}
user_credentials = {}
passwords = set()
characters = string.ascii_letters + string.punctuation + string.digits
def is_ipv6(addr):
"""Checks if a given address is an IPv6 address."""
try:
socket.inet_pton(socket.AF_INET6, addr)
class Mailjet(Base_messagerie):
def __init__(self, **kwds):
Base_messagerie.__init__(self, **kwds)
def Connecter(self):
# Récupération des clés Mailjet
api_key = self.dict_parametres.get("api_key", None)
api_secret = self.dict_parametres.get("api_secret", None)
if api_key == None or api_secret == None:
raise ValueError(u"Les codes MAILJET ne sont pas valides.")
# Connexion à Mailjet
try:
from mailjet_rest import Client
self.connection = Client(auth=(api_key, api_secret), version='v3.1')
except Exception as err:
raise
# def Envoyer_archive(self, message=None, afficher_confirmation_envoi=False):
# self.Envoyer_lot(messages=[message,], afficher_confirmation_envoi=afficher_confirmation_envoi)
#
# def Envoyer_lot_archive(self, messages=[], dlg_progress=None, afficher_confirmation_envoi=True):
# """ Envoi des messages par lot """
# data = {"Messages": []}
# for message in messages:
#
# # Préparation du message
# dict_message = {
# "From": {"Email": self.email_exp, "Name": self.nom_exp},
# "To": [{"Email": destinataire} for destinataire in message.destinataires],
# "Subject": message.sujet,
# "TextPart": message.texte_plain,
# "HTMLPart": message.texte_html,
# "Attachments": [],
# "InlinedAttachments": [],
# }
#
# # Intégration des images incluses
# index = 0
# for fichier in message.images:
# ctype, encoding = mimetypes.guess_type(fichier)
# with open(fichier, "rb") as file:
# Base64Content = base64.b64encode(file.read())
# nom_fichier = os.path.basename(fichier)
#
# dict_fichier = {
# "ContentType": ctype,
# "Filename": nom_fichier,
# "ContentID": "image%d" % index,
# "Base64Content": Base64Content,
# }
# dict_message["InlinedAttachments"].append(dict_fichier)
# index += 1
#
# # Intégration des pièces jointes
# for fichier in message.fichiers:
# ctype, encoding = mimetypes.guess_type(fichier)
# with open(fichier, "rb") as file:
# Base64Content = base64.b64encode(file.read())
# nom_fichier = os.path.basename(fichier)
#
# dict_fichier = {
# "ContentType": ctype,
# "Filename": nom_fichier,
# "Base64Content": Base64Content,
# }
# dict_message["Attachments"].append(dict_fichier)
#
# # Mémorisation du message
# data["Messages"].append(dict_message)
#
# if wx.GetKeyState(wx.WXK_CONTROL) == True:
# from Utils import UTILS_Json
# UTILS_Json.Ecrire(nom_fichier=UTILS_Fichiers.GetRepTemp(fichier="appel_mailjet.txt"), data=data)
# return False
#
# # Envoi de la requête à Mailjet
# resultats = self.connection.send.create(data=data)
# # print resultats.status_code
# # print resultats.json()
#
# # Analyse des résultats
# liste_succes = []
# listeAnomalies = []
# index = 0
# for message in messages:
# resultat_message = resultats.json()["Messages"][index][u'Status']
# if resultat_message == u'success':
# liste_succes.append(message)
# else :
# listeAnomalies.append((message, resultat_message))
# index += 1
#
# # Fin de la gauge
# if dlg_progress != None:
# dlg_progress.Update(index, _(u"Fin de l'envoi."))
# dlg_progress.Destroy()
#
# # Si tous les Emails envoyés avec succès
# if len(listeAnomalies) == 0 and afficher_confirmation_envoi == True:
# if len(liste_succes) == 1:
# message = _(u"L'Email a été envoyé avec succès !")
# else:
# message = _(u"Les %d Emails ont été envoyés avec succès !") % len(liste_succes)
# dlg = wx.MessageDialog(None, message, _(u"Fin de l'envoi"), wx.OK | wx.ICON_INFORMATION)
# dlg.ShowModal()
# dlg.Destroy()
#
# # Si Anomalies
# if len(listeAnomalies) > 0 and len(messages) > 1:
# if len(liste_succes) > 0:
# intro = _(u"%d Email(s) ont été envoyés avec succès mais les %d envois suivants ont échoué :") % (
# len(liste_succes), len(listeAnomalies))
# else:
# intro = _(u"Tous les envois ont lamentablement échoué :")
# lignes = []
# for message, erreur in listeAnomalies:
# adresse = message.GetLabelDestinataires()
# try:
# lignes.append(u"- %s : %s" % (adresse.decode("iso-8859-15"), erreur))
# except:
# lignes.append(u"- %s : %s" % (adresse, erreur))
# dlg = DLG_Messagebox.Dialog(None, titre=_(u"Compte-rendu de l'envoi"), introduction=intro,
# detail="\n".join(lignes), icone=wx.ICON_INFORMATION, boutons=[_(u"Ok"), ])
# dlg.ShowModal()
# dlg.Destroy()
#
# return liste_succes
def Envoyer(self, message=None):
# Préparation du message
dict_message = {
"From": {"Email": self.email_exp, "Name": self.nom_exp},
"To": [{"Email": destinataire} for destinataire in message.destinataires],
"Subject": message.sujet,
"TextPart": message.texte_plain,
"HTMLPart": message.texte_html,
"Attachments": [],
"InlinedAttachments": [],
}
# Intégration des images incluses
index = 0
for fichier in message.images:
ctype, encoding = mimetypes.guess_type(fichier)
with open(fichier, "rb") as file:
Base64Content = base64.b64encode(file.read())
nom_fichier = os.path.basename(fichier)
dict_fichier = {
"ContentType": ctype,
"Filename": nom_fichier,
"ContentID": "image%d" % index,
"Base64Content": Base64Content,
}
dict_message["InlinedAttachments"].append(dict_fichier)
index += 1
# Intégration des pièces jointes
for fichier in message.fichiers:
ctype, encoding = mimetypes.guess_type(fichier)
with open(fichier, "rb") as file:
Base64Content = base64.b64encode(file.read())
nom_fichier = os.path.basename(fichier)
dict_fichier = {
"ContentType": ctype,
"Filename": nom_fichier,
"Base64Content": Base64Content,
}
dict_message["Attachments"].append(dict_fichier)
# Envoi de la requête à Mailjet
resultats = self.connection.send.create(data={"Messages": [dict_message,]})
# print resultats.status_code
# print resultats.json()
# Analyse du résultat
resultat = resultats.json()["Messages"][0][u'Status']
if resultat != u'success':
raise Exception(resultat)
return resultat
def Fermer(self):
self.connection.close()
def Envoyer_lot(self, messages=[], dlg_progress=None, afficher_confirmation_envoi=True):
""" Envoi des messages par lot """
# Envoi des mails
index = 1
listeAnomalies = []
listeSucces = []
ne_pas_signaler_erreurs = False
for message in messages:
while True:
adresse = message.GetLabelDestinataires()
try:
labelAdresse = adresse.decode("iso-8859-15")
except:
labelAdresse = adresse
label = _(u"Envoi %d/%d : %s...") % (index, len(messages), labelAdresse)
# Si la dlg_progress a été fermée, on la réouvre
if dlg_progress == None:
dlg_progress = wx.ProgressDialog(_(u"Envoi des mails"), _(u""), maximum=len(messages) + 1, parent=None)
dlg_progress.SetSize((450, 140))
dlg_progress.CenterOnScreen()
dlg_progress.Update(index, label)
# Envoi
try:
self.Envoyer(message)
listeSucces.append(message)
except Exception as err:
err = str(err).decode("iso-8859-15")
listeAnomalies.append((message, err))
print(("Erreur dans l'envoi d'un mail : %s...", err))
traceback.print_exc(file=sys.stdout)
if ne_pas_signaler_erreurs == False:
# Fermeture de la dlg_progress
dlg_progress.Destroy()
dlg_progress = None
# Affichage de l'erreur
intro = _(u"L'erreur suivante a été détectée :")
detail = err
if index <= len(messages) - 1:
conclusion = _(u"Souhaitez-vous quand même continuer l'envoi des autres emails ?")
boutons = [_(u"Réessayer"), _(u"Continuer"),
_(u"Continuer et ne plus signaler les erreurs"), _(u"Arrêter")]
else:
conclusion = None
boutons = [_(u"Réessayer"), _(u"Arrêter"), ]
dlgErreur = DLG_Messagebox.Dialog(None, titre=_(u"Erreur"), introduction=intro, detail=detail,
conclusion=conclusion, icone=wx.ICON_ERROR, boutons=boutons)
reponse = dlgErreur.ShowModal()
dlgErreur.Destroy()
if reponse == 0:
continue
if reponse == 2:
ne_pas_signaler_erreurs = True
if reponse == 3:
return listeSucces
break
if len(messages) > 1:
time.sleep(1)
index += 1
# Fin de la gauge
if dlg_progress != None:
dlg_progress.Update(index, _(u"Fin de l'envoi."))
dlg_progress.Destroy()
# Si tous les Emails envoyés avec succès
if len(listeAnomalies) == 0 and afficher_confirmation_envoi == True:
if len(listeSucces) == 1:
message = _(u"L'Email a été envoyé avec succès !")
else:
message = _(u"Les %d Emails ont été envoyés avec succès !") % len(listeSucces)
dlg = wx.MessageDialog(None, message, _(u"Fin de l'envoi"), wx.OK | wx.ICON_INFORMATION)
dlg.ShowModal()
dlg.Destroy()
# Si Anomalies
if len(listeAnomalies) > 0 and len(messages) > 1:
if len(listeSucces) > 0:
intro = _(u"%d Email(s) ont été envoyés avec succès mais les %d envois suivants ont échoué :") % ( len(listeSucces), len(listeAnomalies))
else:
intro = _(u"Tous les envois ont lamentablement échoué :")
lignes = []
for message, erreur in listeAnomalies:
adresse = message.GetLabelDestinataires()
try:
lignes.append(u"- %s : %s" % (adresse.decode("iso-8859-15"), erreur))
except:
lignes.append(u"- %s : %s" % (adresse, erreur))
dlg = DLG_Messagebox.Dialog(None, titre=_(u"Compte-rendu de l'envoi"), introduction=intro, detail="\n".join(lignes), icone=wx.ICON_INFORMATION, boutons=[_(u"Ok"), ])
dlg.ShowModal()
dlg.Destroy()
return listeSucces
def Fermer(self):
pass
