def test1112():
"""Series with 1 ep (in a season) and 1 OTO (seasonless)"""
p = Producer(name='Universal')
p.save()
d = Distributor(name='PBS Distribution')
d.save()
se = Season(name='3', ordinal=3)
se.save()
e1 = SeriesEpisode(name="Go West Young Monkey")
e1.seasons = [se,]
e1.save()
e2 = OneTimeOnlyEpisode(name="Curious George XMAS")
e2.save()
s = Series(name="Curious George")
s.onetimeonlys = [e2,]
s.save()
sa = SeasonAssociation(season=se)
sa.series = s
sa.episode = e1
sa.save()
def test1():
"""Franchised, Series, 1 Season, 1 Ep"""
p = Producer(name='BBC Productions')
p.save()
d = Distributor(name='PBS Distribution')
d.save()
ep1 = SeriesEpisode(name="Wolf Hall Ep 1")
ep1.save()
se = Season(name="1", ordinal="1")
se.save()
s = Series(name='Wolf Hall')
s.orgs = [p, d]
s.save()
sa = SeasonAssociation(season=se)
sa.series = s
sa.episode = ep1
sa.season = se
sa.save()
f = Franchise(name='Masterpiece')
f.serieses.append(s)
f.save()
def test3():
"""Franchised, Series, Seasoned, with 1 OTO"""
p = Producer(name='BBC Productions')
p.save()
d = Distributor(name='PBS Distribution')
d.save()
ep1 = SeriesEpisode(name="Scandal in Belgravia")
ep1.save()
se = Season(name="Season 2", ordinal="2")
se.save()
s = Series(name='Sherlock')
s.orgs = [p, d]
s.save()
sa = SeasonAssociation(season=se)
sa.series = s
sa.episode = ep1
sa.season = se
sa.save()
# get the previous
f = session.query(Franchise).filter(Franchise.name=="Masterpiece").all()[0]
f.serieses.append(s)
f.save()
def test7():
"""Series with Subseries and 1 Ep"""
p = Producer(name='WGBH Productions')
p.save()
d = Distributor(name='PBS Distribution')
d.save()
se = Season(name='17', ordinal=17)
se.save()
e1 = SeriesEpisode(name="Antiques Roadshow Seattle, Ep1")
e1.seasons = [se,]
e1.save()
sss = Season(name='1', ordinal=1)
sss.save()
ss1 = SubSeries(name="Antiques Roadshow in Seattle")
ss1.save()
s = Series(name="Antiques Roadshow")
s.subseries = [ss1]
s.seasons = [se,]
s.save()
sa = SeasonAssociation(season=se)
sa.series = s
sa.episode = e1
sa.save()
sa2 = SeasonAssociation(season=sss)
sa2.series = ss1
sa2.episode = e1
sa2.save()
def test4():
"""Franchised series with 1 oto"""
p = Producer(name='Ken Burns')
p.save()
d = Distributor(name='PBS Distribution')
d.save()
ep1 = SeriesEpisode(name="The Scripture of Nature (1851-1890)")
ep1.save()
se = Season(name='Season 2009', ordinal=2009)
se.save()
s = Series(name='The National Parks')
s.orgs = [p, d]
s.save()
sa = SeasonAssociation(season=se)
sa.series = s
sa.episode = ep1
sa.season = se
sa.save()
f = Franchise(name='Ken Burns')
f.serieses = [s]
f.save()
def test10():
"""Series with OTO"""
p = Producer(name='CAPC')
p.save()
d = Distributor(name='PBS Distribution')
d.save()
e1 = OneTimeOnlyEpisode(name="A Capitol Fourth 2014")
e1.save()
s = Series(name="A Capitol Fourth")
s.onetimeonlys = [e1,]
s.save()
def test_tag():
p = Producer(name='BBC Productions')
p.save()
d = Distributor(name='PBS Distribution')
d.save()
ep1 = SeriesEpisode(name="Wolf Hall Ep 1")
ep1.save()
se = Season(name="1", ordinal="1")
se.save()
s = Series(name='Wolf Hall')
s.orgs = [p, d]
s.save()
s2 = Series(name='Wolf Hall Subseries')
s2.orgs = [p, d]
s2.save()
#sept = SeriesEpisodeTag(series=s, episode=s2, tag='subseries')
#sept.save()
sept = SeriesRelationTag(parent=s, child=s2, tag='subseries')
sept.save()
sa = SeasonAssociation(season=se)
sa.series = s
sa.episode = ep1
sa.season = se
sa.save()
def series(request):
sort_key = request.GET.get('sort', DEFAULT_SORT)
sort = VALID_SERIES_SORTS.get(sort_key, DEFAULT_SORT)
if sort == 'rating':
series_all = Series.all_order_by_rating()
else:
series_all = Series.all_ordered_alphabetically()
if 'search_query' in request.GET:
return search_series(request, series_all)
else:
return render_to_response('tvmaniacs/series.html',
{'Series': series_all, 'page_limit': Series.page_limit()},
context_instance=RequestContext(request))
def load_series():
ser = {}
engine = create_engine('sqlite:////u/yipuwang/cs373-idb/flaskapp/data/test.db', echo=True)
# engine = create_engine('postgresql://*****:*****@localhost:5432/testdb', echo=True)
Session = sessionmaker(bind=engine)
session = Session()
for serie in series:
status = 1
if serie["numbered"]:
status = 0
db_format = Series(
title = serie["title"],
num_books = serie["num_books"],
description = serie["description"],
notes = serie["notes"],
status = status,
)
ser[db_format.name] = db_format
session.add(db_format)
for book in series_books:
db_format = Book(
title = book['title'],
isbn = book['isbn'],
image_link = book["img"],)
def search_series(request, series_list):
text = request.GET["search_query"]
found_series = series_list.filter(name__icontains=text)
message = 'Results: ' + str(len(found_series))
return render_to_response('tvmaniacs/series.html',
{'Series': found_series, 'page_limit': Series.page_limit(),
'search_message': message}, context_instance=RequestContext(request))
def setUp(self):
self.engine = create_engine('mysql+pymysql://')
self.session = Session(engine)
Base.metadata.create_all(self.engine)
self.characters_instance = Characters(1009610, "Spider-Man")
self.session.add(self.character_instance)
self.comics_instance = Comics(30885, "Age of Heroes (Trade Paperback)")
self.session.add(self.comics_instance)
self.creators_instance = Creators(9799, "David Baldeon")
self.session.add(self.creators_instance)
self.events_instance = Events(116, "Acts of Vengeance!")
self.session.add(self.events_instance)
self.series_instance = Series(10235, "Age of Heroes (2011)")
self.session.add(self.series_instance)
self.stories_instance = Stories(483, "Interior #483")
self.session.add(self.stories_instance)
self.images_instance = Images(
1, 0, "http://i.annihil.us/u/prod/marvel/i/mg/3/40/4c06c8261544e")
self.session.add(self.images_instance)
self.session.commit()
def series(request):
sort_key = request.GET.get('sort', DEFAULT_SORT)
sort = VALID_SERIES_SORTS.get(sort_key, DEFAULT_SORT)
if sort == 'rating':
series_all = Series.all_order_by_rating()
else:
series_all = Series.all_ordered_alphabetically()
if 'search_query' in request.GET:
return search_series(request, series_all)
else:
return render_to_response('tvmaniacs/series.html', {
'Series': series_all,
'page_limit': Series.page_limit()
},
context_instance=RequestContext(request))
def add_series(name, frequency, columns=[], db=None, config=None):
if db is None:
db = get_mongo_db(config)
if frequency not in FREQUENCIES.keys():
raise ValueError('frequency is not valid')
series = db.series
new_series = {"name": name, "frequency": frequency, "columns": columns, "slices": []}
result = series.insert_one(new_series)
return Series(db, series, result.inserted_id, name, frequency, columns)
def search_series(request, series_list):
text = request.GET["search_query"]
found_series = series_list.filter(name__icontains=text)
message = 'Results: ' + str(len(found_series))
return render_to_response('tvmaniacs/series.html', {
'Series': found_series,
'page_limit': Series.page_limit(),
'search_message': message
},
context_instance=RequestContext(request))
def sav(data):
ep = Episode.objects.all()[0]
series = Series()
series.link = data.get("serieslink")
series.date = convStrToDate(data.get('date'))
series.thumbnail_url = data.get('thumbnail')
series.episode = ep
series.save()
return series
def test2():
"""Franchised, Series, NO Season, 1 OTO"""
p = Producer(name='BBC Productions')
p.save()
d = Distributor(name='PBS Distribution')
d.save()
ep1 = OneTimeOnlyEpisode(name="Downton Abbey 2014 X-mas Special")
ep1.save()
s = Series(name='Downton Abbey')
s.onetimeonlys = [ep1]
s.orgs = [p, d]
s.save()
# get the previous
f = session.query(Franchise).filter(Franchise.name=="Masterpiece").all()[0]
f.serieses.append(s)
f.save()
def add_aim():
form = AimsForm()
error = None
form.groupName.choices = [ (-1, '-- Choose a group from the list --')]
form.groupName.choices.extend([(group.id, group.group_name) for group in Group.query.all()])
form.seriesName.choices = [ (-1, '-- Choose a series from the list --'), (0, '-- Create a new series --')]
form.seriesName.choices.extend([(series.id, series.series_name) for series in Series.query.all()])
if request.method == 'POST' and form.validate():
try:
group = Group.query.get(request.form['groupName'])
seriesId = request.form['seriesName']
series = None
if seriesId == '0':
series = Series(request.form['newSeriesName'], request.form['memoryVerse'])
db.session.add(series)
db.session.commit()
else:
series = Series.query.get(seriesId)
scheduledDate = helpers.next_sunday()
aim = Aim(
group,
series,
what_they_learnt=request.form['whatTheyLearnt'],
lesson_aim=request.form['lessonAim'],
bible_passage=request.form['biblePassage'],
tip1=request.form['tip1'],
tip2=request.form['tip2'],
scheduled_date=scheduledDate
)
db.session.add(aim)
db.session.commit()
flash(Markup('<strong>Success!</strong> Your aim has been submitted and is scheduled to be sent to parents on: <strong>%s</strong>' % scheduledDate.strftime("%A %-d %B %Y")))
return redirect(url_for('show_aims'))
except Exception as err:
error = "Something went wrong {}".format(err)
return render_template('index.html', form=form, error=error)
def test8():
"""Series with EP"""
p = Producer(name='WETA')
p.save()
d = Distributor(name='PBS Distribution')
d.save()
ep1 = SeriesEpisode(name="Monday, July 15th, 2014")
ep1.save()
s = Series(name='PBS NewsHour')
s.orgs = [p, d]
s.save()
se = Season(name='29', ordinal=29)
se.save()
sa2 = SeasonAssociation(season=se)
sa2.series = s
sa2.episode = ep1
sa2.save()
def test5():
"""Series with Ep in one season AND Subseries with Ep in a different season"""
p = Producer(name='WGBH Productions')
p.save()
d = Distributor(name='PBS Distribution')
d.save()
se = Season(name='38', ordinal=38)
se.save()
se1 = Season(name='1', ordinal=1)
se1.save()
e1 = SeriesEpisode(name="Making Stuff Similar Episode")
e1.save()
e2 = SeriesEpisode(name="Making Stuff Similar Episode2")
e2.save()
ss1 = SubSeries(name="Making Stuff")
ss1.save()
s = Series(name="NOVA")
s.subseries = [ss1]
s.save()
sa = SeasonAssociation(season=se)
sa.series = s
sa.episode = e1
sa.save()
sa2 = SeasonAssociation(season=se1)
sa2.series = ss1
sa2.episode = e2
sa2.save()
def create_series(jwt):
data = request.get_json()
error = False
try:
series = Series(name=data["name"], description=data["description"])
isTest = False
if "isTest" in data:
isTest = data["isTest"]
DBHelper.insert(series)
except:
DBHelper.rollback()
error = True
finally:
DBHelper.close()
if error:
abort(404)
return jsonify({"success": True})
def editar_serie(nombre):
data = request.json
serie_id = nombre
series_doc = series_ref.document(serie_id)
if (series_doc.get().exists == False):
error_message = {
"error": f"No existe una serie registrada con el nombre {serie_id}"
}
return jsonify(error_message), 400
try:
serie_info = series_doc.get().to_dict()
if ("descripcion" in data):
descripcion = data["descripcion"]
else:
descripcion = serie_info["descripcion"]
if ("puntuacion" in data):
puntuacion = float(data["puntuacion"])
else:
puntuacion = serie_info["puntuacion"]
if ("vista" in data):
vista = bool(data["vista"])
else:
vista = serie_info["vista"]
if ("link" in data):
link = data["link"]
else:
link = serie_info["link"]
serie_act = Series(nombre, puntuacion, descripcion, vista,
link).to_dict()
series_doc.update(serie_act)
return jsonify(serie_act), 200
except:
error_message = {
"error":
"Los datos de la serie no están completos o son incorrectos",
"status": 400
}
return jsonify(error_message), 400
def get_series(db=None, config=None, id=None):
if db is None:
db = get_mongo_db(config)
if id is not None:
if ObjectId.is_valid(id):
cursor = db.series.find({"_id": ObjectId(id)})
else:
return []
else:
cursor = db.series.find({})
series = [Series(db,
db.series,
series['_id'],
series['name'],
series['frequency'],
series['columns'],
_get_slices(db, config, series['slices']))
for series in cursor]
return series
def test_add_series(self):
newSeries = Series(9021090, "Testing 123", "This is a test Series",
2015, 2018, "http://www.whitehouse.gov/logo.jpg", 1,
8, 289, 4)
db.session.add(newSeries)
db.session.commit()
query = db.session.query(Series).filter_by(id="9021090").first()
self.assertEqual(query.id, 9021090)
self.assertEqual(query.title, "Testing 123")
self.assertEqual(query.desc, "This is a test Series")
self.assertEqual(query.start, 2015)
self.assertEqual(query.end, 2018)
self.assertEqual(query.img, "http://www.whitehouse.gov/logo.jpg")
self.assertEqual(query.num_creators, 1)
self.assertEqual(query.num_characters, 8)
self.assertEqual(query.num_comics, 289)
self.assertEqual(query.num_events, 4)
db.session.delete(newSeries)
db.session.commit()
def test_add_series(self):
with app.app_context():
newSeries = Series(id=9021090, title="Testing 123", desc="This is a test Series",
start=2015, end=2018, img="http://www.whitehouse.gov/logo.jpg", num_creators=1,
num_characters=8, num_comics=289, num_events=4)
db.session.add(newSeries)
db.session.commit()
query = db.session.query(Series).filter_by(id="9021090").first()
self.assertEqual(query.id, 9021090)
self.assertEqual(query.title, "Testing 123")
self.assertEqual(query.desc, "This is a test Series")
self.assertEqual(query.start, 2015)
self.assertEqual(query.end, 2018)
self.assertEqual(query.img, "http://www.whitehouse.gov/logo.jpg")
self.assertEqual(query.num_creators, 1)
self.assertEqual(query.num_characters, 8)
self.assertEqual(query.num_comics, 289)
self.assertEqual(query.num_events, 4)
db.session.delete(newSeries)
db.session.commit()
def agregar_serie():
data = request.json
serie_id = str(request.json["nombre"])
series_doc = series_ref.document(serie_id)
if (series_doc.get().exists):
error_message = {
"error": f"Ya existe una serie registrada con el nombre {serie_id}"
}
return jsonify(error_message), 400
try:
nueva_serie = Series(data["nombre"],
float(data["puntuacion"]), data["descripcion"],
bool(data["vista"]), data["link"]).to_dict()
series_doc.set(nueva_serie)
return jsonify(nueva_serie), 201
except:
error_message = {
"error":
"Los datos de la serie no están completos o son incorrectos"
}
return jsonify(error_message), 400
def setUpClass(cls):
"""
# Creates a new database for the unit test to use
"""
cls.engine.execute('DROP TABLE IF EXISTS authors;')
cls.engine.execute('DROP TABLE IF EXISTS books;')
cls.engine.execute('DROP TABLE IF EXISTS series;')
cls.engine.execute('DROP TABLE IF EXISTS publishers;')
cls.engine.execute('DROP TABLE IF EXISTS assoc_author_book;')
cls.engine.execute('DROP TABLE IF EXISTS assoc_author_series;')
Base.metadata.create_all(cls.engine)
dostoyevsky = Author(name="Fyodor Dostoyevsky",
date_of_birth="1821-11-11",
nationality="Russian"
# homepage_URL = null
)
keats = Author(name="John Keats",
date_of_birth="1821-2-23",
nationality="British",
occupation="Poet"
# homepage_URL = null
)
tolstoy = Author(name="Leo Tolstoy",
date_of_birth="1828-9-9",
nationality="Russian"
# homepage_URL = null
)
murakami = Author(name="Haruki Murakami",
date_of_birth="1949-1-12",
nationality="Japanese",
homepage_URL="www.harukimurakami.com")
# adding publishers
penguin = Publisher(name="Penguin",
founder="Allen Lane",
year_founded="1935",
country="United Kingdom",
status="Active")
vintage = Publisher(name="Vintage",
founder="Alfred A. Knopf, Sr.",
year_founded="1954",
country="United States",
status="Active")
knopf = Publisher(name="Knopf",
founder="Alfred A. Knopf, Sr.",
country="United States",
status="Active")
oxford = Publisher(name="Oxford University Press",
country="United Kingdom")
oneq84 = Series(title="1Q84",
genre="Magical Realism",
num_books=3,
status=1)
oneq84.written_by = [murakami]
bis = Book(title="1Q84, #1-3", isbn="0307593312")
bis.written_by = [murakami]
bis.publisher = knopf
bis.in_series = oneq84
war_and_peace = Book(title="War and Peace", isbn="0192833987")
notes_from_underground = Book(title="Notes from Underground",
isbn="067973452X")
crime_and_punishment = Book(title="Crime and Punishment",
isbn="0143058142")
tolstoy.wrotes = [war_and_peace]
dostoyevsky.wrotes = [notes_from_underground]
oxford.published_book = [war_and_peace]
vintage.published_book = [notes_from_underground]
crime_and_punishment.written_by = [dostoyevsky]
crime_and_punishment.publisher = penguin # books to publishers: many to one
tolkien = Author(name="J. R. R. Tolkien",
date_of_birth="1892-1-3",
nationality="British",
occupation="Philologist")
houghton_mifflin_harcourt = Publisher(name="Houghton Mifflin Harcourt",
founder="Henry Oscar Houghton",
country="United States",
status="Active")
del_rey = Publisher(name="Del Rey",
founder="Lester del Rey",
status="Active")
hobbit = Book(title="The Hobbit", isbn="0618260307")
hobbit.written_by = [tolkien]
hobbit.publisher = houghton_mifflin_harcourt
rings = Series(title="The Lord of the Rings",
genre="Epic",
num_books=3,
status=1)
ring1 = Book(title="The Fellowship of the Ring", isbn="0618346252")
ring1.written_by = [tolkien]
ring1.publisher = houghton_mifflin_harcourt
ring1.in_series = rings
ring2 = Book(title="The Two Towers", isbn="0618346260")
ring2.written_by = [tolkien]
ring2.publisher = houghton_mifflin_harcourt
ring2.in_series = rings
ring3 = Book(title="The Return of the King", isbn="0345339738")
ring3.written_by = [tolkien]
ring3.publisher = del_rey
ring3.in_series = rings
# add The Lord of the Rings related
cls.session.add(houghton_mifflin_harcourt)
cls.session.add(del_rey)
cls.session.add(ring2)
cls.session.add(ring1)
cls.session.add(ring3)
cls.session.add(hobbit)
# add publishers
cls.session.add(knopf)
cls.session.add(penguin)
cls.session.add(vintage)
cls.session.add(oxford)
# add books
cls.session.add(crime_and_punishment)
# add authors
cls.session.add(dostoyevsky)
cls.session.add(keats)
cls.session.add(tolstoy)
cls.session.add(murakami)
# add series
cls.session.add(oneq84)
cls.session.commit()
def detail(slug, folder, filename):
if folder is not None:
return send_data(folder, filename)
query = Entry.public()
entry = get_object_or_404(query, Entry.slug == slug)
return render_template('detail.html', entry=entry, series=Series(entry))
def add_series(self, data):
series = Series(data["title"], data["begin_date"], data["end_date"])
db.session.add(series)
db.session.commit()
def main():
#fcharacters = open('series_characters2.txt', 'a')
#fcreators = open('series_creators2.txt', 'a')
#fevents = open('series_events2.txt', 'a')
marvel = MarvelRequest()
"""
json.loads(String) takes in json formatted string, and outputs
data according to the conversion table at json library website
"""
index = 0
for offset in range(0, 10000, 20):
response = marvel.request("series",
offset) # No trailing slash allowed here
print(response.status_code)
assert response.status_code == 200
series = json.loads(response.text)
idNum = 0
title = ""
desc = ""
path = ""
start = ""
end = ""
numCreators = ""
numChars = ""
numComics = ""
numEvents = ""
for series_meta_keys, series_meta_data in series['data'].items():
# series_meta_keys: offset, limit, total, count, results[] from Marvel
# JSON structure
if series_meta_keys == 'results':
for series in series_meta_data:
if series['id'] != "":
for series_attribute_keys, series_attribute in series.items(
):
# now stepping through title, description, thumbnail, etc.
if series_attribute_keys == 'id':
idNum = int(series_attribute)
# idNum = idNum.encode('utf-8')
elif series_attribute_keys == 'title':
title = series_attribute
title = title.encode('utf-8')
# print('Title: ' + title)
elif series_attribute_keys == 'description':
if series_attribute != None:
"""
Error arose when using str(description) and
transferring output to text file: You must not
use str(...) to strip away unicode symbols
that often appear in Marvel descriptions!
"""
desc = series_attribute
desc = desc.encode('utf-8')
# print('Description: ' + desc)
elif series_attribute_keys == 'startYear':
# print("Start Year: " + str(series_attribute))
start = str(series_attribute)
elif series_attribute_keys == 'endYear':
# print("End Year: " + str(series_attribute))
end = str(series_attribute)
elif series_attribute_keys == 'thumbnail':
path = str(series_attribute['path'])
temp = path.split('/')
for v in temp:
if v == 'image_not_available':
path = None
if path != None:
path = str(path) + '.' + str(
series_attribute['extension'])
# print (path)
if series_attribute_keys == 'creators':
# print("Comics in series: " + str(series_attribute['available']))
numCreators = int(
series_attribute['available'])
#creator_ids = [series['id']]
#for creator_uri in series_attribute['items']:
# resource_path = creator_uri['resourceURI'].split('/')
# creator_ids.append(int(resource_path[-1]))
#fcreators.write(str(creator_ids) + '\n')
elif series_attribute_keys == 'characters':
# print("Characters in series: " + str(series_attribute['available']))
numChars = int(series_attribute['available'])
#character_ids = [series['id']]
#for character in series_attribute['items']:
# resource_path = character['resourceURI'].split('/')
#
# character_ids.append(int(resource_path[-1]))
#fcharacters.write(str(character_ids) + '\n')
elif series_attribute_keys == 'comics':
numComics = int(series_attribute['available'])
elif series_attribute_keys == 'events':
numEvents = str(series_attribute['available'])
#event_ids = [series['id']]
#for event in series_attribute['items']:
# resource_path = event['resourceURI'].split('/')
# event_ids.append(int(resource_path[-1]))
#fevents.write(str(event_ids) + '\n')
newEntry = Series(idNum, title, desc, start, end, path,
numCreators, numChars, numComics,
numEvents)
db.session.merge(newEntry)
db.session.commit()
index += 1
print("processed series " + str(index))
def createSeries(self, name="testSeries"):
series = Series(name=name, description="abc")
return self.createEntity(series)
