def seed_show_data():
show1 = Show(venue_id=1,
artist_id=1,
start_time=datetime(2019, 5, 21, 21, 30))
show2 = Show(venue_id=3,
artist_id=2,
start_time=datetime(2019, 6, 15, 23, 0))
show3 = Show(venue_id=3,
artist_id=3,
start_time=datetime(2035, 4, 1, 20, 0))
show4 = Show(venue_id=3,
artist_id=3,
start_time=datetime(2035, 4, 15, 20, 0))
try:
db.session.add(show1)
db.session.add(show2)
db.session.add(show3)
db.session.add(show4)
db.session.commit()
except:
db.session.rollback()
print(sys.exc_info())
finally:
db.session.close()
def create_show_submission():
# validate form
form = ShowForm(request.form)
if not form.validate():
return render_template('forms/new_show.html', form=form)
# create show
error = False
try:
show = Show()
show.venue_id = request.form.get('venue_id', '')
show.artist_id = request.form.get('artist_id', '')
show.start_time = request.form.get('start_time', '')
db.session.add(show)
db.session.commit()
except:
error = True
db.session.rollback()
print(sys.exc_info())
finally:
db.session.close()
if error:
flash('Show could not be listed.')
else:
flash('Show was successfully listed!')
return render_template('pages/home.html')
def create_show_submission():
# called to create new shows in the db, upon submitting new show
# listing form
# DONE: insert form data as a new Show record in the db, instead
artist_id = request.form.get('artist_id', None)
venue_id = request.form.get('venue_id', None)
start_time = request.form.get('start_time', None)
try:
artist = db.session.get(Artist, artist_id)
venue = db.session.get(Venue, venue_id)
show = Show(start_time=start_time)
show.artist = artist
show.venue = venue
db.session.add(show)
db.session.commit()
# on successful db insert, flash success
flash('Show was successfully listed!')
except Exception as e:
print(e)
# DONE: on unsuccessful db insert, flash an error instead.
# see: http://flask.pocoo.org/docs/1.0/patterns/flashing/
flash('An error occurred. Show could not be listed.')
return render_template('pages/home.html')
def create_show_submission():
# called to create new shows in the db, upon submitting new show listing form
error = False
try:
form = ShowForm()
show = Show(
artist_id=form.artist_id.data,
venue_id=form.venue_id.data,
start_time=form.start_time.data
)
show.insert()
#venue = Venue.query.get(show.venue_id)
#venue.upcoming_shows_count += 1
#venue.update()
#artist = Artist.query.get(show.artist_id)
#artist.upcoming_shows_count += 1
#artist.update()
except:
error = True
print(sys.exc_info())
db.session.rollback()
if error:
abort (400)
flash('An error occured')
else:
flash('Show was successfully listed')
# on successful db insert, flash success
return render_template('pages/home.html')
def create_show_submission():
# called to create new shows in the db, upon submitting new show listing form
# TODO: insert form data as a new Show record in the db, instead
try:
venue_id = request.form.get('venue_id')
artist_id = request.form.get('artist_id')
start_time = request.form.get('start_time')
busy_time = BusyTime.query.filter(artist_id == artist_id).filter(start_time > BusyTime.end_date and start_time < BusyTime.end_date)
if busy_time is not None:
raise (Exception)
flash("The Artitst is busy at "+ start_time.strftime('%Y-%m-%d %H:%M:%S'))
show = Show(venue_id=venue_id, artist_id=artist_id,
start_time=start_time)
venue = Venue.query.get(venue_id)
artist = Artist.query.get(artist_id)
show.venue = venue
show.artist = artist
db.session.add(show)
db.session.commit()
# on successful db insert, flash success
flash('Show was successfully listed!')
except Exception:
flash("The Artitst is busy at "+ start_time)
except:
db.session.rollback()
print(sys.exc_info())
# TODO: on unsuccessful db insert, flash an error instead.
flash('An error occurred. Show could not be listed.')
finally:
db.session.close()
return render_template('pages/home.html')
def create_show_submission():
# called to create new shows in the db, upon submitting new show listing form
# TODO: insert form data as a new Show record in the db, instead
new_show = Show(start_time=request.form['start_time'],
artist_id=request.form['artist_id'],
venue_id=request.form['venue_id'])
if not new_show.valid_time():
flash('Sorry, the artist is not available on this time!')
return redirect(url_for('create_shows'))
else:
try:
db.session.add(new_show)
db.session.commit()
# on successful db insert, flash success
flash('Show was successfully listed!')
except:
# TODO: on unsuccessful db insert, flash an error instead.
# e.g., flash('An error occurred. Show could not be listed.')
# see: http://flask.pocoo.org/docs/1.0/patterns/flashing/
db.session.rollback()
flash(sys.exc_info())
return redirect(url_for('create_shows'))
finally:
db.session.close()
return render_template('pages/home.html')
def create_show_submission():
error = False
try:
data = request.form
show = Show()
show.venue_id = data['venue_id']
show.artist_id = data['artist_id']
show.start_time = data['start_time']
db.session.add(show)
db.session.commit()
except:
db.session.rollback()
error = True
print(sys.exc_info())
finally:
db.session.close()
if error:
flash('ERROR: Show could not be listed!')
else:
flash('Show successfully listed!')
return render_template('pages/home.html')
def create_show_submission():
# called to create new shows in the db, upon submitting new show listing form
# DONE: insert form data as a new Show record in the db, instead
try:
new_data = ShowForm(request.form)
show = Show(
artist_id=new_data.artist_id.data,
venue_id=new_data.venue_id.data,
start_time=new_data.start_time.data
)
if not show.isDuplicate():
db.session.add(show)
db.session.commit()
# on successful db insert, flash success
flash('Show was successfully listed!')
else:
flash('Show was not inserted since it is already listed!')
except:
db.session.rollback()
# DONE: on unsuccessful db insert, flash an error instead.
flash('An error occurred. Show could not be listed.')
finally:
db.session.close()
return render_template('pages/home.html')
def create_show_submission():
""" The function create new show with venue id,artist id and start time
filled into Show Form and insert new show to database
Returns:
Render Home Page with flash for successed or faild
"""
Show_form = ShowForm(request.form)
Valid_Artist_Id = Artist.query.get(Show_form.artist_id.data)
Valid_Venue_Id = Venue.query.get(Show_form.venue_id.data)
if(Valid_Venue_Id==None or Valid_Artist_Id==None):
flash('Venue or Artist not found. Show could not be listed.')
return render_template('pages/home.html')
try:
New_Show = Show()
New_Show.venue_id = Show_form.venue_id.data
New_Show.artist_id = Show_form.artist_id.data
New_Show.start_time = Show_form.start_time.data
db.session.add(New_Show)
db.session.commit()
flash('Show was successfully listed!')
except:
db.session.rollback()
flash('An error occurred. Show could not be listed.')
finally:
db.session.close()
return render_template('pages/home.html')
def create_show_submission():
# called to create new shows in the db, upon submitting new show listing form
# TODO: insert form data as a new Show record in the db, instead
try:
# from form
artist_id = request.form['artist_id']
venue_id = request.form['venue_id']
start_time = request.form['start_time']
# create a new show
show = Show()
show.venue_id = venue_id
show.artist_id = artist_id
show.start_time = start_time
# add show to db
db.session.add(show)
db.session.commit()
flash('Show was successfully listed!')
# exception handler
except:
db.session.rollback()
flash('An error occurred. Show could not be listed.')
# close session
finally:
db.session.close()
# TODO: on unsuccessful db insert, flash an error instead.
# e.g., flash('An error occurred. Show could not be listed.')
# see: http://flask.pocoo.org/docs/1.0/patterns/flashing/
return render_template('pages/home.html')
def load_schedule():
# http://flask.pocoo.org/docs/0.11/patterns/fileuploads/
# https://gist.github.com/DazWorrall/1779861
schedule_file = request.files.get('schedule')
if not schedule_file:
raise InvalidUsage('Schedule file not provided')
filename = secure_filename(schedule_file.filename)
filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
schedule_file.save(filepath)
with open(filepath) as schedule_upload:
try:
schedule_json = json.load(schedule_upload)
except Exception as ex:
raise InvalidUsage('Invalid JSON: {}'.format(ex))
for idx, schedule_item in enumerate(schedule_json):
show = Show(**schedule_item)
missing_columns = show.missing_columns()
if not missing_columns:
db.session.add(show)
else:
raise InvalidUsage('Missing `{}` for schedule index {}'.format(missing_columns, idx))
db.session.commit()
return 'OK'
def create_show_submission():
# called to create new shows in the db, upon submitting new show listing form
try:
venue_id = request.form['venue_id']
artist_id = request.form['artist_id']
start_time = request.form['start_time']
venue = Venue.query.filter_by(id=venue_id)[0]
artist = Artist.query.filter_by(id=artist_id)[0]
show = Show(venue_id=venue_id,
artist_id=artist_id,
start_time=start_time)
show.venue = venue
show.artist = artist
db.session.add(venue)
db.session.add(artist)
db.session.commit()
# on successful db insert, flash success
flash('Show was successfully listed!')
except SQLAlchemyError as e:
db.session.rollback()
flash(e)
finally:
db.session.close()
return render_template('pages/home.html')
def load_schedule():
# http://flask.pocoo.org/docs/0.11/patterns/fileuploads/
# https://gist.github.com/DazWorrall/1779861
schedule_file = request.files.get('schedule')
if not schedule_file:
raise InvalidUsage('Schedule file not provided')
filename = secure_filename(schedule_file.filename)
filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
schedule_file.save(filepath)
with open(filepath) as schedule_upload:
try:
schedule_json = json.load(schedule_upload)
except Exception as ex:
raise InvalidUsage('Invalid JSON: {}'.format(ex))
for idx, schedule_item in enumerate(schedule_json):
show = Show(**schedule_item)
missing_columns = show.missing_columns()
if not missing_columns:
db.session.add(show)
else:
raise InvalidUsage('Missing `{}` for schedule index {}'.format(
missing_columns, idx))
db.session.commit()
return 'OK'
def show_artist(artist_id):
# Shows the artist page with the given artist_id
artist = Artist.query.filter_by(id=artist_id).first_or_404()
past_shows = db.session.query(Venue, Show).join(Show).join(Artist). \
filter(
Show.artist_id == artist_id,
Show.venue_id == Venue.id,
Show.start_time < datetime.now()
). \
all()
upcoming_shows = db.session.query(Venue, Show).join(Show).join(Artist). \
filter(
Show.artist_id == artist_id,
Show.venue_id == Venue.id,
Show.start_time > datetime.now()
). \
all()
data = Artist.detail(artist)
data.update({
'past_shows': [Show.venue_detail(show) for venue, show in past_shows],
'upcoming_shows':
[Show.venue_detail(show) for venue, show in upcoming_shows],
'past_shows_count':
len(past_shows),
'upcoming_shows_count':
len(upcoming_shows)
})
return render_template('pages/show_artist.html', artist=data)
def db_cleanup():
# Movie cleanup
aprint('Cleaning up movies...', 'NOTIFICATOR')
movies = Movie.select().order_by(Movie.title)
n_movies = len(movies)
for movie in movies:
deletion = Movie.delete().where(Movie.imdb == movie.imdb,
Movie.quality == movie.quality)
deletion.execute()
aprint('Deleted {} movies.'.format(n_movies), 'NOTIFICATOR')
# TV cleanup
aprint('Cleaning up tv shows...', 'NOTIFICATOR')
episodes = Show.select().order_by(Show.series).order_by(
Show.season).order_by(Show.episode)
n_episodes = len(episodes)
for episode in episodes:
deletion = Show.delete().where(Show.series == episode.series,
Show.season == episode.season,
Show.episode == episode.episode)
deletion.execute()
aprint('Deleted {} episodes.'.format(n_episodes), 'NOTIFICATOR')
# Tracks cleanup
aprint('Cleaning up tracks...', 'NOTIFICATOR')
tracks = Track.select().order_by(Track.artist).order_by(Track.tracknumber)
n_tracks = len(tracks)
for track in tracks:
deletion = Track.delete().where(Track.artist == track.artist,
Track.title == track.title,
Track.tracknumber == track.tracknumber,
Track.quality == track.quality)
deletion.execute()
aprint('Deleted {} tracks.'.format(n_tracks), 'NOTIFICATOR')
def save_show(choice='new', **kwargs):
# Convert to boolean
kwargs['use_season_folders'] = 'use_season_folders' in kwargs
# Download serie info from tvdb
url = 'http://thetvdb.com/api/{api_key}/series/{id}/'
r = requests.get(url.format(id=kwargs['tvdb_id'], api_key=models.API_KEY))
t = et.fromstring(r.content)
show = {i.tag.lower(): i.text for i in t.find('Series')}
# Only create show in db if it doesn't exist
shows = Show.select().where(Show.tvdb_id == kwargs['tvdb_id'])
if shows.count() == 0:
s = Show.create(**dict(kwargs.items() + show.items()))
else:
s = list(shows)[0]
# Only use valid keys
showdata = dict(kwargs.items() + show.items()).items()
d = {k: v for k, v in showdata if k in Show._meta.fields.keys()}
d['tvdb_id'] = d['id']
del d['id']
d['date_last_updated'] = datetime.datetime.now()
s.update(**d).execute()
s.save_episodes('download_new_only' in kwargs, 'skip_specials' in kwargs)
# Mark episodes as downloaded if they exist
if choice == 'existing':
s.check_download_status()
return s.id
def save_show(choice='new', **kwargs):
# Convert to boolean
kwargs['use_season_folders'] = 'use_season_folders' in kwargs
# Download serie info from tvdb
url = 'http://thetvdb.com/api/{api_key}/series/{id}/'
r = requests.get(url.format(id=kwargs['tvdb_id'], api_key=models.API_KEY))
t = et.fromstring(r.content)
show = {i.tag.lower(): i.text for i in t.find('Series')}
# Only create show in db if it doesn't exist
shows = Show.select().where(Show.tvdb_id == kwargs['tvdb_id'])
if shows.count() == 0:
s = Show.create(**dict(kwargs.items() + show.items()))
else:
s = list(shows)[0]
# Only use valid keys
showdata = dict(kwargs.items() + show.items()).items()
d = {k: v for k, v in showdata if k in Show._meta.fields.keys()}
d['tvdb_id'] = d['id']
del d['id']
d['date_last_updated'] = datetime.datetime.now()
s.update(**d).execute()
s.save_episodes('download_new_only' in kwargs, 'skip_specials' in kwargs)
# Mark episodes as downloaded if they exist
if choice == 'existing':
s.check_download_status()
return s.id
def create_show_submission():
try:
show = Show()
form = ShowForm(request.form)
show = populateObjectFromForm(show, form)
if (show.end_time == None):
print("Info: No end time submitted - adding default")
show.end_time = show.start_time + default_booking_slot_duration
print("end time: ", show.end_time)
if not isShowWithinArtistAvailibility(show):
raise ArtistUnavailable
db.session.add(show)
db.session.commit()
flash('Show was successfully listed!')
except ArtistUnavailable:
db.session.rollback()
flash(
'An error occurred. Artist is not available during requested booking slot. Show could not be listed.'
)
except:
print(sys.exc_info())
db.session.rollback()
flash('An error occurred. Show could not be listed.')
finally:
db.session.close()
return redirect(url_for('index'))
def show_artist(artist_id):
# shows the artist page with the given artist_id
# TODO: replace with real Artist data from the Artist table, using artist_id
artist_details = {}
try:
artist_query = Artist.query.get(artist_id)
if artist_query:
artist_details = Artist.details(artist_query)
current_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
show_query = Show.query.options(db.joinedload(
Show.Artist)).filter(Show.artist_id == artist_id)
upcoming_show_list = list(
map(Show.artist_details(),
show_query.filter(Show.date_time > current_time).all()))
past_show_list = list(
map(Show.artist_details(),
show_query.filter(Show.date_time <= current_time).all()))
artist_details["upcoming_shows"] = upcoming_show_list
artist_details["upcoming_shows_count"] = len(upcoming_show_list)
artist_details["past_shows"] = past_show_list
artist_details["past_shows_count"] = len(past_show_list)
except:
db.session.rollback()
finally:
db.session.close()
if artist_details:
return render_template('pages/show_artist.html',
artist=artist_details)
else:
return render_template('errors/404.html')
def show_venue(venue_id):
current_time = get_current_time()
error = False
body = {}
try:
venue = Venue.query.get(venue_id)
upcoming_shows = venue.shows.filter(
Show.start_time > current_time).all()
past_shows = venue.shows.filter(Show.start_time < current_time).all()
upcoming_shows_data = []
past_shows_data = []
for show in upcoming_shows:
artist_details = Show.get_artist_details(show, format_datetime)
upcoming_shows_data.append(artist_details)
for show in past_shows:
artist_details = Show.get_artist_details(show, format_datetime)
past_shows_data.append(artist_details)
body = Venue.get_full_details(venue)
body['past_shows'] = past_shows_data
body['upcoming_shows'] = upcoming_shows_data
body['past_shows_count'] = len(past_shows)
body['upcoming_shows_count'] = len(upcoming_shows)
except:
error = True
print(sys.exc_info())
if error:
not_found_error()
else:
return render_template('pages/show_venue.html', venue=body)
def create_show_submission():
# called to create new shows in the db, upon submitting new show listing form
# TODO: insert form data as a new Show record in the db, instead
error = False
try:
show = Show()
show.start_time = request.form['start_time']
venue = Venue.query.filter_by(id=request.form['venue_id']).first()
venue.shows.append(show)
artist = Artist.query.filter_by(id=request.form['artist_id']).first()
artist.shows.append(show)
db.session.commit()
except:
error = True
# TODO: on unsuccessful db insert, flash an error instead.
flash('An error occurred. Show could not be listed.')
db.session.rollback()
print(sys.exc_info())
finally:
db.session.close()
# on successful db insert, flash success
if not error:
flash('Show was successfully listed!')
return render_template('pages/home.html')
def show_venue(venue_id):
# Shows the venue page with the given venue_id
venue = Venue.query.filter_by(id=venue_id).first_or_404()
past_shows = db.session.query(Artist, Show).join(Show).join(Venue). \
filter(
Show.venue_id == venue_id,
Show.artist_id == Artist.id,
Show.start_time < datetime.now()
). \
all()
upcoming_shows = db.session.query(Artist, Show).join(Show).join(Venue). \
filter(
Show.venue_id == venue_id,
Show.artist_id == Artist.id,
Show.start_time > datetime.now()
). \
all()
data = Venue.detail(venue)
data.update({
'past_shows':
[Show.artist_detail(show) for artist, show in past_shows],
'upcoming_shows':
[Show.artist_detail(show) for artist, show in upcoming_shows],
'past_shows_count':
len(past_shows),
'upcoming_shows_count':
len(upcoming_shows)
})
return render_template('pages/show_venue.html', venue=data)
def new_neighbor_report(bot, update, created_user):
"""Send message for users who enabled notifications"""
log.info(log_msg(update))
# query for users who set notifications as _notify_house
query_params = Show.select(Show.user_id).where(Show.notification_mode == '_notify_house')
query_users = Own.select(Own.user).where(Own.house == created_user.house)
query = query_params & query_users
# prevent telegram blocking spam
for i, user in enumerate(query):
if i % 29 == 0:
time.sleep(1)
try:
bot.sendMessage(chat_id=user.user_id, parse_mode=ParseMode.HTML,
text=f'Новий сусід\n{created_user.joined_str}')
except BadRequest as err:
bot.sendMessage(chat_id=ADMIN_ID, text=f'failed to send notification for user {user.user_id} {err}',
parse_mode=ParseMode.HTML)
# query for users who set notifications as _notify_section
query_params = Show.select(Show.user_id).where(Show.notification_mode == '_notify_section')
query_users = query_users.where(Own.section == created_user.section)
query = query_params & query_users
for i, user in enumerate(query):
if i % 29 == 0:
time.sleep(1)
try:
bot.sendMessage(chat_id=user.user_id, parse_mode=ParseMode.HTML,
text=f'Новий сусід\n{created_user.joined_str}')
except BadRequest as err:
bot.sendMessage(chat_id=ADMIN_ID, text=f'failed to send notification for user {user.user_id} {err}',
parse_mode=ParseMode.HTML)
def create_show_submission():
error = False
try:
venue_id = request.form['venue_id']
artist_id = request.form['artist_id']
start_time = request.form['start_time']
show = Show(venue_id=venue_id,
artist_id=artist_id,
start_time=start_time)
venue = Venue.query.get(venue_id)
artist = Artist.query.get(artist_id)
show.venue = venue
show.artist = artist
db.session.add(show)
db.session.commit()
except:
error = True
db.session.rollback()
print(sys.exc_info())
finally:
db.session.close()
if not error:
# on successful db insert, flash success
flash('Show was successfully listed!')
return render_template('pages/home.html')
else:
flash('An error occurred. Show could not be listed.')
abort(500)
def create_database(destroy_existing=False):
""" Create db and tables if it doesn't exist """
if not os.path.exists(DB_NAME):
logger.info('Create database: {0}'.format(DB_NAME))
open(DB_NAME, 'a').close()
Show.create_table()
Episode.create_table()
Setting.create_table()
def create_database(destroy_existing=False):
""" Create db and tables if it doesn't exist """
if not os.path.exists(DB_NAME):
logger.info('Create database: {0}'.format(DB_NAME))
open(DB_NAME, 'a').close()
Show.create_table()
Episode.create_table()
Setting.create_table()
def create_show(session, orga, name="show1"):
show = Show(orga)
show.medium_name = name
show.long_name = name
show.station_id = 1
session.add(show)
session.commit()
time.sleep(config.SPI_GENERATION_INTERVAL * 3)
return show
def create_show(session, orga, name="show1"):
show = Show(orga)
show.medium_name = name
show.long_name = name
show.station_id = 1
session.add(show)
session.commit()
time.sleep(config.SPI_GENERATION_INTERVAL * 3)
return show
def add (request, date_str):
try:
date_object = datetime.strptime(date_str)
show = Show(date=date_object)
show.save()
return HttpResponse(show.id)
except e:
print e
return HttpResponse("ERR")
def addShowsData():
shows = Show.query.all()
# only load data if db is empty
if (not len(shows)):
for defaultShow in shows_default_data:
show = Show()
show.venue_id = defaultShow['venue_id']
show.artist_id = defaultShow['artist_id']
show.start_time = defaultShow['start_time']
db.session.add(show)
db.session.commit()
def create_show_submission():
try:
new_show = Show(venue_id=request.form['venue_id'],
artist_id=request.form['artist_id'],
start_time=request.form['start_time'])
Show.insert(new_show)
# on successful db insert, flash success
flash('Show was successfully listed!')
except SQLAlchemyError as e:
flash('An error occurred. Show could not be listed.')
return render_template('pages/home.html')
def test_add_playlist_to_show(self):
with gillard.app.app_context():
playlist = Playlist()
show = Show('TESTID','TESTPW')
show.playlists = [playlist]
show = test_utils.save_and_refresh(gillard.db.session, show)
assert len(show.playlists) == 1
# cascading add
assert show.playlists[0].id is not None
def delete_show(show_id):
show = Show(id=show_id)
try:
show.delete()
response = jsonify(type="success")
response.status_code = 200
return response
except Exception as ex:
_message = 'An error occurred. ' + ex.args[0]
response = jsonify(type="error", message=_message)
response.status_code = 522 #custom server error code
return response
def create_tables():
auth.User.create_table(fail_silently=True)
Users.create_table(fail_silently=True)
Role.create_table(fail_silently=True)
Category.create_table(fail_silently=True)
Product.create_table(fail_silently=True)
Period.create_table(fail_silently=True)
Order_detail.create_table(fail_silently=True)
Address.create_table(fail_silently=True)
Show.create_table(fail_silently=True)
UserRoles.create_table(fail_silently=True)
Configure.create_table(fail_silently=True)
WinRecord.create_table(fail_silently=True)
def create_show_submission():
show_form = ShowForm(request.form)
try:
show = Show(artist_id=show_form.artist_id.data,
venue_id=show_form.venue_id.data,
start_time=show_form.start_time.data)
show.add()
# on successful db insert, flash success
flash('Show was successfully listed!')
except Exception as e:
flash('An error occurred. Show could not be listed.')
return render_template('pages/home.html')
def test_get_show_far_in_future(self):
make_current = lambda t: timezone.make_aware(
t, timezone.get_current_timezone())
for x in xrange(2):
# these functions do different things depending on if shows already
# exist, but there should be no visible difference between the
# results of these different things
ours = Show.at(make_current(datetime.datetime(3000, 1, 1)))
self.assertEqual(Show.objects.all().count(), 1)
self.assertEqual(ours.end.date(), datetime.date(3000, 1, 4))
for x in xrange(2):
ours = Show.at(make_current(datetime.datetime(3010, 1, 1)))
self.assertEqual(Show.objects.all().count(), 523)
self.assertEqual(ours.end.date(), datetime.date(3010, 1, 6))
def test_make_show(self, wipe=True):
# this may seem overly thorough, but it has already found bugs that
# would otherwise have been missed:
for hours in xrange(366*24, 0, -1):
if wipe:
Show.objects.all().delete()
starter = (
timezone.now().replace(tzinfo=timezone.get_current_timezone())
-
datetime.timedelta(hours=hours)
)
show = Show.at(starter)
showtime = show.showtime.astimezone(
timezone.get_current_timezone())
self.assertEqual(showtime.hour, 21)
self.assertEqual(showtime.minute, 0)
self.assertEqual(showtime.second, 0)
self.assertEqual(showtime.microsecond, 0)
self.assertEqual(showtime.weekday(), 5)
self.assertEqual(show.end - show.showtime,
datetime.timedelta(hours=2))
self.assertGreater(show.end, starter)
def scrape_all(venue):
for show in venue.scrape():
if Show.query(Show.url == show.get('url'), Show.date == show.get('date')).fetch():
# import pdb; pdb.set_trace()
continue
new_show = Show(
venue = show.get('venue'),
title = show.get('title'),
description = show.get('description'),
date = show.get('date'),
times = show.get('times'),
prices = show.get('prices'),
price_descriptions = show.get('price_descriptions'),
url = show.get('url')
)
new_show.put()
def get(self, show_id=None):
# If a show was specified
if show_id:
show = ndb.Key(Show, int(show_id)).get()
context = {'show': show}
else:
tomorrow_start = get_tomorrow_start()
# Get the future shows
future_shows = Show.query(
Show.scheduled > tomorrow_start).order(Show.scheduled).filter()
# Get the previous shows
previous_shows = Show.query(
Show.end_time != None).order(
-Show.end_time).filter()
context = {'future_shows': future_shows,
'previous_shows': previous_shows}
self.response.out.write(template.render(self.path('other_shows.html'),
self.add_context(context)))
def process_check_new_episodes():
res = []
# Only check after 24 hours
yesterday = datetime.datetime.now() - datetime.timedelta(1)
shows = Show.select().where(
Show.date_last_updated > yesterday
)
for s in shows:
res.append(save_show(tvdb_id=s.tvdb_id))
return res
def handle_xml(self, shows):
for country in shows:
for i, show in enumerate(country):
showid = get_int(show, "showid")
show_name = get_str(show, "showname")
show, created = Show.get_or_create(title=show_name)
if not show.fully_populated:
taskqueue.add(url=webapp.uri_for(name_prefix+"show_task"),
params={'showid': showid})
if i>12:
break
def handle_xml(self, feed):
episode_list = feed.find("Episodelist")
show_name = get_str(feed, "name")
if episode_list is not None:
show_obj = Show.get_by_title(show_name)
for season in episode_list:
for episode in season:
self._parse_episode(episode, season, show_obj)
show_obj.fully_populate()
def api(**kwargs):
args = []
action = request.args.get('action', '')
def scan_show(show):
return show.check_download_status()
def delete_show(show):
show.delete_instance(recursive=True)
def update_show(show):
return utils.save_show(tvdb_id=show.tvdb_id)
def episode_mark_skipped(episode):
episode.status = models.SKIPPED
episode.save()
def episode_mark_wanted(episode):
episode.status = models.WANTED
episode.save()
def episode_mark_downloaded(episode, location):
episode.status = models.DOWNLOADED
episode.location = location
episode.save()
actions = {
'scan': scan_show,
'delete': delete_show,
'update': update_show,
'episode_mark_wanted': episode_mark_wanted,
'episode_mark_skipped': episode_mark_skipped,
'episode_mark_downloaded': episode_mark_downloaded,
'background_search': utils.process_search_torrent,
'background_download': utils.process_download_torrent,
'background_update': utils.process_check_new_episodes,
'background_status': utils.process_check_downloaded
}
if not action in actions:
msg = 'No action named {}'.format(action)
return jsonify(stat='fail', msg=msg, result=[])
if 'show_id' in request.args:
args.append(Show.get(id=request.args['show_id']))
if 'episode_id' in request.args:
args.append(Episode.get(id=request.args['episode_id']))
if 'location' in request.args:
args.append(request.args['location'])
res = actions[action](*args)
return jsonify(stat='ok', result=res)
def get_show_settings(show_id):
s = Show.get(id=show_id)
c = {
'show': s,
'settings': settings,
'choice': 'saved_show'
}
if request.method == 'POST':
s.folder = request.form['folder']
s.filters = request.form['filters']
s.use_season_folders = 'use_season_folders' in request.form
s.save()
msg = 'Successfully saved settings'
return redirect('/show/{id}/?msg={msg}'.format(id=show_id, msg=msg))
return render_template('show_add.html', **c)
def add_show(self):
status = 'success'
try:
data = cherrypy.request.json
series_id = data['seriesid']
t = tvdb_api.Tvdb()
s = t[series_id]
# db = models.connect()
if cherrypy.request.db.query(Show).filter(Show.show_id == series_id).first() is None:
# save new show to db
first_aired_date = datetime.strptime(s['firstaired'], "%Y-%m-%d")
new_show = Show(show_id=series_id, show_name=s['seriesname'], first_aired=first_aired_date,
is_active=s.data['status'] == 'Continuing', banner=s['banner'])
if new_show.banner == None:
new_show.banner = ''
# create folder based on show name:
new_show.show_directory = '/' + new_show.show_name.replace('.', '').strip()
phys_directory = cherrypy.request.db.query(Config).first().tv_parent_directory + new_show.show_directory
if not os.path.exists(phys_directory):
os.makedirs(phys_directory)
cherrypy.request.db.add(new_show)
cherrypy.request.db.commit()
ActionLog.log('"%s" added.' % new_show.show_name)
Utils.add_episodes(series_id, t, cherrypy.request.db)
else:
status = 'duplicate'
# http://stackoverflow.com/questions/7753073/jquery-ajax-post-to-django-view
except Exception as ex:
# logger.exception(ex)
ActionLog.log(ex)
status = 'error'
return json.dumps(status)
def radioepg_shows_edit(request, id):
"""Edit a show."""
station_id = request.args.get('station_id')
object = None
errors = []
if id != '-':
object = Show.query.filter_by(orga=int(request.args.get('ebuio_orgapk') or request.form.get('ebuio_orgapk')),
id=int(id)).first()
if request.method == 'POST':
if not object:
object = Show(int(request.form.get('ebuio_orgapk')))
object.station_id = station_id
object.medium_name = request.form.get('medium_name')
object.long_name = request.form.get('long_name')
object.description = request.form.get('description')
object.color = request.form.get('color')
# Check errors
if object.medium_name == '':
errors.append("Please set a medium name")
if object.long_name == '':
errors.append("Please set a long name")
if object.description == '':
errors.append("Please set a description")
if object.color == '':
errors.append("Please set a color")
# If no errors, save
if not errors:
if not object.id:
db.session.add(object)
db.session.commit()
return PlugItRedirect('radioepg/shows/?saved=yes')
if object:
object = object.json
colors = [('Red', '#e41a1c'), ('Blue', '#377eb8'), ('Green', '#4daf4a'), ('Magenta', '#984ea3'),
('Orange', '#ff7f00'), ('Yellow', '#ffff33'), ('Brown', '#a65628'), ('Pink', '#f781bf'),
('Gray', '#999999')]
return {'object': object, 'colors': colors, 'errors': errors, 'current_station_id': station_id}
def discover_shows():
result = []
for epguides_name in list_all_epguides_keys_redis():
show = Show(epguides_name)
show.episodes = "{0}show/{1}/".format(app.config['BASE_URL'], epguides_name)
show.next_episode = "{0}show/{1}/next".format(app.config['BASE_URL'], epguides_name)
show.last_episode = "{0}show/{1}/last".format(app.config['BASE_URL'], epguides_name)
show.imdb_url = "http://www.imdb.com/title/{0}".format(show.imdb_id)
show.epguides_url = "http://www.epguides.com/{0}".format(epguides_name)
result.append(show)
return json_response(result)
def _new_show(self, rss_url, publisher, feed):
description = feed.get('description') or feed.get('summary')
image_url = feed.get('image', {}).get('href') \
or feed.get('logo') \
or feed.get('icon')
show_dict = {
'publisher': publisher,
'name': self._sanitize_title(feed.get('title')),
'description': self._sanitize_text(description),
'homepage_url': self._sanitize_url(feed.get('link')),
'image_url': self._sanitize_url(image_url),
'language': self._sanitize_word(feed.get('language'))
}
show_dict = {key: value for key, value in show_dict.iteritems() if value is not None}
show, is_new = Show.get_or_create(rss_url=rss_url, defaults=show_dict)
print('Saved show "{}": new={}'.format(show_dict['name'], is_new))
return show
def handle_xml(self, show):
show_title = get_str(show, "showname")
classification = get_str(show, "classification")
show_obj = Show.get_by_title(show_title)
try:
show_obj.classification = classification
except BadValueError:
logging.critical("!!! classification {}".format(classification))
if classification not in CLASSIFICATION_ONLY:
show_obj.fully_populate()
return
show_obj.country = get_str(show, "origin_country")
try:
show_obj.status = get_str(show, "status")
except BadValueError:
logging.critical("!!! stats {}".format(get_str(show, "status")))
show_obj.summary = get_str(show, "summary") or ""
show_obj.networks = [network.text for network in show.findall("network")]
show_obj.genres = [genre.text for genre in show.find("genres")]
seasons_number = get_int(show, "seasons")
show_obj.runtime = get_int(show, "runtime")
show_obj.started_date = get_date(show, "startdate")
show_obj.ended_date = get_date(show, "ended")
show_obj.put()
taskqueue.add(url=webapp.uri_for(name_prefix+"episodes_list_task"),
params={'showid': self.showid})
def test_show_attrs(self):
with gillard.app.app_context():
show = Show('TESTID', 'TESTPW')
show.title = 'A TEST SHOW TITLE'
show.startDay = 2
show.startHour = 4
show.endDay = 6
show.endHour = 8
show = test_utils.save_and_refresh(gillard.db.session, show)
assert show.display_id == 'TESTID'
assert show.password == 'TESTPW'
assert show.title == 'A TEST SHOW TITLE'
assert show.startDay == 2
assert show.startHour == 4
assert show.endDay == 6
assert show.endHour == 8
def post(self):
deleted = None
unused_deleted = False
show_list = self.request.get_all('show_list')
action_list = self.request.get_all('action_list')
item_list = self.request.get_all('item_list')
character_list = self.request.get_all('character_list')
theme_list = self.request.get_all('theme_list')
delete_unused = self.request.get_all('delete_unused')
# If action(s) were deleted
if action_list:
for action in action_list:
action_entity = ndb.Key(Action, int(action)).get()
# Get all the related action votes and delete them
action_votes = ActionVote.query(ActionVote.action == action_entity.key).fetch()
for av in action_votes:
av.key.delete()
action_entity.key.delete()
deleted = 'Action(s)'
# If theme(s) were deleted
if theme_list:
for theme in theme_list:
theme_entity = ndb.Key(Theme, int(theme)).get()
# Get all the related theme votes and delete them
theme_votes = ThemeVote.query(ThemeVote.theme == theme_entity.key).fetch()
for tv in theme_votes:
tv.key.delete()
theme_entity.key.delete()
deleted = 'Theme(s)'
# If show(s) were deleted
if show_list:
for show in show_list:
show_entity = ndb.Key(Show, int(show)).get()
show_actions = ShowAction.query(ShowAction.show == show_entity.key).fetch()
# Delete the actions that occurred within the show
for show_action in show_actions:
action = show_action.player_action.get().action
if action:
action.delete()
show_action.player_action.delete()
show_action.key.delete()
# Delete player associations to the show
show_players = ShowPlayer.query(ShowPlayer.show == show_entity.key).fetch()
for show_player in show_players:
show_player.key.delete()
# Delete all Role votes
role_votes = RoleVote.query(RoleVote.show == show_entity.key).fetch()
for role_vote in role_votes:
role_vote.key.delete()
# Delete the theme used in the show, if it existed
if show_entity.theme:
show_entity.theme.delete()
show_entity.key.delete()
deleted = 'Show(s)'
# Delete ALL un-used things
if delete_unused:
# Delete Un-used Actions
unused_actions = Action.query(Action.used == False).fetch()
for unused_action in unused_actions:
# Get all the related action votes and delete them
action_votes = ActionVote.query(ActionVote.action == unused_action.key).fetch()
for av in action_votes:
av.key.delete()
# Delete the un-used actions
unused_action.key.delete()
deleted = 'All Un-used Actions'
context = {'deleted': deleted,
'unused_deleted': unused_deleted,
'shows': Show.query().fetch(),
'actions': Action.query(Action.used == False).fetch(),
'themes': Theme.query(Theme.used == False).fetch()}
self.response.out.write(template.render(self.path('delete_tools.html'),
self.add_context(context)))
def func():
show = Show(showtime=showtime, end=end)
show.save()
show.delete()
def get_show(show_id):
c = {
'show': Show.get(id=show_id),
'episodes': Episode.select().join(Show).where(Show.id == show_id)
}
return render_template('show.html', **c)
def process_check_downloaded():
shows = Show.select().join(Episode).where(
Episode.status << [models.FOUND, models.DOWNLOADING],
Episode.firstaired < datetime.datetime.now()
).group_by(Show)
return [s.check_download_status() for s in shows]
from models import Show, MovieClip, Producer
f = open('thrones.xml')
xml = f.read()
s = Show(xml=xml)
s.save()
print s
def index():
return render_template('home.html', shows=list(Show.select()))
from models import Show, MovieClip, Producer s = Show(id=1000) print s.get_xml()
from models import Show, MovieClip, Producer s = Show(id=1000) print "Clip Duration: %s" % (s.total_clip_duration())
def test_calling_next_or_prev_on_only_show_returns_none(self):
self.assertIs(None, Show.current().next())
self.assertIs(None, Show.current().prev())
