def lost_passwd_send(self, email=None):
if not email:
util.redirect("/")
try:
u = UserAcct.by_email_address(email)
import smtplib
import pkg_resources
from email.MIMEText import MIMEText
msg_to = u.email_address
msg_from = "BandRadar Help <*****@*****.**>"
body = pkg_resources.resource_string(__name__,
'templates/user/lost_passwd_email.txt')
body = body % {'password': u.password,
'user_name': u.user_name}
msg = MIMEText(body)
msg['Subject'] = "bandradar.com password reminder"
msg['From'] = msg_from
msg['To'] = msg_to
s = smtplib.SMTP()
s.connect()
s.sendmail(msg_from, [msg_to], msg.as_string())
s.close()
flash("Email sent to %s." % email)
except SQLObjectNotFound:
flash("Email unknown - no email sent.")
util.redirect("/")
def lastfm_artist_update(artist):
artist_info = lastfm.artist_info(artist.name)
artist.img_url = artist_info["img_url"]
artist.tags = artist_info["tags"]
sims_objs = []
sims_names = artist_info["similars"]
for artist_name in sims_names:
try:
sim_artist = Artist.byNameI(artist_name)
except SQLObjectNotFound:
# keep out too-short names
if len(artist_name) < 3:
continue
try:
sim_artist = Artist(name=artist_name, added_by=UserAcct.get(1))
except SQLObjectIntegrityError:
print "trying to add '%s'" % artist_name
hub.rollback()
hub.begin()
# Artists added this way are *not* approved. This keeps them from
# also having sims generated (when they could be non-local bands
# that we really don't care much about.)
# If they have events approved, then of course they are, too.
sims_objs.append(sim_artist)
artist.similars = sims_objs
def edit(self, user_name):
if not (identity.current.user.user_name == user_name
or "admin" in identity.current.groups):
raise identity.IdentityFailure("Not authorized")
try:
u = UserAcct.by_user_name(user_name)
except SQLObjectNotFound:
flash("Invalid username")
util.redirect("/")
return dict(user_name=user_name, user_form=user_form,
form_vals=u)
def validate_python(self, field_dict, state):
if not field_dict['old_pass']:
return
try:
u = UserAcct.by_user_name(field_dict['user_name'])
enc_pass = identity.current_provider.encrypt_password(field_dict['old_pass'])
if enc_pass != u.password:
raise formencode.Invalid("", field_dict, state,
error_dict = {'old_pass':"******"})
except SQLObjectNotFound:
raise formencode.Invalid("", field_dict, state,
error_dict = {'old_pass':'******'})
def showtracked(self, user_name):
try:
u = UserAcct.by_user_name(user_name)
artists = u.artists.orderBy(Artist.q.name)
viewing_self = False
if identity.current.user and identity.current.user.user_name == user_name:
viewing_self = True
except SQLObjectNotFound:
flash("User not found")
util.redirect("/")
return dict(user=u, artists=artists, viewing_self=viewing_self,
artist_list=artist_list)
def save(self, user_name, old_pass, pass1, **kw):
if not (identity.current.user.user_name == user_name
or "admin" in identity.current.groups):
raise identity.IdentityFailure("Not authorized")
try:
u = UserAcct.by_user_name(user_name)
u.set(**u.clean_dict(kw))
# old pw checked by validator, if present
if (old_pass or "admin" in identity.current.groups) and pass1:
# model does hash, not us
u.password = pass1
flash("Saved")
except SQLObjectNotFound:
flash("Error saving changes")
util.redirect("/users/%s" % u.user_name)
def show(self, user_name):
try:
u = UserAcct.by_user_name(user_name)
artists = u.artists.orderBy(Artist.q.name)
venues = u.venues.orderBy(Venue.q.name)
attendances = Attendance.selectBy(user=u)
viewing_self = False
if identity.current.user and identity.current.user.user_name == user_name:
viewing_self = True
except SQLObjectNotFound:
flash("User not found")
util.redirect("/")
return dict(user=u, artists=artists, venues=venues,
attendances=attendances, viewing_self=viewing_self,
description=util.desc_format(u.description))
def record_request(self, visit):
if identity.current.user:
# if we are logged in, watch for the "remember" param, and set the
# cookie if so.
if cherrypy.request.params.pop("remember", None):
vi = VisitIdentity.by_visit_key(visit.key)
vi.expiry = remember(visit)
else:
# if we're not logged in, see if the cookie is there, and log in
try:
saved_key = cherrypy.request.simple_cookie[cookie_name].value
vi = VisitIdentity.by_visit_key(saved_key)
u = UserAcct.get(vi.user_id)
identity.current_provider.validate_identity(u.user_name,
u.password, visit.key)
# must commit or db will forget we logged in, when we
# redirect (rollback) below
hub.commit()
# reload, since now we're logged in
turbogears.redirect(cherrypy.request.path)
except (KeyError, SQLObjectNotFound):
pass
def icalendar(self, user_name):
try:
u = UserAcct.by_user_name(user_name)
except SQLObjectNotFound:
return "User not found."
events = set()
desc = "Event listed by Bandradar.com because you are tracking this %s."
events.update(it.izip(u.events, it.repeat(desc % "event")))
for artist in u.artists:
events.update(it.izip(artist.future_events, it.repeat(desc % "artist")))
for venue in u.venues:
events.update(it.izip(venue.future_events, it.repeat(desc % "venue")))
cal = ical.Calendar()
cal.add('x-wr-calname', "BandRadar: events for %s" % u.user_name)
cal.add('prodid', '-//bandradar//calendar//')
cal.add('version', '1.0')
for event, src in events:
cal_event = ical.Event()
cal_event.add('summary', event.name)
if event.description:
src += "\n\n" + event.description
cal_event.add('description', src)
location = event.venue.name
if event.venue.address:
location += " (" + event.venue.address + ")"
cal_event.add('location', location)
cal_event.add('uid', event.id)
cal_event.add('url', "http://bandradar.com/events/%s" % event.id)
cal_event.add('dtstart', datetime(event.date.year, event.date.month,
event.date.day,21,0,0))
cal_event.add('dtend', datetime(event.date.year, event.date.month,
event.date.day,23,0,0))
cal_event.add('dtstamp', datetime(event.date.year, event.date.month,
event.date.day,21,0,0))
cal.add_component(cal_event)
cherrypy.response.headers['content-type'] = "text/calendar"
return cal.as_string()
def changed_by(row):
if not row.changed_by:
return "Nobody (batch)"
else:
return UserAcct.get(row.changed_by).user_name
def send_email(start, finish):
conn = hub.getConnection()
users_to_email = set()
#
# Gather results for tracked artists. Notify if events added since last update
#
artist_email = {}
results = conn.queryAll(
"""
select u.id, e.name, e.date, v.name
from user_acct u, artist_user_acct au, artist a, artist_event ae, event e, venue v
where
u.event_email is true
and u.id = au.user_acct_id
and a.id = au.artist_id
and a.id = ae.artist_id
and ae.event_id = e.id
and e.venue_id = v.id
and e.created >= '%s'
and e.created < '%s'
and e.date >= CURRENT_DATE
"""
% (start, finish)
)
for user_id, name, date, venue_name in results:
evt_list = artist_email.get(user_id, list())
evt_list.append((unicode(name, "utf-8"), date, unicode(venue_name, "utf-8")))
artist_email[user_id] = evt_list
users_to_email.add(user_id)
#
# Gather results for tracked events. Notify if they're today
#
event_email = {}
results = conn.queryAll(
"""
select e.id, e.name, att.user_id, v.name
from event e, attendance att, venue v
where e.date = CURRENT_DATE
and e.id = att.event_id
and e.venue_id = v.id
"""
)
for event_id, event_name, user_id, venue_name in results:
evt_list = event_email.get(user_id, list())
evt_list.append((unicode(event_name, "utf-8"), venue_name))
event_email[user_id] = evt_list
users_to_email.add(user_id)
# Gather results for tracked venues. Once a week.
# why do this here, instead of having a separate scheduled function called?
# because we want to put both artist and venue notifications in the same email.
venue_email = {}
if finish.isoweekday() == 4:
results = conn.queryAll(
"""
select u.id, e.name, e.date, v.name
from user_acct u, venue v, event e, user_acct_venue uv
where
u.event_email is true
and e.venue_id = v.id
and u.id = uv.user_acct_id
and uv.venue_id = v.id
and e.date >= CURRENT_DATE
order by e.date
"""
)
for user_id, event_name, date, venue_name in results:
venue_dict = venue_email.get(user_id, dict())
venue = venue_dict.get(venue_name, list())
venue.append((unicode(event_name, "utf-8"), date))
venue_dict[venue_name] = venue
venue_email[user_id] = venue_dict
users_to_email.add(user_id)
for id in users_to_email:
import pkg_resources
u = UserAcct.get(id)
event_text = ""
for event_name, venue_name in event_email.get(id, list()):
event_text += u"%s, at %s\n" % (event_name, venue_name)
if event_text:
hdr_txt = "These events you want to go to are TONIGHT!\n\n"
event_text = hdr_txt + event_text + "\n"
artist_text = ""
for event_name, date, venue_name in artist_email.get(id, list()):
artist_text += u"%s, %s at %s\n" % (event_name, date, venue_name)
if artist_text:
hdr_txt = "Newly added shows featuring artists you are tracking:\n\n"
artist_text = hdr_txt + artist_text + "\n"
venue_text = ""
for venue_name, event_list in venue_email.get(id, dict()).iteritems():
venue_text += venue_name + "\n" + ("-" * len(venue_name)) + "\n"
for name, date in event_list:
venue_text += u"%s: %s\n" % (date, name)
venue_text += "\n"
if venue_text:
hdr_txt = "Upcoming shows at the venues you are tracking:\n\n"
venue_text = hdr_txt + venue_text
text = event_text + artist_text + venue_text
user_url = "http://bandradar.com/users/%s" % u.user_name
msg_to = u.email_address
msg_from = "BandRadar Events <*****@*****.**>"
body = pkg_resources.resource_string(__name__, "templates/new_event_email.txt")
body = body % {"text": text, "user_url": user_url}
util.email(msg_to, msg_from, "BandRadar upcoming events", body)
return (len(users_to_email), len(artist_email), len(venue_email))
def validate_python(self, value, state):
rows = UserAcct.select(func.LOWER(UserAcct.q.email_address) == value.lower()).count()
if rows:
raise formencode.Invalid('Sorry, that email exists', value, state)
def validate_python(self, value, state):
try:
user = UserAcct.byNameI(value)
raise formencode.Invalid('Sorry, that username exists', value, state)
except SQLObjectNotFound:
pass
def list(self):
u = UserAcct.select(orderBy=UserAcct.q.created).reversed()
return dict(users=u)
