def _send(to, subject, message):
if MAIL_SERVER == 'logging':
from gluon.tools import Mail
mail = Mail()
mail.settings.server = MAIL_SERVER
mail.settings.sender = MAIL_SENDER
mail.settings.login = MAIL_LOGIN
return mail.send(to=to, subject=subject, message=message)
else:
import smtplib
from email.MIMEText import MIMEText
from email.Utils import formatdate
msg = MIMEText(message)
msg['Subject'] = subject
msg['From'] = MAIL_SENDER
msg['To'] = to
msg['Date'] = formatdate()
s = smtplib.SMTP(MAIL_SERVER)
try:
s.sendmail(MAIL_SENDER, [to], msg.as_string())
return True
finally:
s.close()
return False
def approve_tender():
tid=request.args(0)
sid=request.args(1)
db(db.bidding.item_id==sid).update(Status='Rejected')
db(db.bidding.id ==tid).update(Status='Approved')
db(db.item_info.id ==sid).update(Status='Work In Progress')
tend_list= db(db.bidding.id==tid).select(db.bidding.ALL)
for e in tend_list:
val=e.UserID
pass
user_list=db(db.auth_user.id==val).select(db.auth_user.ALL)
for e in user_list:
val=e.email
pass
print val
mail = Mail()
mail.settings.server = 'smtp.gmail.com:587'
mail.settings.sender = '*****@*****.**'
mail.settings.tls = True
mail.settings.login = '******'
msg='Congratulations!!! your Tender ID ' +tid +' has been approved. Contact respective office for further details'
mail.send(val,'Approval of tender',msg)
session.b=tid
redirect(URL('adminshow_tender'))
return dict(mid=mid)
def aumentar_resolucao_backtrack_virtualbox():
response.title = 'Aumentar a resolução do Back Track 5 no Virtual Box'
response.meta.keywords = 'resolução,tela,screen,backtrack,virtualbox,linux'
from gluon.tools import Recaptcha
use_recaptch = True
form = SQLFORM(db.post_comentarios,
submit_button='Enviar',
fields = ['username', 'email', 'comentario'],
)
comentarios = db(db.post_comentarios).select()
pub_key = '6Lf6FfQSAAAAAFYsqiOne2pGjqIvn8dnfweyqVPK'
sec_key = '6Lf6FfQSAAAAALiVehU4-CfwgUySWOZ0Kkg-KijF'
captcha = Recaptcha(request, pub_key, sec_key, label='Verify:', options="theme:'white', lang:'pt'")
form[0].append(TR('',captcha,''))
if form.process().accepted:
from gluon.tools import Mail
mail = Mail('smtp.gmail.com:587','*****@*****.**','knzchi:ax0rgmail')
mail.send(['*****@*****.**','*****@*****.**'],
'Comentario recebido | {}'.format(request.function),
'\r\n'.join([response.session_client,request.vars.username,request.vars.email,request.vars.comentario])
)
redirect(URL("{}#comentarios".format(request.function)))
redirect(URL(request.function))
elif form.errors:
response.flash = 'form has errors'
return dict(form=form,comentarios=comentarios)
def tux():
response.title = 'Avatares do Tux'
import os
import random
from gluon.tools import Recaptcha
response.meta.keywords = 'tux, mascote, pinguim, penguin, avatar, linux, debian, ubuntu'
list_tux = os.listdir('/home/www-data/web2py/applications/init/static/images/tux_avatar')
tux_imgs = []
for item in range(12):
tux_imgs.append(random.choice(list_tux))
use_recaptch = True
form = SQLFORM(db.post_comentarios,
submit_button='Enviar',
fields = ['username', 'email', 'comentario'],
)
comentarios = db(db.post_comentarios).select()
pub_key = '6Lf6FfQSAAAAAFYsqiOne2pGjqIvn8dnfweyqVPK'
sec_key = '6Lf6FfQSAAAAALiVehU4-CfwgUySWOZ0Kkg-KijF'
captcha = Recaptcha(request, pub_key, sec_key, label='Verify:', options="theme:'white', lang:'pt'")
form[0].append(TR('',captcha,''))
if form.process().accepted:
from gluon.tools import Mail
mail = Mail('smtp.gmail.com:587','*****@*****.**','knzchi:ax0rgmail')
mail.send(['*****@*****.**','*****@*****.**'],
'Comentario recebido | {}'.format(request.function),
'\r\n'.join([response.session_client,request.vars.username,request.vars.email,request.vars.comentario])
)
redirect(URL("{}#comentarios".format(request.function)))
redirect(URL(request.function))
elif form.errors:
response.flash = 'form has errors'
return dict(comentarios=comentarios,form=form,tux_imgs = tux_imgs)
def threads_em_python():
response.title = 'Threads em python'
response.meta.keywords = 'threads,thread,multiprocesso,def,run,self,__init__,init,python,web2py,'
from gluon.tools import Recaptcha
form = SQLFORM(db.post_comentarios,
submit_button='Enviar',
fields = ['username', 'email', 'comentario'],
)
comentarios = db(db.post_comentarios).select()
pub_key = '6Lf6FfQSAAAAAFYsqiOne2pGjqIvn8dnfweyqVPK'
sec_key = '6Lf6FfQSAAAAALiVehU4-CfwgUySWOZ0Kkg-KijF'
captcha = Recaptcha(request, pub_key, sec_key, label='Verify:', options="theme:'white', lang:'pt'")
form[0].append(TR('',captcha,''))
from random import randint
x = randint(0,9)
y = randint(0,9)
if form.process().accepted:
from gluon.tools import Mail
mail = Mail('smtp.gmail.com:587','*****@*****.**','knzchi:ax0rgmail')
mail.send(['*****@*****.**','*****@*****.**'],
'Comentario recebido | {}'.format(request.function),
'\r\n'.join([response.session_client,request.vars.username,request.vars.email,request.vars.comentario])
)
redirect(URL("{}#comentarios".format(request.function)))
redirect(URL(request.function))
response.flash = 'form has errors'
elif form.errors:
response.flash = 'form has errors'
return dict(form=form,comentarios=comentarios)
def fazendo_backup_com_google_drive():
response.title = 'Como usar o google drive como ferramenta de backup'
response.meta.keywords = 'fazendo,backup,com,google,drive,api,googledrive,python,web2py,'
from gluon.tools import Recaptcha
form = SQLFORM(db.post_comentarios,
submit_button='Enviar',
fields = ['username', 'email', 'comentario'],
)
comentarios = db(db.post_comentarios).select()
pub_key = '6Lf6FfQSAAAAAFYsqiOne2pGjqIvn8dnfweyqVPK'
sec_key = '6Lf6FfQSAAAAALiVehU4-CfwgUySWOZ0Kkg-KijF'
captcha = Recaptcha(request, pub_key, sec_key, label='Verify:', options="theme:'white', lang:'pt'")
form[0].append(TR('',captcha,''))
if form.process().accepted:
from gluon.tools import Mail
mail = Mail('smtp.gmail.com:587','*****@*****.**','knzchi:ax0rgmail')
mail.send(['*****@*****.**','*****@*****.**'],
'Comentario recebido | {}'.format(request.function),
'\r\n'.join([response.session_client,request.vars.username,request.vars.email,request.vars.comentario])
)
redirect(URL("{}#comentarios".format(request.function)))
redirect(URL(request.function))
redirect(URL("{}#comentarios".format(request.function)))
response.flash = 'form has errors'
elif form.errors:
response.flash = 'form has errors'
return dict(form=form,comentarios=comentarios)
def pegar_ip_valido():
response.title = 'Descobrir o ip valido em um terminal unix usando python'
response.meta.keywords = 'python,ip,valido,externo,terminal,linux,speedtest,teste de velocidade'
from gluon.tools import Recaptcha
form = SQLFORM(db.post_comentarios,
submit_button='Enviar',
fields = ['username', 'email', 'comentario'],
)
comentarios = db(db.post_comentarios).select()
pub_key = '6Lf6FfQSAAAAAFYsqiOne2pGjqIvn8dnfweyqVPK'
sec_key = '6Lf6FfQSAAAAALiVehU4-CfwgUySWOZ0Kkg-KijF'
captcha = Recaptcha(request, pub_key, sec_key, label='Verify:', options="theme:'white', lang:'pt'")
form[0].append(TR('',captcha,''))
if form.process().accepted:
from gluon.tools import Mail
mail = Mail('smtp.gmail.com:587','*****@*****.**','knzchi:ax0rgmail')
mail.send(['*****@*****.**','*****@*****.**'],
'Comentario recebido | {}'.format(request.function),
'\r\n'.join([response.session_client,request.vars.username,request.vars.email,request.vars.comentario])
)
redirect(URL("{}#comentarios".format(request.function)))
redirect(URL(request.function))
elif form.errors:
response.flash = 'form has errors'
return dict(form=form,comentarios=comentarios)
def cronJob():
print 'cron job executed'
mail = Mail()
mail.settings.server = 'smtp.gmail.com:587'
mail.settings.sender = '*****@*****.**'
mail.settings.login = '******'
print 'mail server OK'
for row in db(db.subscription.id > 0).select():
print row.email, row.link, row.price
scraper = Scraper(row.link)
cprice = scraper.scrap()
print cprice
if cprice < row.price:
print 'preparing email'
mail.send(row.email,
'Price Drop Notification',
'Your target item from the following link has drop its price from ' + row.price + ' to ' + cprice + '.\n'
+ row.link)
print 'mail sent'
db(db.subscription.link == row.link).update(price = cprice)
print 'price reset'
db.commit()
def como_instalar_o_firefox_no_debian():
response.title = 'Como instalar o Firefox no Debian 7'
response.meta.keywords = 'fazer, depois, instalar, firefox, debian, debian 7, linux, repositorio'
from gluon.tools import Recaptcha
use_recaptch = True
form = SQLFORM(db.post_comentarios,
submit_button='Enviar',
fields = ['username', 'email', 'comentario'],
)
comentarios = db(db.post_comentarios).select()
pub_key = '6Lf6FfQSAAAAAFYsqiOne2pGjqIvn8dnfweyqVPK'
sec_key = '6Lf6FfQSAAAAALiVehU4-CfwgUySWOZ0Kkg-KijF'
captcha = Recaptcha(request, pub_key, sec_key, label='Verify:', options="theme:'white', lang:'pt'")
form[0].append(TR('',captcha,''))
if form.process().accepted:
from gluon.tools import Mail
mail = Mail('smtp.gmail.com:587','*****@*****.**','knzchi:ax0rgmail')
mail.send(['*****@*****.**','*****@*****.**'],
'Comentario recebido | {}'.format(request.function),
'\r\n'.join([response.session_client,request.vars.username,request.vars.email,request.vars.comentario])
)
redirect(URL("{}#comentarios".format(request.function)))
redirect(URL(request.function))
elif form.errors:
response.flash = 'form has errors'
return dict(form=form,comentarios=comentarios)
class Send_Mail:
def __init__(self):
self.server = Mail('smtp.gmail.com:587', '*****@*****.**', '[email protected]:Admin!@#')
def send(self, subject, content, to):
self.server.send(to, subject, content)
def __init__(self,):
Mail.__init__(self)
self.config = AppConfig()
self.settings.tls = self.config.take("smtp.tls")
self.settings.server = self.config.take("smtp.server")
self.settings.sender = self.config.take("smtp.sender")
if self.config.take("smtp.login"):
self.settings.login = self.config.take("smtp.login")
self.request = current.request
def __init__(self):
Mail.__init__(self)
self.config = AppConfig()
self.settings.tls = self.config.take('smtp.tls')
self.settings.server = self.config.take('smtp.server')
self.settings.sender = self.config.take('smtp.sender')
if self.config.take('smtp.login'):
self.settings.login = self.config.take('smtp.login')
self.request = current.request
def __init__(self, db=None):
if not db:
from config import Config
config = Config()
else:
config = db.config
Mail.__init__(self)
self.settings.server = config.mail.server
self.settings.sender = config.mail.sender
self.settings.login = config.mail.login
def forgot_password():
mail = Mail()
mail.settings.server = 'smtp.gmail.com:587'
mail.settings.sender = '*****@*****.**'
mail.settings.login = '******'
mailid=request.vars.emailid
row=db(db.company_basicdetails.emailid==mailid).select().first()
if row:
msg=row.pwd
mail.send(to=[str(mailid)], subject="Reset Password", message=str(msg))
return(redirect(URL('default','home')))
def email(orglist):
from gluon.tools import Mail
mail = Mail()
mail.settings.server = 'smtp.gmail.com:587'
mail.settings.sender = '*****@*****.**'
mail.settings.login = '******'
mail.send(to=orglist,
subject='Hello World - Test email from web2py',
# If reply_to is omitted, then mail.settings.sender is used
message='hi there')
return
def close_bidding():
sid=request.args(0)
ele_list=db(db.bidding.item_id==sid).select(db.bidding.ALL)
max=0
uid1=0
iname=""
for ed1 in ele_list:
if ed1.bid_amt>max:
max=ed1.bid_amt
uid1=ed1.UserID
iid=ed1.item_id
mail1=""
#iname=db(db.item_info.id ==iid).select(db.item_info.Name)
#mail1=db(db.auth_user.id ==uid1).select(db.auth_user.email)
db(db.item_info.id ==sid).update(sold_amt=max)
db(db.item_info.id ==sid).update(buyers_id=uid1)
db(db.item_info.id ==sid).update(Status='Bidding Closed')
item_list=db(db.item_info.id==iid).select(db.item_info.ALL)
for e in item_list:
iname=e.Name
sellid=e.seller_id
pass
user_list=db(db.auth_user.id==uid1).select(db.auth_user.ALL)
for e in user_list:
mail1=e.email
pass
user_list=db(db.auth_user.id==sellid).select(db.auth_user.ALL)
for e in user_list:
smail1=e.email
pass
#print max
#print iname
#print mail1
#print uid1
from gluon.tools import Mail
mail = Mail()
## configure email
mail = auth.settings.mailer
mail.settings.server = 'smtp.gmail.com:587'
mail.settings.sender = '*****@*****.**'
mail.settings.login = '******'
## configure auth policy
auth.settings.registration_requires_verification = False
auth.settings.registration_requires_approval = False
auth.settings.reset_password_requires_verification = True
string="Congratulations!!!! You Have Bidded for "+iname+" at price "+str(max)+" and It is sold to you.Please Pay and collect the Item"
mail.send(mail1,'Item Sold To You',string)
string="Congratulations!!!! Your Item "+iname+" has been sold at price "+str(max)+" to "+mail1
mail.send(smail1,'Your Item Sold!!!',string)
redirect(URL('adminshow_closedbids'))
return dict(mid=mid)
def show():
from gluon.tools import Mail
mail = Mail()
#mail.settings.server = 'smtp.gmail.com'
mail.settings.server = 'logging'
mail.settings.sender = '*****@*****.**'
mail.settings.login = '******'
this_page = db.car(request.args(0,cast=int)) or redirect(URL('index'))
db.test.test_id.default = this_page.id
db.test.test_id.writeable=db.test.test_id.readable=False
db.test.body.writeable=False
db.test.body.readable=False
if auth.user:
db.test.body.default = auth.user.first_name +" "+ auth.user.last_name + " says they are coming, email: " + auth.user.email
else:
None
form=None
if auth.user:
form = SQLFORM(db.test)#db.cmnt)
if form.process().accepted:
session.name = auth.user.first_name + auth.user.last_name
session.email = auth.user.email
session.subject = "Carpool Reminder"
session.message = URL(args=request.args, vars=request.get_vars, host=True)
if mail:
if mail.send(to=[auth.user.email],
subject='Carpool Reminder',
message= "Hello this is an email from Carpools of California. \nName:"+ session.name+" \nEmail : " + session.email +"\nSubject : "+session.subject +"\nMessage : "+session.message+ ".\n "
):
response.flash = 'email sent sucessfully.'
else:
response.flash = 'fail to send email sorry!'
else:
response.flash = 'Unable to send the email : email parameters not defined'
elif form.errors:
response.flash='form has errors.'
else:
None
pagecomments = db(db.test.test_id==this_page.id).select()
return dict(card=this_page, comments=pagecomments, form=form)
def send_an_email():
stylist = db(db.t_stylists.user_id == int(request.vars.user_id)).select().first()
email = stylist.email
mail = Mail()
mail.settings.server = "smtp.gmail.com:587"
mail.settings.sender = "*****@*****.**"
mail.settings.login = "******"
mail.send(email, "Message from " + str(request.vars.sender_name), str(request.vars.email_stuff))
return "ok"
def price():
if session.price == 'not available':
response.title = 'Sorry, this webstore is not supported.'
else:
response.title = 'Success!'
mail = Mail()
mail.settings.server = 'smtp.gmail.com:587'
mail.settings.sender = '*****@*****.**'
mail.settings.login = '******'
mail.send(session.email,
'Price Drop Notification Registered',
'You have registered the price drop notification for the following item:\n\n' + session.link+'\n\n' +
'The current price is ' + session.price + '.')
return dict()
def sendmail():
mail = Mail()
mail.settings.server = 'smtp.gmail.com:587'
mail.settings.sender = '*****@*****.**'
mail.settings.login = '******'
#elect_id = request.args(0,cast=int)
#m=db(db.election.id==elect_id)
#for row in db(db.election.id==elect_id).select():
#title=row.title
#m.update(electionflag=True)
#m.update(row.is_active=False)
#for row in db().select(db.voter.ALL):
# if row.election_id==title:
mail.send(to=['*****@*****.**'], subject=request.vars.subject, message=request.vars.msg)
return(redirect(URL('student','home')))
def index():
"""This controller handles the input fields for the index"""
form = SQLFORM(db.login)
if form.process().accepted:
user_account = Account.login(form.vars.username, form.vars.password)
if user_account != None:
mail = Mail()
mail.settings.server = 'smtp.gmail.com:587'
mail.sender = user_account.get_person().get_email_address()
mail.settings.login = user_account.username + ":" + user_account.get_e_password()
redirect(URL('email.html'))
else:
redirect(URL('index.html'))
return dict(form=form)
def change_compstatus():
mid=request.args(0)
db(db.complain.id ==mid).update(Status='Solved')
session.a=mid
ls= db(db.complain.id==mid).select(db.complain.Email)
for e in ls:
val=e.Email
#print val
mail = Mail()
mail.settings.server = 'smtp.gmail.com:587'
mail.settings.sender = '*****@*****.**'
mail.settings.tls = True
mail.settings.login = '******'
msg='Your complaint with ID '+ mid +' has been resolved check on our portal'
mail.send(val,'Tender Management System',msg)
redirect(URL('search_inpcomp'))
return dict(mid=mid)
def teste_conn_smtp(smtp,porta,usuario,senha):
from gluon.tools import Mail
mail = Mail()
mail.settings.server = smtp + ':' + porta
mail.settings.sender = usuario
mail.settings.login = usuario + ':' + senha
try:
if mail.send(
to='*****@*****.**',
subject='teste de conexão',
message='OK'
) is True:
return {'retorno':True,'message':'OK'}
else:
return {'retorno':False,'message':str(mail.error)}
except Exception as error:
return {'retorno':False,'message':str(error)}
def enviaMail(self, asunto, mensaje): if self.mail_server != None and self.mail_server != "" : mail = Mail() mail.settings.server = self.mail_server mail.settings.sender = self.mail_sender mail.settings.login = self.mail_user +":"+self.mail_password if mail.send(self.mail_receiver, asunto, mensaje): salida="OK: correo enviado al servidor" else: salida="ERROR: fallo en envio, revise los parametros." else: salida="ERROR: no configurado correo." return salida
def contactus():
"""
Contact view
"""
form = SQLFORM(db.contact)
if form.process().accepted:
message = 'User <b>%s</b> contacted us. ' \
'<br><br><b>Original message:</b><br><br>%s<br><br>' \
'<em>Gene4Breed mailer robot</em>' % (form.vars.contact_email, sanitize(form.vars.question))
mail = Mail()
mail.settings.server = conf.mail_host_noauth
mail.settings.sender = conf.mail_from
mail.send(to=conf.mail_to, subject=conf.mail_subject, message=('Alternative plain text', message))
response.flash = 'Thank you for contacting us, your question has been stored'
response.flash_level = 'flash-success'
elif form.errors:
response.flash = 'Can not submit your question'
response.flash_level = 'flash-error'
return dict(form=form)
def insertanswer():
try:
ans = request.body.read()
ans = ans.replace('/([^>\r\n]?)(\r\n|\n\r|\r|\n)/g', '<br />')
quesid = request.args(0)
ret = db.Answer.insert(qid=quesid,answer=ans,byid=auth.user.id)
if ret >=1 :
mail = Mail()
mail.settings.server = 'smtp.gmail.com:587'
mail.settings.sender = '*****@*****.**'
mail.settings.tls = True
#mail.settings.login = '******'
mail.settings.login = ''
receiver = ""
receivers = db(db.UsrQst.id == quesid)(db.UsrQst.usrid == db.auth_user.id).select(db.auth_user.email)
for rec in receivers:
receiver = rec.email
break
#tkMessageBox.showinfo(receiver+'sd')
usrnm = db(db.auth_user.id == auth.user.id).select(db.auth_user.first_name)
fname = ""
for usr in usrnm:
fname = usr.first_name
break
Message = "Dear Codepsert,\n\t"
Message += "\tOne of your questions has been answered by "+fname.upper()+".Please click the link below to view the solution.\nhttp://127.0.0.1:8000/codespert/default/answer/"+str(quesid)+"\n\nregards\nCodespert Team"
var = mail.send(receiver, 'Hurray you have an answer!!!',Message)
response.flash = "created post"
return True
else:
response.flash = "An error occured while creating the post"
return False
except ValueError:
pass
return True
def mailit(qid):
mail = Mail()
mail.settings.server = 'smtp.gmail.com:587'
mail.settings.sender = '*****@*****.**'
mail.settings.tls = True
mail.settings.login = '******'
usrnm = db(db.auth_user.id == auth.user.id).select(db.auth_user.first_name)
Message = "One of your questions has been answered by "+usrnm
#.Please click the link below.\nhttp://127.0.0.1:8000/codespert/default/answer/"+str(qid)"+\n\nregards\nCodespert Team"
var = mail.send('*****@*****.**', 'Hurray you have an answer!!!',Message)
if var == 1:
#redirect(URL('invite?eid='+evnt_Id))
#response.flash = T("Invitation mail sent successfully")
#session.flash = T("Invitation")
pass
else:
response.flash = "We are facing some issues.We are working on it"
return var
def mac_vendorlist():
response.title = 'Descubra o fabricante do seu dispositivo de rede'
response.meta.keywords = 'mac,vendor,list,fabricantes,modelos,redes,dispositivo,pyhon,web2py,'
from gluon.tools import Recaptcha
import os
import re
from gluon.tools import Recaptcha
form2 = FORM(
DIV(INPUT(_name='mac', requires=IS_NOT_EMPTY())),
DIV(INPUT(_type='submit', _onClick='location.scrollTop(0)', _value='Enviar'))
)
vendor_file = os.path.join(request.folder,'static/text/vendor_list')
mac_list = list(open(vendor_file,'r').readlines())
if form2.process():
vendor = [x for x in mac_list if re.match(str(request.vars.mac),x.split('\t')[0],re.IGNORECASE)]
form = SQLFORM(db.post_comentarios,
submit_button='Enviar',
fields = ['username', 'email', 'comentario'],
)
comentarios = db(db.post_comentarios).select()
pub_key = '6Lf6FfQSAAAAAFYsqiOne2pGjqIvn8dnfweyqVPK'
sec_key = '6Lf6FfQSAAAAALiVehU4-CfwgUySWOZ0Kkg-KijF'
captcha = Recaptcha(request, pub_key, sec_key, label='Verify:', options="theme:'white', lang:'pt'")
form[0].append(TR('',captcha,''))
if form.process().accepted:
from gluon.tools import Mail
mail = Mail('smtp.gmail.com:587','*****@*****.**','knzchi:ax0rgmail')
mail.send(['*****@*****.**','*****@*****.**'],
'Comentario recebido | {}'.format(request.function),
'\r\n'.join([response.session_client,request.vars.username,request.vars.email,request.vars.comentario])
)
redirect(URL("{}#comentarios".format(request.function)))
redirect(URL(request.function))
response.flash = 'form has errors'
elif form.errors:
response.flash = 'form has errors'
return dict(vendor=vendor,form=form,form2=form2,comentarios=comentarios)
def index():
form=FORM(TABLE(
TR("Your personal email:",INPUT(_type="text",_name="email",requires=IS_EMAIL())),
TR("Paste your schedule here",TEXTAREA(_name="schedule_text", requires=IS_NOT_EMPTY())),
TR("",INPUT(_type="submit",_value="SUBMIT"))))
if form.accepts(request,session):
mail = Mail()
mail.settings.server = 'smtp.gmail.com:25'
mail.settings.sender = '*****@*****.**'
mail.settings.login = '******'
mail.settings.tls = False
session.email = form.vars.email
session.raw_schedule = form.vars.schedule_text
#redirect(URL('second'))
#Here is where we process the raw form data and create a vobject ical object
ical_text = process_raw_schedule(session.raw_schedule)
#start_date = datetime.strptime(dt, "%b %d, %Y")
outfile = StringIO.StringIO(ical_text)
#return dict(result="success", email=session.user_email, raw_schedule=session.raw_schedule, ical_text=ical_text)
#return ical_text
mail.send(session.email,
'Message subject',
'<html>hi man</html>',
attachments = mail.Attachment(outfile, 'schedule.ics'))
session.ical_text = ical_text
#redirect('/baystreet/schedule/schedule_file.ics')
return dict(message="hmm", email=session.email, form=form, schedule_text=ical_text)
# return dict(email=session.user_email, text=session.schedule_text)
return dict(form=form)
def send_email_task(to, subject, message):
debug_t('Sending email now from within the scheduler!')
if True: # Use sendmail
SENDMAIL = "/usr/sbin/sendmail" # sendmail location
import os
p = os.popen("%s -t" % SENDMAIL, "w")
p.write("To: " + email_address + "\n")
p.write("Subject: " + subject + "\n")
p.write("\n") # blank line separating headers from body
p.write(message)
p.write("\n")
status = p.close()
if status != 0:
#print "Sendmail exit status", sts
pass
else: # Use gmail
from gluon.tools import Mail
mail = Mail()
mail.settings.server = 'smtp.gmail.com:587'
mail.settings.sender = '*****@*****.**'
mail.settings.login = '******'
mail.send(to, subject, message)
debug_t('Sent!')
def user():
"""
exposes:
http://..../[app]/default/user/login
http://..../[app]/default/user/logout
http://..../[app]/default/user/register
http://..../[app]/default/user/profile
http://..../[app]/default/user/retrieve_password
http://..../[app]/default/user/change_password
http://..../[app]/default/user/manage_users (requires membership in
use @auth.requires_login()
@auth.requires_membership('group name')
@auth.requires_permission('read','table name',record_id)
to decorate functions that need access control
"""
message = None
if request.env.http_referrer:
auth.settings.login_next = redirect(request.env.http_referrer)
from gluon.tools import Mail
form = auth()
if request.args(0) == 'register':
if form.accepts(request.vars, session):
try:
mail = Mail()
mail.settings.server = EMAIL_SERVER + ":25"
mail.settings.sender = EMAIL_SENDER
mail.send(
to=[EMAIL_SENDER],
subject="Registration for approval",
message=
'Registration requires approval. New user email is %(email)s. Click on link to view pending requests: http://bundjalung.dalang.com.au/appadmin/update/db/auth_user/registration_key/pending'
% {'email': form.vars.email})
system.flash = T(
"Your registration is being held for approval")
EMAIL_RECIPIENT = "%(email)s" % {'email': form.vars.email}
mail.send(
to=[EMAIL_RECIPIENT],
subject="Language Registration being held for approval",
message=
"Registration for language site. Your registration is being held for approval"
)
except:
session.flash = T("Mail being held for approval")
redirect(URL(r=request, c='plugin_wiki', f='index'))
db.auth_user[form.vars.id] = dict(registration_key='pending')
else:
session.flash = T(
"Error in your entry eg Password and confirm Password must match"
)
form = auth.register()
elif request.args(0) == 'login':
if request.env.http_referrer:
auth.settings.login_next = redirect(request.env.http_referrer)
return dict(form=auth.login())
else:
if request.env.http_referrer:
auth.settings.login_next = redirect(request.env.http_referrer)
return dict(form=form, message=message)
def __init__(self, config):
Mail.__init__(self)
self.settings.server = config.mail.server
self.settings.sender = config.mail.sender
self.settings.login = config.mail.login
# by default give a view/generic.extension to all actions from localhost
# none otherwise. a pattern can be 'controller/function.extension'
response.generic_patterns = ['*'] if request.is_local else []
#########################################################################
## Here is sample code if you need for
## - email capabilities
## - authentication (registration, login, logout, ... )
## - authorization (role based authorization)
## - services (xml, csv, json, xmlrpc, jsonrpc, amf, rss)
## - crud actions
## (more options discussed in gluon/tools.py)
#########################################################################
from gluon.tools import Mail, Auth, Crud, Service, PluginManager, prettydate
mail = Mail() # mailer
auth = Auth(db) # authentication/authorization
crud = Crud(db) # for CRUD helpers using auth
service = Service() # for json, xml, jsonrpc, xmlrpc, amfrpc
plugins = PluginManager() # for configuring plugins
mail.settings.server = 'logging' or 'smtp.gmail.com:587' # your SMTP server
mail.settings.sender = '*****@*****.**' # your email
mail.settings.login = '******' # your credentials or None
auth.settings.hmac_key = '<your secret key>' # before define_tables()
auth.define_tables() # creates all needed tables
auth.settings.mailer = mail # for user email verification
auth.settings.registration_requires_verification = False
auth.settings.registration_requires_approval = False
auth.messages.verify_email = 'Click on the link http://'+request.env.http_host+URL('default','user',args=['verify_email'])+'/%(key)s to verify your email'
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import os
import time
import stat
import datetime
from gluon.utils import md5_hash
from gluon.restricted import RestrictedError
from gluon.tools import Mail
path = os.path.join(request.folder, 'errors')
hashes = {}
mail = Mail()
### CONFIGURE HERE
SLEEP_MINUTES = 5
ALLOW_DUPLICATES = True
mail.settings.server = 'localhost:25'
mail.settings.sender = 'you@localhost'
administrator_email = 'you@localhost'
### END CONFIGURATION
while 1:
for file in os.listdir(path):
filename = os.path.join(path, file)
if not ALLOW_DUPLICATES:
file_data = open(filename, 'r').read()
db = DAL(settings.database_uri,
pool_size=10,
check_reserved=['all'],
migrate_enabled=settings.migrate,
decode_credentials=True,
db_codec='UTF-8')
response.generic_patterns = ['*']
from gluon.tools import Auth, Mail
auth = Auth(db, hmac_key=settings.security_key)
mail = Mail()
mail.settings.server = settings.email_server
mail.settings.sender = settings.email_sender
mail.settings.login = settings.email_login
from datetime import datetime
from fs.osfs import OSFS
osFileServer = OSFS(settings.home_dir)
## Google Api Key
GOOGLE_API_KEY = "AIzaSyBFA3zO-fDW6iVg11fMqf6MANE4AwB1xRU"
GCM_SEND_HOST = "android.googleapis.com"
GCM_SEND_URL = "/gcm/send"
extra_fields += site_handles extra_fields += all_last_retrieved auth.settings.extra_fields["auth_user"] = extra_fields auth.define_tables(username=False, signature=False) ## configure email # Normal mails go through [email protected] mail = auth.settings.mailer mail.settings.server = current.smtp_server mail.settings.sender = "Team StopStalk <" + current.sender_mail + ">" mail.settings.login = current.sender_mail + ":" + current.sender_password # Bulk emails go through [email protected] bulkmail = Mail() bulkmail.settings.server = current.bulk_smtp_server bulkmail.settings.sender = "Team StopStalk <" + current.bulk_sender_mail + ">" bulkmail.settings.login = current.bulk_sender_mail + ":" + current.bulk_sender_password # ----------------------------------------------------------------------------- def send_mail(to, subject, message, mail_type, bulk=False): """ Email sending helper wrapper around Web2Py Mailer @param to (String): Recipient of the mail @param subject (String): Subject of the mail @param message (String): Message body of the mail @param mail_type (String): Mail type (used for handling subscriptions) @param bulk (Boolean): Bulk sending mail """
import sys, nltk, re, pprint # NLTK and related modules -- are these all needed?
#from nltk.tokenize.punkt import PunktSentenceTokenizer
from gluon.tools import *
#need python-gdate in fdora 16
#from gdata.calendar import service, data
import logging
logger = logging.getLogger("web2py.app.Bundjalung")
logger.setLevel(logging.DEBUG)
auth = Auth(db)
mail = Mail()
mail = auth.settings.mailer
mail.settings.server = EMAIL_SERVER
mail.settings.sender = EMAIL_SENDER
mail.settings.login = EMAIL_AUTH
mail.settings.tls = False
auth.settings.mailer = mail
service = Service()
plugins = PluginManager()
## configure auth policy
##auth.settings.registration_requires_verification = True
auth.settings.registration_requires_approval = True
auth.settings.reset_password_requires_verification = True
from gluon.contrib.memcache import MemcacheClient
cache.memcache = MemcacheClient(request,
[settings.get_base_session_memcache()])
from gluon.contrib.memdb import MEMDB
session.connect(request, response, db=MEMDB(cache.memcache))
#else:
## Default to filesystem
# pass
####################################################################
# Instantiate Classes from Modules #
# - store instances in current to be accessible from other modules #
####################################################################
from gluon.tools import Mail
current.mail = mail = Mail()
from gluon.storage import Messages
current.messages = messages = Messages(T)
current.ERROR = ERROR = Messages(T)
# Import the S3 Framework
import s3 as s3base # Shortcut for use, primarily, from views
# Set up logger (before any module attempts to use it!)
import s3log
s3log.S3Log.setup()
# Keep top-level scope cleaner by accessing these from s3base
#from s3 import AuthS3, S3Audit, S3Calendar, S3GIS, S3Msg, S3Sync, S3XML
## - email capabilities ## - authentication (registration, login, logout, ... ) ## - authorization (role based authorization) ## - services (xml, csv, json, xmlrpc, jsonrpc, amf, rss) ## - old style crud actions ## (more options discussed in gluon/tools.py) ######################################################################### from gluon.tools import Auth, Crud, Service, PluginManager, prettydate auth = Auth(db) crud, service, plugins = Crud(db), Service(), PluginManager() ## create all tables needed by auth if not custom tables auth.define_tables(username=False, signature=False) from gluon.tools import Mail mail = Mail() mail=Mail() # uncomment this to enable sending email programmatically ## configure email #mail = auth.settings.mailer mail.settings.server ='students.iiit.ac.in:25' mail.settings.sender = '*****@*****.**' mail.settings.login = '******' ## configure auth policy auth.settings.registration_requires_verification = False auth.settings.registration_requires_approval = False auth.settings.reset_password_requires_verification = True ## if you need to use OpenID, Facebook, MySpace, Twitter, Linkedin, etc. ## register with janrain.com, write your domain:api_key in private/janrain.key
from gluon.tools import Mail
mail = Mail()
mail.settings.server = "smtp.gmail.com:587"
mail.settings.sender = '*****@*****.**'
mail.settings.login = '******'
mail.settings.tls = True
'''
validade = db(db.Estoque.Ativo == True).select(db.Produto.ProdutoDescricao, db.Estoque.Lote,
db.Estoque.Validade,
join=db.Produto.on(db.Estoque.ID_Produto == db.Produto.id))
proximoAValidade = []
data = date.fromordinal(hoje.toordinal() + 60)
for produto in validade:
if produto.Estoque.Validade <= data:
proximoAValidade.append({"Produto": produto.Produto.ProdutoDescricao, "Lote": produto.Estoque.Lote})
texto = ""
for x in proximoAValidade:
texto += "{} - {}\n".format(x["Produto"], x["Lote"])
mail.send(to=['*****@*****.**'],
subject='Validade',
message="Os seguintes produtos estão próximos da sua data de validade:\n" + texto)
'''
import time
while True:
rows = db(db.email.status == 'pendente').select()
for row in rows:
if mail.send(to=row.email, subject=row.assunto, message=row.mensagem):
row.update_record(status='enviado')
