def reload(self):
'''This is the 'reload' instance.
Deserializes the JSON file to __objects.
If JSON file does not exist, do nothing.
Return: __object or nothing
'''
if os.path.isfile(FileStorage.__file_path) is True:
with open(FileStorage.__file_path, 'r+', encoding='utf-8') as fn:
obj = json.load(fn)
for key in obj.keys():
is_dict = obj[key]
is_class = is_dict['__class__']
if 'BaseModel' in is_class:
FileStorage.__objects[key] = models.BaseModel(obj[key])
if 'Amenity' in is_class:
FileStorage.__objects[key] = models.Amenity(obj[key])
if 'City' in is_class:
FileStorage.__objects[key] = models.City(obj[key])
if 'Place' in is_class:
FileStorage.__objects[key] = models.Place(obj[key])
if 'Review' in is_class:
FileStorage.__objects[key] = models.Review(obj[key])
if 'State' in is_class:
FileStorage.__objects[key] = models.State(obj[key])
if 'User' in is_class:
FileStorage.__objects[key] = models.User(obj[key])
def create_review(project):
"""Create new review."""
review = models.Review(
author='Jeff Knupp',
content='Sandman rules!',
documentation_review=models.ReviewMetric(name='documentation',
stars=4,
content='It\'s great'),
project_infrastructure_review=models.ReviewMetric(
name='project_infrastructure',
stars=5,
content='Continuous Integration and automated documentation'
'generation in place.'),
ease_of_use_review=models.ReviewMetric(name='ease_of_use',
stars=5,
content='Wow!'),
ease_of_contribution_review=models.ReviewMetric(
name='ease_of_contribution',
stars=3,
content='Missing "CONTRIBUTING.md" or similar file!'),
code_quality_review=models.ReviewMetric(
name='code_quality',
stars=3,
content='This code sucks! The author should read <a '
'href="https://www.jeffknupp.com/writing-idiomatic-python-ebook">Writing '
'Idiomatic Python</a>'),
overall_review=models.ReviewMetric(name='overall',
stars=4,
content='Meh...'),
project=project)
models.db.session.add(review)
models.db.session.commit()
def Rinsert(items):
global engine
if (engine is None):
engine = sqlmy.create_engine(
"mysql+pymysql://" + mc['user'] + ":" + mc['psw'] + "@" +
mc['host'] + ":" + mc['port'] + "/" + mc['db_name'] + "?charset=" +
mc['charset'],
echo=False)
DBSession = sessionmaker(bind=engine)
session = DBSession()
get_data = session.query(
M.Review).filter(M.Review.rid == items['rid']).first()
if (get_data is None):
new_data = M.Review(rid=items['rid'],
sub_id=items['sub_id'],
star=items['star'],
review=items['review'],
info_time=items['info_time'])
session.add(new_data)
session.commit()
else:
#print(get_data)
print("repeat")
session.close()
async def post_facility_reviews(self, facility_id, source, rating, count):
"""
:param facility_id: Идентификатор клиники
:param source: Источник данных ("google")
:param rating: Рейтинг (5.0)
:param count: Количество отзывов (47)
"""
if self.base_address is not None:
raise NotImplementedError
async with models.AsyncSession() as session:
review = session.query(models.Review).filter(
models.Review.facility_id == facility_id,
models.Review.source == source
).first()
if review is None:
review = models.Review(
facility_id=facility_id,
source=source
)
session.add(review)
review.rating = rating
review.count = count
session.commit()
def setupDB():
for index in range(0, len(reviews)):
review = m.Review(
reviews[index]['id'], reviews[index]['text'],
reviews[index]['stars'],
s.indi_sentimentR(s.singularTokenize(reviews[index]['text'])))
m.db.session.add(review)
m.db.session.commit()
def submit_review(book_id, review_title, content, score, language, user_id):
user = models.User.query.filter_by(id=user_id).first()
book = models.Book.query.filter_by(id=book_id).first()
review = models.Review(review_title, content, score, language,
str(datetime.date.today()), user, book)
models.db.session.add(review)
models.db.session.commit()
update_avg_score(book.id)
def receive_review_add():
review = request.form['review']
stars = request.form['stars']
length = len(m.Review.query.all())
sentiment = s.indi_sentimentR(s.singularTokenize(review))
reviewAdd = m.Review(length, review, stars, sentiment)
m.db.session.add(reviewAdd)
m.db.session.commit()
return ('', 202)
def _tx():
review = models.Review(
key=key,
product_key=prod.key,
username=username, rating=rating,
comment=comment)
review.put()
defer(utils.updateAverageRating, key, _transactional=True)
return review
def test_joined_attr():
f = models.Review(
app="Annoyed Birds",
stars=5,
reviewer_email="*****@*****.**",
reviewer_name="Some One",
)
print(f.serialize())
assert ulid.from_str(f.serialize()["ulid"]["S"])
assert ulid.from_str(f.serialize()["pk"]["S"].split("#")[-1])
assert f.serialize()["__type"]["S"] == "Review"
assert f.serialize()["gsi1_pk"]["S"] == "REVIEW#[email protected]"
def _tx():
review = models.Review(key=key,
product_key=prod.key,
username=username,
rating=rating,
comment=comment)
review.put()
# in a transactional task, update the parent product's average
# rating to include this review's rating, and flag the review as
# processed.
defer(utils.updateAverageRating, key, _transactional=True)
return review
def add_review():
business_id = request.json['business_id']
worker_id = request.json['worker_id']
date = datetime.strptime(request.json['date'], '%b %d %Y %I:%M%p')
content = request.json['content']
score = request.json['score']
listing_id = request.json['listing_id']
reviewer_type = request.json['reviewer_type']
new_review = models.Review(business_id, worker_id, date, content, score, listing_id, reviewer_type)
db.session.add(new_review)
db.session.commit()
return "201 Created Review"
def db_start():
create_engine('sqlite:///tmp/testapi.db', convert_unicode=True)
db.create_all()
db.session.commit()
product_1 = models.Product()
product_1.name = 'Computer'
product_1.description = 'Very big comupter'
product_1.category = 'Personal computer'
db.session.add(product_1)
db.session.commit()
review_1 = models.Review()
review_1.author = 'Johny'
review_1.text = 'Very nice computer'
review_1.rating = 5
review_1.product_id = 1
db.session.add(review_1)
db.session.commit()
def do_create(self, arg):
'''Creates a new instance of BaseModel, save to JSON file.'''
args = arg.split()
if len(args) < 1:
print(self.errors['noclass'])
elif args[0] in self.new_class:
if args[0] == 'BaseModel':
new = models.BaseModel()
if args[0] == 'Amenity':
new = models.Amenity()
if args[0] == 'City':
new = models.City()
if args[0] == 'Place':
new = models.Place()
if args[0] == 'Review':
new = models.Review()
if args[0] == 'State':
new = models.State()
if args[0] == 'User':
new = models.User()
new.save()
print('{}'.format(new.id))
else:
print(self.errors['badclass'])
def review():
majorCodes = db.session.query(models.MajorCodes).all()
programs = db.session.query(models.Program).all()
allUsers = db.session.query(models.Users).all()
db.session.close()
form = forms.WriteReview()
# setting up the form
form.majorCode.choices = sorted([(m.duke_major_code, m.duke_major_code) for m in majorCodes])
if form.validate_on_submit():
dateTimeObj = datetime.now()
timestampStr = dateTimeObj.strftime("%d-%b-%Y (%H:%M:%S.%f)")
id = timestampStr
u_email = session.get('user_email')
# get form responses
duke_major_code = form.majorCode.data
duke_code = str(duke_major_code) + " " + str(form.courseNumber.data)
course_name = form.course.data
rating = form.rating.data
difficulty = form.difficulty.data
content = form.thoughts.data
user = db.session.query(models.Users).filter(Users.email == u_email).one()
program_name = user.program_name
for p in programs:
if p.program_name == program_name:
country = p.country
break
# check for errors
if request.method == 'POST':
error = None
user = db.session.query(models.Users).filter(Users.email == u_email).first()
specifcUserReviews = db.session.query(models.Review).filter(Review.u_email == u_email)\
.join(models.Course, Course.id == Review.course_id).filter(Course.course_name == course_name).all()
if len(specifcUserReviews) != 0:
error = 'You have already written a review for this class.'
flash(error)
return redirect(url_for('review'))
# check if the course already exists
courses = db.session.query(models.Course).filter(Course.course_name == course_name)\
.filter(Course.program_name == program_name).filter(Course.duke_code == duke_code).all()
course_id = None
for course in courses:
if course.course_name == course_name and course.program_name == program_name and course.duke_code == duke_code:
course_id = course.id
break
if course_id == None:
new_course = models.Course(duke_code=duke_code, course_name=course_name, program_name=program_name)
db.session.add(new_course)
db.session.flush()
db.session.commit()
course_id = new_course.id
new_review = models.Review(id=id, country=country, duke_major_code=duke_major_code, u_email=u_email, course_id=course_id , rating=rating, difficulty=difficulty, content=content)
db.session.add(new_review)
db.session.flush()
db.session.commit()
flash('New entry was successfully posted')
return render_template('submitted.html', form=form)
return render_template('review.html', form=form)
def add_review(request):
# Current time in milliseconds
post_time = int(time.time())
loc_id = request.get('URL')
loc_obj = DatabaseReader.get_location(loc_id)
loc_name = loc_obj.name
try:
vision_rating = int(request.get('Vision'))
except:
vision_rating = 0
try:
mobility_rating = int(request.get('Mobility'))
except:
mobility_rating = 0
try:
speech_rating = int(request.get('Speech'))
except:
speech_rating = 0
try:
helpfulness_rating = int(request.get('Helpfulness'))
except:
helpfulness_rating = 0
text = request.get('Text')
tag_ids = {
'1': 'wheelchair-friendly',
'2': 'blind-friendly',
'3': 'understanding',
'4': 'autism-friendly',
'5': 'elevators',
'6': 'secret laboratory'
}
tags_list = request.get_all('tags')
# tags_list ={
# 'wheelchair-friendly': request.get('wheelchair-friendly').strip(),
# 'blind-friendly': request.get('blind-friendly').strip(),
# 'understanding': request.get('understanding').strip(),
# 'autism-friendly': request.get('autism-friendly').strip()
# }
review = models.Review()
review.loc_name = loc_name
if vision_rating <= 5:
review.vision_rating = vision_rating
else:
review.vision_rating = 0
vision_rating = 0
if mobility_rating <= 5:
review.mobility_rating = mobility_rating
else:
review.mobility_rating = 0
mobility_rating = 0
if speech_rating <= 5:
review.speech_rating = speech_rating
else:
review.speech_rating = 0
speech_rating = 0
if helpfulness_rating <= 5:
review.helpfulness_rating = helpfulness_rating
else:
review.helpfulness_rating = 0
helpfulness_rating = 0
review.text = text
review.time_created = datetime.datetime.fromtimestamp(post_time)
review.loc_id = loc_id
update_location_average(review)
user = users.get_current_user()
if user:
review.user = user.nickname()
review.user_email = user.email()
else:
review.user = "******"
# Checking for tags Alpha
# for tag in tags_list.keys():
# if(tags_list[tag] != ""):
# logging.info("%s value is %s" %(tag, tags_list[tag]))
# review = append_tag_to_review(tag, tags_list[tag], review)
for tag in tags_list:
if (tag != ""):
try:
tag = int(tag)
tag_index = tag_ids[str(abs(tag))]
except:
continue
logging.info("%s value is %s" % (tag_index, tag))
append_tag_to_review(tag_index, tag, review)
add_review_tags_to_location(loc_obj, review)
if (review.vision_rating != None and review.mobility_rating != None
and review.speech_rating != None
and review.helpfulness_rating != None):
review.put()
return loc_id # For now?
else:
return None
def setUp(self):
"""Setup for each testcase"""
self.testcase = models.Review()
def get_reviews(self, url):
try:
amazon_url, asin = get_amazon_asin(url)
headers = {
'User-Agent':
'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.90 Safari/537.36'
}
page = requests.get(amazon_url, headers=headers)
page_response = page.text
parser = html.fromstring(page_response)
XPATH_AGGREGATE = '//span[@id="acrCustomerReviewText"]'
XPATH_REVIEW_SECTION_1 = '//div[contains(@id,"reviews-summary")]'
XPATH_REVIEW_SECTION_2 = '//div[@data-hook="review"]'
XPATH_AGGREGATE_RATING = '//table[@id="histogramTable"]//tr'
XPATH_PRODUCT_NAME = '//h1//span[@id="productTitle"]//text()'
XPATH_PRODUCT_PRICE = '//span[@id="priceblock_ourprice"]/text()'
raw_product_price = parser.xpath(XPATH_PRODUCT_PRICE)
product_price = ''.join(raw_product_price).replace(',', '')
ratings_dict = {}
raw_product_name = parser.xpath(XPATH_PRODUCT_NAME)
product_name = ''.join(raw_product_name).strip()
total_ratings = parser.xpath(XPATH_AGGREGATE_RATING)
# grabing the rating section in product page
for ratings in total_ratings:
extracted_rating = ratings.xpath('./td//a//text()')
if extracted_rating:
rating_key = extracted_rating[0]
raw_raing_value = extracted_rating[1]
rating_value = raw_raing_value
if rating_key:
ratings_dict.update({rating_key: rating_value})
XPATH_PAGER = '//*[@id="reviewSummary"]/div[1]/a/div/div/div[2]/div/span//text()'
pager = parser.xpath(XPATH_PAGER)
pager = ''.join(pager)
total_pages_str = pager
total_pages = int(re.sub("[^0-9.]*", '', total_pages_str))
number_of_pages = math.ceil(total_pages / 10)
current_page = 1
reviews_list = []
while current_page <= number_of_pages:
REVIEW_URL = r"http://www.amazon.com/product-reviews/%s/"
REVIEW_URL += r"ref=cm_cr_arp_d_show_all?ie=UTF8&reviewerType=all_reviews&pageNumber=%s"
url = REVIEW_URL % (asin, current_page)
page = requests.get(url, headers=headers)
page_response = page.text
review_parser = html.fromstring(page_response)
reviews = review_parser.xpath(XPATH_REVIEW_SECTION_1)
if not reviews:
reviews = review_parser.xpath(XPATH_REVIEW_SECTION_2)
if not reviews:
raise ValueError('unable to find reviews in page')
for review in reviews:
XPATH_RATING = './/i[@data-hook="review-star-rating"]//text()'
XPATH_REVIEW_HEADER = './/a[@data-hook="review-title"]//text()'
XPATH_REVIEW_POSTED_DATE = './/a[contains(@href,"/profile/")]/parent::span/following-sibling::span/text()'
XPATH_REVIEW_TEXT_1 = './/span[@data-hook="review-body"]//text()' # './/div[@data-hook="review-collapsed"]//text()'
XPATH_REVIEW_TEXT_2 = './/div//span[@data-action="columnbalancing-showfullreview"]/@data-columnbalancing-showfullreview'
XPATH_REVIEW_COMMENTS = './/span[@data-hook="review-comment"]//text()'
XPATH_AUTHOR = './/a[contains(@href,"/profile/")]/parent::span//text()'
XPATH_REVIEW_TEXT_3 = './/div[contains(@id,"dpReviews")]/div/text()'
raw_review_author = review.xpath(XPATH_AUTHOR)
raw_review_rating = review.xpath(XPATH_RATING)
raw_review_header = review.xpath(XPATH_REVIEW_HEADER)
raw_review_posted_date = review.xpath(
XPATH_REVIEW_POSTED_DATE)
raw_review_text1 = review.xpath(XPATH_REVIEW_TEXT_1)
raw_review_text2 = review.xpath(XPATH_REVIEW_TEXT_2)
raw_review_text3 = review.xpath(XPATH_REVIEW_TEXT_3)
review_id = review.attrib['id']
author = ' '.join(
' '.join(raw_review_author).split()).strip('By')
# cleaning data
review_rating = ''.join(raw_review_rating).replace(
'out of 5 stars', '')
review_header = ' '.join(
' '.join(raw_review_header).split())
review_posted_date = dateparser.parse(
''.join(raw_review_posted_date)).strftime('%d %b %Y')
review_text = ' '.join(' '.join(raw_review_text1).split())
# grabbing hidden comments if present
if raw_review_text2:
json_loaded_review_data = json.loads(
raw_review_text2[0])
json_loaded_review_data_text = json_loaded_review_data[
'rest']
cleaned_json_loaded_review_data_text = re.sub(
'<.*?>', '', json_loaded_review_data_text)
full_review_text = review_text + cleaned_json_loaded_review_data_text
else:
full_review_text = review_text
if not raw_review_text1:
full_review_text = ' '.join(
' '.join(raw_review_text3).split())
raw_review_comments = review.xpath(XPATH_REVIEW_COMMENTS)
review_comments = ''.join(raw_review_comments)
review_comments = re.sub('[A-Za-z]', '',
review_comments).strip()
review_dict = {
'review':
full_review_text,
'date':
review_posted_date,
'star_rating':
review_rating,
'user_name':
author,
'url':
"https://www.amazon.com/gp/customer-reviews/{0}".
format(review_id)
}
reviews_list.append(review_dict)
current_page = current_page + 1
sleep(3)
item = models.Item(name=product_name, url=amazon_url, ref_id=asin)
db.session.add(item)
db.session.commit()
for comment in reviews_list:
review = models.Review(user_name=comment['user_name'],
review=comment['review'],
url=comment['url'],
date=comment['date'],
star_rating=comment['star_rating'],
item_id=item.id)
db.session.add(review)
db.session.commit()
return item.id
except Exception as e:
print(os.environ)
print(e)
self.errors.append(e.__str__())
return {"error": self.errors}
return {"error": "failed to process the page", "asin": asin}
def setUp(self):
# Blank out the test JSON files:
data_map = { # todo DRY, this is repeated in every model interface's tests module
"user_data": "test/testing_mockUserDB.json",
"datespot_data": "test/testing_mockDatespotDB.json",
"match_data": "test/testing_mockMatchData.json",
"review_data": "test/testing_mockReviewData.json",
"message_data": "test/testing_mockMessageData.json",
"chat_data": "test/testing_mockChatData.json"
}
with open(TEST_JSON_DB_NAME, 'w') as fobj:
json.dump(data_map, fobj)
fobj.seek(0)
# make sure all the test-mock JSONs exist
for filename in data_map:
with open(data_map[filename], 'w') as fobj:
json.dump({}, fobj)
fobj.seek(0)
# Make a mock restaurant
self.terrezanos_location = (40.72289821341384, -73.97993915779077)
self.terrezanos_name = "Terrezano's"
self.terrezanos_traits = [
"italian", "wine", "pasta", "NOT FROM PIZZA HUT", "authentic",
"warehouse"
]
self.terrezanos_price_range = 2
self.terrezanos_hours = [
[14, 22], [14, 21], [14, 21], [14, 21], [14, 23], [14,
23], [14, 20]
] # ints in [0..23] representing hours, for now
terrezanos_data = {
"location": self.terrezanos_location,
"name": self.terrezanos_name,
"traits": self.terrezanos_traits,
"price_range": self.terrezanos_price_range,
"hours": self.terrezanos_hours,
}
# Make mock text
self.mock_text_positive_relevant = "This was a wonderful place to go on a date. I had the pasta. It was authentic and not from Pizza Hut."
self.expected_sentiment = 0.1906 # todo hardcoded
self.expected_relevance = round(
1 / len(self.mock_text_positive_relevant),
SENTIMENT_DECIMAL_PLACES) # i.e. "date" appears once.
# Connect to the database with the mock data set
self.db = DatabaseAPI(json_map_filename=TEST_JSON_DB_NAME)
args_data = {
"object_model_name": "datespot",
"object_data": terrezanos_data
}
self.terrezanos_id = self.db.post_object(args_data)
# Instantiate mock Review object
self.review_obj = models.Review(datespot_id=self.terrezanos_id,
text=self.mock_text_positive_relevant)
def test():
models.User.query.delete()
models.Book.query.delete()
models.Review.query.delete()
models.Author.query.delete()
# Adding users
user1 = models.User(
'admin', '*****@*****.**', 'Sweden',
'Send me an email if a book is missing in the database.',
str(datetime.date.today()), True)
models.db.session.add(user1)
models.db.session.commit()
user1 = models.User('Pelle Nordfors', '*****@*****.**', 'Sweden',
'hi everyone!', str(datetime.date.today()), False)
models.db.session.add(user1)
models.db.session.commit()
user2 = models.User(
'mrs. Lovett', '*****@*****.**', 'England',
'''A great fan of fiction. Lorem ipsum dolor sit
amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. ''',
str(datetime.date.today()), False)
models.db.session.add(user2)
models.db.session.commit()
user3 = models.User('Elphaba Thropp', '*****@*****.**', 'Oz',
'I like books. Especially The Grimmerie!',
str(datetime.date.today()), False)
models.db.session.add(user3)
models.db.session.commit()
user4 = models.User('George Banks', '*****@*****.**', 'England',
'Hi! Mary Poppins in my favorite book!',
str(datetime.date.today()), False)
models.db.session.add(user4)
models.db.session.commit()
user5 = models.User('Magda Keller', '*****@*****.**', 'Hungary',
'Umm... I rarely read at all.',
str(datetime.date.today()), False)
models.db.session.add(user5)
models.db.session.commit()
# Adding Lolita by Nabokov
author = models.Author('Vladimir Nabokov', 'Russia', 1899)
book = models.Book(
'Lolita', 1955,
'A man marries his landlady so he can take advantage of her daughter.',
'English')
book.written_by.append(author)
models.db.session.add(author)
models.db.session.commit()
review = models.Review('Awesome!', 'blabla', 9, 'Swedish',
str(datetime.date.today()), user1, book)
models.db.session.add(review)
review = models.Review('This is filth!', 'blablabla', 2, 'English',
str(datetime.date.today()), user2, book)
models.db.session.add(review)
models.db.session.commit()
database_helper.update_avg_score(book.id)
# Adding It by King
author = models.Author('Stephen King', 'USA', 1947)
book = models.Book(
'It', 1986,
'In 1960, seven outcast kids known as "The Loser Club" fight an evil demon.',
'English')
book.written_by.append(author)
models.db.session.add(author)
models.db.session.commit()
database_helper.update_avg_score(book.id)
# Adding The Shining by King
book = models.Book(
'The Shining', 1977,
'A recovering alcoholic and his family move into a haunted hotel as caretakers.',
'English')
book.written_by.append(author)
models.db.session.add(author)
models.db.session.commit()
database_helper.update_avg_score(book.id)
# Adding Carrie by King
book = models.Book(
'Carrie', 1974,
'A classic horror tale about Carrie White, a shy girl.', 'English')
book.written_by.append(author)
models.db.session.add(author)
models.db.session.commit()
database_helper.update_avg_score(book.id)
# Adding Misery by King
book = models.Book(
'Misery', 1987,
'Paul Sheldon, a successful novelist, is rescued after a snow storm by his "Number One Fan".',
'English')
book.written_by.append(author)
models.db.session.add(author)
models.db.session.commit()
database_helper.update_avg_score(book.id)
def get_reviews(self, url):
youtube_url, video_id = get_youtube_id(url)
try:
video_url = 'https://www.googleapis.com/youtube/v3/videos?id={0}&key={1}&fields=items(id,snippet(channelId,title,categoryId),statistics)&part=snippet,statistics'.format(
video_id, DEVELOPER_KEY)
headers = {
'User-Agent':
'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.90 Safari/537.36'
}
response = requests.get(video_url, headers=headers)
video_details = response.json()
if "items" not in video_details or len(
video_details["items"]) == 0:
raise ValueError("Unable to Get Video Details")
video_information = {
"ref_id":
video_id,
"ratings":
"N/A",
"name":
video_details["items"][0]["snippet"]["title"],
"reviews": [],
"url":
'https://www.youtube.com/watch?v=' + video_id,
"comment_count":
video_details["items"][0]["statistics"]["commentCount"]
}
data = []
results = self.youtube.commentThreads().list(
part="snippet", videoId=video_id,
textFormat="plainText").execute()
for item in results["items"]:
snippet = item['snippet']['topLevelComment']['snippet']
if snippet:
review_dict = {
'review':
snippet.get('textOriginal', ''),
'date':
dateparser.parse(
snippet['publishedAt']).strftime('%d %b %Y'),
'star_rating':
0,
'user_name':
snippet.get('authorDisplayName', ''),
'url':
'https://www.youtube.com/watch?v={0}&lc={1}'.format(
video_id, item['id'])
}
data.append(review_dict)
while "nextPageToken" in results:
results = self.youtube.commentThreads().list(
part="snippet",
videoId=video_id,
pageToken=results["nextPageToken"],
textFormat="plainText",
).execute()
for item in results["items"]:
snippet = item['snippet']['topLevelComment']['snippet']
if snippet:
review_dict = {
'review':
snippet.get('textOriginal', ''),
'date':
dateparser.parse(
snippet['publishedAt']).strftime('%d %b %Y'),
'star_rating':
0,
'user_name':
snippet.get('authorDisplayName', ''),
'url':
'https://www.youtube.com/watch?v={0}&lc={1}'.
format(video_id, item['id'])
}
data.append(review_dict)
video_information["reviews"] = data
item = models.Item(name=video_information['name'],
url=youtube_url,
ref_id=video_id)
db.session.add(item)
db.session.commit()
for comment in data:
review = models.Review(user_name=comment['user_name'],
review=comment['review'],
url=comment['url'],
date=comment['date'],
star_rating=comment['star_rating'],
item_id=item.id)
db.session.add(review)
db.session.commit()
return item.id
except Exception as e:
print(e)
self.errors.append(e.__str__())
return {"error": self.errors}
return {"error": "failed to process comments", "video_id": video_id}