def add_review(self, user, **kwargs):
reviews = Review()
rev = reviews.insert(cart_id=self.get_id(), user=user, **kwargs)
ratings = [r.rating for r in self.get_reviews()]
self.rating = sum(ratings) / len(ratings)
self.save()
return rev
def __init__(self, request):
"""
Handle the reviewed answer
"""
try:
fsession['reviewanswer']
except:
pass
else:
# for rating in request.form.getlist('rating'):
# Review.add(fsession['reviewanswer'], fsession['user_id'], rating, )
for tag_id in request.form.getlist('remove_tags'):
AnswerTag.remove(fsession['reviewanswer'], tag_id)
try:
request.form['rating']
except KeyError:
pass
else:
Review.add(fsession['reviewanswer'], g.lti.get_user_id(),
request.form['rating'], request.form['comments'])
# users can review only once per answer so delete from schdule list
Schedule.delete(fsession['reviewanswer'], g.lti.get_user_id())
# revoke permission to review answer
del fsession['reviewanswer']
def test_Review_attributes(self):
'''
Test that Review class has place_id, user_id and text
attributes.
'''
new_review = Review()
self.assertTrue("place_id" in new_review.__dir__())
self.assertTrue("user_id" in new_review.__dir__())
self.assertTrue("text" in new_review.__dir__())
def test_delete_review_wrong(self):
"""the id does not match a review"""
review_args = {"text": "sad cage", "place_id": self.place.id,
"user_id": self.user.id, "id": "RCA"}
review = Review(**review_args)
review.save()
rv = self.app.delete('{}/reviews/{}/'.format(self.path, "noID"),
follow_redirects=True)
self.assertEqual(rv.status_code, 404)
storage.delete(review)
def test_getreviews_bad_place(self):
"""test listing all reviews with a bad place id"""
review_args = {"text": "what a cage", "place_id": self.place.id,
"user_id": self.user.id}
review = Review(**review_args)
review.save()
rv = self.app.get('{}/places/{}/reviews/'.format(self.path, "noID"),
follow_redirects=True)
self.assertEqual(rv.status_code, 404)
storage.delete(review)
def test_update_place_bad_id(self):
"""test update with no matching id"""
review_args = {"text": "cage", "place_id": self.place.id,
"user_id": self.user.id, "id": "RCA"}
review = Review(**review_args)
review.save()
rv = self.app.put('{}/reviews/{}/'.format(self.path, "noID"),
content_type="application/json",
data=json.dumps({"text": "Z"}),
follow_redirects=True)
self.assertEqual(rv.status_code, 404)
storage.delete(review)
def test_update_review_bad_json(self):
"""test update with ill formed json"""
review_args = {"text": "cage", "place_id": self.place.id,
"user_id": self.user.id, "id": "RCA"}
review = Review(**review_args)
review.save()
rv = self.app.put('{}/reviews/{}/'.format(self.path, review.id),
content_type="application/json",
data={"id": "Z"},
follow_redirects=True)
self.assertEqual(rv.status_code, 400)
self.assertEqual(rv.get_data(), b"Not a JSON")
storage.delete(review)
def test_delete_review(self):
"""test delete a review"""
review_args = {"text": "poor cage", "place_id": self.place.id,
"user_id": self.user.id, "id": "RCA"}
review = Review(**review_args)
review.save()
rv = self.app.delete('{}/reviews/{}/'.format(self.path,
review_args["id"]),
follow_redirects=True)
self.assertEqual(rv.status_code, 200)
self.assertEqual(rv.headers.get("Content-Type"), "application/json")
json_format = getJson(rv)
self.assertEqual(json_format, {})
self.assertIsNone(storage.get("Review", review_args["id"]))
def test_view_one_review(self):
"""test retrieving one review"""
review_args = {"text": "cool cage", "place_id": self.place.id,
"user_id": self.user.id, "id": "RCA"}
review = Review(**review_args)
review.save()
rv = self.app.get('{}/reviews/{}/'.format(self.path,
review_args["id"]),
follow_redirects=True)
self.assertEqual(rv.status_code, 200)
self.assertEqual(rv.headers.get("Content-Type"), "application/json")
json_format = getJson(rv)
self.assertEqual(json_format.get("text"), review_args["text"])
self.assertEqual(json_format.get("id"), review_args["id"])
self.assertEqual(json_format.get("user_id"), review_args["user_id"])
storage.delete(review)
def test_update_review_user_id(self):
"""test cannot update review user_id"""
review_args = {"text": "cage", "place_id": self.place.id,
"user_id": self.user.id, "id": "RCA"}
review = Review(**review_args)
review.save()
rv = self.app.put('{}/reviews/{}/'.format(self.path, review.id),
content_type="application/json",
data=json.dumps({"user_id": "Z"}),
follow_redirects=True)
self.assertEqual(rv.status_code, 200)
self.assertEqual(rv.headers.get("Content-Type"), "application/json")
json_format = getJson(rv)
self.assertEqual(json_format.get("text"), review_args["text"])
self.assertEqual(json_format.get("id"), review_args["id"])
self.assertEqual(json_format.get("place_id"), review_args["place_id"])
self.assertEqual(json_format.get("user_id"), review_args["user_id"])
storage.delete(review)
def get(self):
restid = request.args.get('id')
rests = Rest.get_rest_object(restid)
pics = Photo.get_rest_pics(restid)
reviews = Review.get_rest_reviews(restid)
for review in reviews:
review.menu = Course.get_courses(review.revid)
return render_template('rest_index.html', pics=pics, reviews=reviews, rests=rests)
def test_getreviews(self):
"""test listing all reviews in a place"""
review_args = {"user_id": self.user.id, "place_id": self.place.id,
"text": "This is a great place"}
review = Review(**review_args)
review.save()
rv = self.app.get('{}/places/{}/reviews/'.format(
self.path, self.place.id),
follow_redirects=True)
self.assertEqual(rv.status_code, 200)
self.assertEqual(rv.headers.get("Content-Type"), "application/json")
json_format = getJson(rv)
self.assertTrue(type(json_format), list)
self.assertIn(review_args["text"],
[e.get("text") for e in json_format])
self.assertIn(review_args["user_id"],
[e.get("user_id") for e in json_format])
storage.delete(review)
def review():
answer = Schedule.get_answer(g.lti.get_user_id())
if answer == None:
return "No answers to review."
fsession['reviewanswer'] = answer.id
enabledtags = AnswerTag.get_tag_ids(answer.id)
reviews = Review.get_list(answer.id)
return render_template('reviewanswer.html', answer=answer,
tags=Tag.get_all(), enabledtags=enabledtags,
reviews=reviews)
def review():
answer = Schedule.get_answer(g.lti.get_user_id())
if answer == None:
return "No answers to review."
fsession['reviewanswer'] = answer.id
enabledtags = AnswerTag.get_tag_ids(answer.id)
reviews = Review.get_list(answer.id)
question = Question.by_id(answer.questionID)
if question is None:
return "Question was not found."
return render_template('reviewanswer.html', answer=answer,
tags=Tag.get_all(), enabledtags=enabledtags,
reviews=reviews, question=question)
def post(self):
op = request.form.get("op")
if op == "search":
keyword = request.form.get("keyword")
return redirect(url_for("search_result") + "?keyword=" + keyword)
elif op == "review":
restid = request.form.get("restid")
rating = request.form.get("rating")
content = request.form.get("review_content")
country = request.form.get("country")
revid = Review.insert(restid, float(rating), content, country)
menuid = Menu.insert_menu(int(restid), int(revid))
for i in request.form:
if i.startswith("menu"):
course = request.form.get(i).split(":")
Course.insert_course(menuid, course[0], course[1])
return redirect(url_for("rest_index") + "?id=" + restid)
class TestReview(unittest.TestCase):
""" class User parent class unit tests
"""
def setUp(self):
""" setup tests """
self.usermodel = User()
self.usermodel.save()
self.placemodel = Place()
self.placemodel.save()
self.model1 = Review()
self.model1.my_number = 89
self.model1.float = 1.1
self.model1.place_id = self.placemodel.id
self.model1.user_id = self.usermodel.id
self.model1.text = "holberton shool"
self.model1.save()
self.model2 = Review()
self.model2.my_number = 98
self.model2.place_id = self.placemodel.id
self.model2.user_id = self.usermodel.id
self.model2.text = "holberton shool"
self.model2.name = "Betty"
self.model2.my_number = 98
self.model2.save()
self.model2_dict = self.model2.to_dict()
self.model3 = Review(**self.model2_dict)
self.model3.save()
def tearDown(self):
""" teardown tests """
all_objs = storage.all()
all_objs.clear()
storage.save()
def test_attr(self):
"""test attr"""
model = Review()
self.assertNotIn('place_id', model.__dict__)
self.assertNotIn('user_id', model.__dict__)
self.assertNotIn('text', model.__dict__)
def test_class(self):
""" test type of the created instance """
self.assertIsInstance(self.model2, Review)
def test_attr_existence(self):
""" test if public attribute exist or not"""
self.assertTrue(hasattr(self.model2, 'place_id'))
self.assertTrue(hasattr(self.model2, 'user_id'))
self.assertTrue(hasattr(self.model2, 'text'))
self.assertFalse(hasattr(self.model2, 'invaid_attr'))
def test_existing_atrr_datatype(self):
""" test req attr data types """
self.assertEqual(type(self.model2.place_id), str)
self.assertEqual(type(self.model2.user_id), str)
self.assertEqual(type(self.model2.text), str)
def test_id(self):
"""model1.id and model2.id are different
"""
self.assertNotEqual(self.model1.id, self.model2.id)
def test_new_attr_name(self):
"""model2.name is string
"""
self.assertEqual(type(self.model2.name), str)
"""model2.name is "Betty"
"""
self.assertEqual(self.model2.name, "Betty")
def test_new_attr_my_number(self):
"""model1.my_number is int type
"""
self.assertEqual(type(self.model2.my_number), int)
"""model1.my_number is 89
"""
self.assertEqual(self.model1.my_number, 89)
"""model2.my_number is int
"""
self.assertEqual(type(self.model2.my_number), int)
"""model2.my_number is 98
"""
self.assertEqual(self.model2.my_number, 98)
def test_updated_at(self):
"""test datetime """
self.assertGreater(self.model2.created_at, self.model1.created_at)
self.assertGreater(self.model2.updated_at, self.model1.updated_at)
def test_new_types(self):
"""test types of new attrs"""
self.assertEqual(type(self.model1.float), float)
self.assertEqual(self.model1.float, 1.1)
def test_str(self):
"""test string method"""
self.assertEqual(
str(self.model1),
"[{}] ({}) {}".format(self.model1.__class__.__name__,
self.model1.id, self.model1.__dict__))
def test_to_dict(self):
""" tests to_dict method """
self.assertEqual(type(self.model2_dict), dict)
""" tests to_dict for iso timeformat """
created_at = self.model2_dict['created_at']
self.assertEqual(type(created_at), str)
created_at = datetime.strptime(created_at, "%Y-%m-%dT%H:%M:%S.%f")
self.assertEqual(type(created_at), datetime)
updated_at = self.model2_dict['updated_at']
self.assertEqual(type(updated_at), str)
updated_at = datetime.strptime(updated_at, "%Y-%m-%dT%H:%M:%S.%f")
self.assertEqual(type(updated_at), datetime)
def test_dict_equals(self):
""" tests to_dict method """
self.assertTrue(self.model2_dict == self.model2.to_dict())
def test_new_model_memory(self):
""" model3 and model3 are two different objects """
self.assertIsNot(self.model2, self.model3)
def test_new_model_id(self):
""" model3 and model2 have the same id """
self.assertEqual(self.model2.id, self.model3.id)
def test_new_model_created_at(self):
""" model3 and model2 have the same created_at value """
self.assertEqual(self.model2.created_at, self.model3.created_at)
def test_new_model_name(self):
""" model3 and model2 have the same name value """
self.assertEqual(self.model2.name, self.model3.name)
def test_new_model_number(self):
""" model3 and model2 have the same my_number value """
self.assertEqual(self.model2.my_number, self.model3.my_number)
def test_place_id(self):
""" test user model place_id """
self.assertEqual(self.model1.place_id, self.placemodel.id)
def test_user_id(self):
""" test user model user_id """
self.assertEqual(self.model1.user_id, self.usermodel.id)
def test_text(self):
""" test user model text """
self.assertEqual(self.model1.text, "holberton shool")
def test_save(self):
""" test save obj serialization """
review = Review()
review.save()
with open("file.json", "r") as file:
pre_objs = file.read()
pre_objs_size = len(pre_objs)
review2 = Review()
review2.save()
review2_key = "{}.{}".format(review2.__class__.__name__, review2.id)
with open("file.json", "r") as file:
post_objs = file.read()
post_objs_size = len(post_objs)
self.assertGreater(post_objs_size, pre_objs_size)
self.assertIn(review2_key, post_objs)
def test_reload(self):
"""" ensure storage reload works """
review = Review()
review.save()
review_key = "{}.{}".format(review.__class__.__name__, review.id)
storage.all().clear()
self.assertNotIn(review_key, storage.all())
storage.reload()
self.assertIn(review_key, storage.all())
def test_init_kwargs(self):
"""" ensure that kwargs are in new instance"""
kwarg_dict = {'int': 1, 'float': 2.2, 'str': "3"}
review = Review(**kwarg_dict)
self.assertEqual(review.int, 1)
self.assertEqual(type(review.int), int)
self.assertEqual(type(review.float), float)
self.assertEqual(type(review.str), str)
def setUp(self):
self.model = Review()
self.model.save()
def setUpClass(cls):
'''Setup Class'''
cls.obj1 = Review()
cls.obj2 = Review()
cls.obj3 = Review()
def setUpClass(cls):
cls.rev1 = Review()
cls.rev1.place_id = "Raleigh"
cls.rev1.user_id = "Greg"
cls.rev1.text = "Grade A"
def test_uuid(self):
""" uuid test """
x = Review()
self.assertEqual(type(x.id), str)
y = Review()
self.assertNotEqual(x.id, y.id)
def test_init(self):
obj = Review()
self.assertIsInstance(obj, BaseModel)
self.assertIs(type(obj), Review)
def test_text(self):
obj = Review()
self.assertIs(obj.text, '')
def setUpClass(cls):
"""set up before functions"""
cls.newreview = Review()
cls.newreview.place_id = "7272728"
cls.newreview.user_id = "Lul"
cls.newreview.text = "Place is meh"
def test_type(self):
r = Review()
self.assertEqual(type(r.place_id), str)
self.assertEqual(type(r.user_id), str)
self.assertEqual(type(r.text), str)
def test_hasattribute(self):
"""Tests if the instance of BaseModel"""
r = Review()
self.assertTrue(hasattr(r, "place_id"))
self.assertTrue(hasattr(r, "user_id"))
self.assertTrue(hasattr(r, "text"))
def test_instance(self):
""" pass """
r = Review()
assert isinstance(r, Review)
bus = BusinessManager(bus_train_file)
user = UserManager(user_train_file)
bus_test = BusinessManager(bus_test_file)
user_test = UserManager(user_test_file)
f_write = open(rating_out_file, "w")
line = ''
print "Starting to read the review file file from:" + review_data_file
f_bus = open(review_data_file)
model = LibFMWithUserBusinessFeatures(bus, user, bus_test, user_test)
output_header = model.get_feature_list()
output_header_text = model.get_header_text(output_header)
f_write.write(output_header_text + "\n")
for line in f_bus:
review_line = json.loads(line)
item = Review(review_line)
line = model.get_output_line(item)
print line
f_write.write(line)
f_bus.close()
f_write.close()
print "Done creating a rating file :" + rating_out_file
def test_text(self):
"""test for text"""
fn = Review()
fn.text = "sneha"
self.assertEqual(type(Review.text), str)
def test_created_at(self):
""" test datetime creation """
x = Review()
self.assertIsInstance(x.created_at, datetime.datetime)
self.assertIsInstance(x.updated_at, datetime.datetime)
self.assertEqual(x.created_at, x.updated_at)
def setUpClass(cls):
"""test"""
cls.rev = Review()
cls.rev.place_id = "4321-dcba"
cls.rev.user_id = "123-bca"
cls.rev.text = "the bestttt"
def test_05_instance_class_match(self):
'''Test if instanced object matches class'''
obj1 = Review()
self.assertIsInstance(obj1, Review,
"Instanced object is not Review class")
del obj1
def setUp(self):
'''Set Up'''
self.dct1 = Review().to_dict()
self.dct2 = Review().to_dict()
def test_04_instantiation(self):
'''Test for failed instantiation'''
try:
obj1 = Review()
obj2 = Review('Test')
obj3 = Review('id')
obj4 = Review(888)
obj5 = Review(id="1234")
obj6 = Review([1, 'A', 3])
obj7 = Review({'A': 1, 'B': 2})
obj8 = Review((2, 'B', 6))
obj9 = Review({7, 'HI', 10})
obj10 = Review(None)
obj11 = Review(-666)
obj12 = Review(float('nan'))
obj13 = Review(float('inf'))
obj14 = Review('')
obj15 = Review([])
obj16 = Review([-5])
obj17 = Review({})
obj18 = Review({'u': [6, 7]})
except:
self.fail("Failed Review instantiation")
finally:
del obj1
del obj2
del obj3
del obj4
del obj5
del obj6
del obj7
del obj8
del obj9
del obj10
del obj11
del obj12
del obj13
del obj14
del obj15
del obj16
del obj17
del obj18
def test_6_kwargs(self):
"""If the value is correct created with kwargs"""
model_id = str(uuid.uuid4())
model_1 = Review(id=model_id)
self.assertTrue(isinstance(model_1, BaseModel))
self.assertEqual(model_id, model_1.id)
def test_father_kwargs(self):
"""Test the class - BaseModel passing kwargs """
dictonary = {'id': '662a23b3-abc7-4f43-81dc-64c000000c00'}
review1 = Review(**dictonary)
self.assertTrue(issubclass(review1.__class__, BaseModel))
def test_07_dynamic_attr(self):
'''Test to dynamically add attributes'''
obj1 = Review()
try:
obj1.test1 = 'TEST'
obj1.test2 = [1, 2, 3]
obj1.test3 = {'a': 1, 'b': 2, 'c': 3}
obj1.test4 = (4, 5, 6)
obj1.test5 = {7, 8, 9}
obj1.test6 = None
obj1.test7 = 0.0
obj1.test8 = float('nan')
obj1.test9 = float('inf')
obj1.test10 = -666
obj1.test11 = ''
obj1.test12 = []
obj1.test13 = [-5]
obj1.test14 = {}
obj1.test15 = {'u': [6, 7]}
except:
self.fail("Failed to dynamically add pub inst attributes")
self.assertEqual(obj1.__dict__['test1'], 'TEST',
"Failed to assign value to dynamic pub inst attr")
self.assertEqual(obj1.__dict__['test2'], [1, 2, 3],
"Failed to assign value to dynamic pub inst attr")
self.assertEqual(obj1.__dict__['test3'], {
'a': 1,
'b': 2,
'c': 3
}, "Failed to assign value to dynamic pub inst attr")
self.assertEqual(obj1.__dict__['test4'], (4, 5, 6),
"Failed to assign value to dynamic pub inst attr")
self.assertEqual(obj1.__dict__['test5'], {7, 8, 9},
"Failed to assign value to dynamic pub inst attr")
self.assertEqual(obj1.__dict__['test6'], None,
"Failed to assign value to dynamic pub inst attr")
self.assertEqual(obj1.__dict__['test7'], 0.0,
"Failed to assign value to dynamic pub inst attr")
self.assertNotEqual(obj1.__dict__['test8'], float('nan'),
"Failed to assign value to dynamic pub inst attr")
self.assertEqual(obj1.__dict__['test9'], float('inf'),
"Failed to assign value to dynamic pub inst attr")
self.assertEqual(obj1.__dict__['test10'], -666,
"Failed to assign value to dynamic pub inst attr")
self.assertEqual(obj1.__dict__['test11'], '',
"Failed to assign value to dynamic pub inst attr")
self.assertEqual(obj1.__dict__['test12'], [],
"Failed to assign value to dynamic pub inst attr")
self.assertEqual(obj1.__dict__['test13'], [-5],
"Failed to assign value to dynamic pub inst attr")
self.assertEqual(obj1.__dict__['test14'], {},
"Failed to assign value to dynamic pub inst attr")
self.assertEqual(obj1.__dict__['test15'], {'u': [6, 7]},
"Failed to assign value to dynamic pub inst attr")
self.assertEqual(len(obj1.__dict__), 18)
del obj1
def test_Review(self):
"""Test attributes of the class."""
my_Review = Review()
my_Review.name = "LA"
self.assertEqual(my_Review.name, 'LA')
def test_attr(self):
"""test attr"""
model = Review()
self.assertNotIn('place_id', model.__dict__)
self.assertNotIn('user_id', model.__dict__)
self.assertNotIn('text', model.__dict__)
def test_place_id(self):
"""test for place_id"""
e = Review()
e.place_id = "abc"
self.assertEqual(type(Review.place_id), str)
def setUpClass(cls):
"""Set up class before start testing."""
cls.R1 = Review()
cls.R2 = Review()
def test_user_id(self):
"""test for user_id"""
p = Review()
p.review = "efg"
self.assertEqual(type(Review.user_id), str)
def test_kwargs(self):
""" test kwargs init """
x = Review()
y = Review(**x.to_dict())
self.assertEqual(x.to_dict(), y.to_dict())
self.assertNotEqual(x, y)
def test_review_created(self):
'''Tests created_at for review'''
r1 = Review()
self.assertTrue(hasattr(r1, "created_at"))
def setUpClass(cls):
"""set up for test"""
cls.rev = Review()
cls.rev.place_id = "4321-dcba"
cls.rev.user_id = "123-bca"
cls.rev.text = "The srongest in the Galaxy"
def test_father(self):
"""Test the class - BaseModel """
review1 = Review()
self.assertTrue(issubclass(review1.__class__, BaseModel))
def get_reviews(self, **kwargs):
reviews = Review()
return reviews.find(cart_id=self.get_id(), **kwargs)
def get_review_by_pkgname(self, package_name, page):
# get application id
self.cursor.execute("select id from application where app_name=?", (package_name,))
res = self.cursor.fetchall()
aid = ''
for item in res:
aid = str(item[0])
# get review count
self.cursor.execute("select count(*) from review where aid_id=?", (aid,))
res = self.cursor.fetchall()
count = ''
for item in res:
count = item[0]
if(page == 1):
# empty cache, download page 1
if(count == 0):
reviews = self.premoter.get_reviews(package_name, 0, 10)
review_total = ''
for review in reviews:
id = str(review.id)
review_total = review.aid['review_total']
user_display = review.user_display
content = review.content
date = str(review.date)
date = date.replace('T',' ')
date = date.replace('Z','')
self.cursor.execute("insert into review values(?,?,'',?,?,?,'zh_CN','',0,0)", (id,aid,content,user_display,date))
if(review_total != ''):
self.cursor.execute("update application set review_total=? where id=?", (review_total,aid))
self.connect.commit()
# normal init, check and download newest reviews
elif(count != 0):
# get newest review's id from local cache
self.cursor.execute("select id from review where aid_id=? order by date DESC limit 0,1", (aid,))
res = self.cursor.fetchall()
id = ''
for item in res:
id = item[0]
# find newest reviews from server
startpage = 0
loop = True
while loop:
reviews = self.premoter.get_reviews(package_name, startpage, 10)
review_total = ''
for review in reviews:
rid = review.id
review_total = review.aid['review_total']
user_display = review.user_display
content = review.content
date = str(review.date)
date = date.replace('T',' ')
date = date.replace('Z','')
# download
if(rid != id):
self.cursor.execute("insert or ignore into review values(?,?,'',?,?,?,'zh_CN','',0,0)", (rid,aid,content,user_display,date))
# end download
else:
# stop 'while'
loop = False
# break 'for'
break
if(review_total != ''):
self.cursor.execute("update application set review_total=? where id=?", (review_total,aid))
startpage += 1
self.connect.commit()
else:
# review not enough, download
if(count < page * 10):
start = (page - 1) * 10
reviews = self.premoter.get_reviews(package_name, start, 10)
review_total = ''
for review in reviews:
id = str(review.id)
review_total = review.aid['review_total']
user_display = review.user_display
content = review.content
date = str(review.date)
date = date.replace('T',' ')
date = date.replace('Z','')
# ignore the same review by id
self.cursor.execute("insert or ignore into review values(?,?,'',?,?,?,'zh_CN','',0,0)", (id,aid,content,user_display,date))
if(review_total != ''):
self.cursor.execute("update application set review_total=? where id=?", (review_total,aid))
self.connect.commit()
# all download check over, return reviews to show
limit = (page - 1) * 10
self.cursor.execute("select id, aid_id, content, user_display, date, language, up_total, down_total from review where aid_id=? order by date DESC limit ?,10", (aid,limit))
res = self.cursor.fetchall()
reviews = []
for item in res:
review = Review(package_name)
review.id = item[0]
review.aid = item[1]
review.content = item[2]
review.user_display = item[3]
review.date = item[4]
review.language = item[5]
review.up_total = item[6]
review.down_total = item[7]
reviews.append(review)
return reviews
