def test_add_single_key_without_existed_movie(self):
with self.instance.test_request_context() as request:
u = UserFactory()
self.db.session.commit()
key = Watchlist.make_key(user_id=u.id,
movie_key='movie:tt0167260:imdb')
result = Watchlist.add(keys=(key,))
self.assertEqual(len(result), 1)
self.assertTrue(isinstance(result[0], Watchlist))
self.assertEqual(result[0].status, Watchlist.PENDING_MOVIE)
movies = self.db.session.query(Movie).all()
self.assertEqual(len(movies), 1)
def test_validate_watchlist_keys(self):
keys = ['watchlist:1:movie:tt0167260:imdb',
'watchlist:1:movie:tt1229238:imdb',
'watchlist:1:movie:tt1272878:imdb']
valid = Watchlist.validate_keys(keys=keys)
self.assertEqual(len(valid), len(keys))
keys = ['watchlist:1:movie:tt0167260:imdb',
'watchlist:1:tt1229238:imdb',
'watchlist:1_movie_tt1272878_imdb']
valid = Watchlist.validate_keys(keys=keys)
self.assertEqual(len(valid), 1)
def test_add_single_key_with_existed_movie(self):
provider = 'imdb'
with self.instance.test_request_context() as request:
u = UserFactory()
m = MovieFactory()
self.db.session.commit()
mid = getattr(m, '%s_id' % provider)
movie_key = Movie.make_key(provider=provider, id=mid)
key = Watchlist.make_key(user_id=u.id, movie_key=movie_key)
result = Watchlist.add(keys=(key,))
self.assertEqual(len(result), 1)
self.assertTrue(isinstance(result[0], Watchlist))
self.assertEqual(result[0].status, Watchlist.PENDING_MOVIE)
def sync_loaded_movies(logger, **kwargs):
user_id = kwargs.get('user_id')
pattern = re.compile(ur'^([a-zA-ZА-Яа-я\d\s:&\'-]+)\s*\(?(\d{4})?\)?$')
path = instance.config.get('LOADED_MOVIE_PATH')
prefix = 'Process loaded movies'
logger.info('%s: start.' % prefix)
for root, dirs, files in os.walk(path):
for filename in files:
if filename.endswith('.mkv'):
name = filename[:-4]
matches = pattern.findall(name)
logger.info('%s: %s founded.' % (prefix, name))
try:
movie = Movie.query.filter_by(
year=matches[0][1]).whoosh_search(matches[0][0]).one()
except NoResultFound:
logger.info('%s: %s does not exists.' % (prefix, name))
redis.sadd('missind_loaded_movies', name)
else:
try:
params = [
Watchlist.user_id == user_id,
Watchlist.movie_id == movie.id
]
watchlist_movie = Watchlist.query.filter(*params).one()
except NoResultFound:
watchlist_movie = Watchlist(user_id=user_id,
movie_id=movie.id)
logger.info('%s: %s add movie to watchlist' % (
prefix, name))
db.session.add(watchlist_movie)
watchlist_movie.status = Watchlist.LOADED_MOVIE
watchlist_movie.path = filename
logger.info('%s: %s update movie in watchlist' % (
prefix, name))
try:
db.session.commit()
except IntegrityError:
db.session.rollback()
logger.info('%s: finished.' % prefix)
def sync_encoded_movies(logger, **kwargs):
user_id = kwargs.get('user_id')
pattern = re.compile(ur'^([a-zA-ZА-Яа-я\d\s:&\'-]+) \(?(\d{4})?\)?$')
path = instance.config.get('MOVIE_COLLECTION_PATH')
prefix = 'Process movies in collection'
logger.info('%s: start.' % prefix)
for root, dirs, files in os.walk(path):
name = root.replace(path, '').encode('utf-8')
matches = pattern.findall(name)
logger.info('%s: %s founded.' % (prefix, name))
if matches:
try:
movie = Movie.query.filter_by(
year=matches[0][1]).whoosh_search(matches[0][0]).one()
except NoResultFound:
redis.sadd('missing_encoded_movies', name)
else:
try:
params = [
Watchlist.user_id == user_id,
Watchlist.movie_id == movie.id
]
watchlist_movie = Watchlist.query.filter(*params).one()
except NoResultFound:
watchlist_movie = Watchlist(user_id=user_id,
movie_id=movie.id)
logger.info('%s: %s add movie to watchlist' % (
prefix, name))
db.session.add(watchlist_movie)
watchlist_movie.status = Watchlist.IN_COLLECTION_MOVIE
watchlist_movie.path = name
logger.info('%s: %s update movie in watchlist' % (
prefix, name))
try:
db.session.commit()
except IntegrityError:
db.session.rollback()
logger.info('%s: finished.' % prefix)
def test_add_already_existed_key(self):
provider = 'imdb'
with self.instance.test_request_context() as request:
u = UserFactory()
m = MovieFactory()
self.db.session.commit()
mid = getattr(m, '%s_id' % provider)
movie_key = Movie.make_key(provider=provider, id=mid)
w = Watchlist(user_id=u.id, movie_id=m.id)
self.db.session.add(w)
self.db.session.commit()
key = Watchlist.make_key(user_id=u.id, movie_key=movie_key)
result = Watchlist.add(keys=(key,))
self.assertEqual(len(result), 1)
self.assertEqual(result[0].id, w.id)
def test_make_key(self):
provider = 'imdb'
with self.instance.test_request_context() as request:
u = UserFactory(login='******', email='*****@*****.**')
m = MovieFactory()
self.db.session.commit()
mid = getattr(m, '%s_id' % provider)
movie_key = Movie.make_key(provider=provider, id=mid)
key = Watchlist.make_key(user_id=u.id, movie_key=movie_key)
self.assertEqual(key, ':'.join(('watchlist', str(u.id), movie_key)))
def test_parse_key(self):
provider = 'imdb'
with self.instance.test_request_context() as request:
u = UserFactory(login='******', email='*****@*****.**')
m = MovieFactory()
self.db.session.commit()
mid = getattr(m, '%s_id' % provider)
movie_key = Movie.make_key(provider=provider, id=mid)
key = 'watchlist:1:%s' % movie_key
result = Watchlist.parse_key(key)
self.assertEqual(len(result), 2)
self.assertEqual(result[0], u.id)
self.assertEqual(result[1], movie_key)
key = 'watchlist_1_%s' % movie_key
result = Watchlist.parse_key(key)
self.assertEqual(len(result), 2)
self.assertEqual(result[0], None)
self.assertEqual(result[1], None)
def test_add_single_key_without_existed_movie(self):
with self.instance.test_request_context() as request:
u = UserFactory()
self.db.session.commit()
user_id = u.id
key = Watchlist.make_key(user_id=u.id,
movie_key='movie:tt0167260:imdb')
add_to_watchlist(keys=(key,))
watchlist = self.db.session.query(Watchlist).filter(Watchlist.user_id == user_id).all()
self.assertEqual(len(watchlist), 1)
movies = self.db.session.query(Movie).all()
self.assertEqual(len(movies), 1)
def test_add_multiple_keys_with_one_person_and_not_existed_movies(self):
with self.instance.test_request_context() as request:
u = UserFactory()
self.db.session.commit()
keys = ['watchlist:1:movie:tt0167260:imdb',
'watchlist:1:movie:tt1229238:imdb',
'watchlist:1:movie:tt1272878:imdb']
result = Watchlist.add(keys=keys)
self.assertEqual(len(result), len(keys))
for item in result:
self.assertEqual(item.status, Watchlist.PENDING_MOVIE)
movies = self.db.session.query(Movie).all()
self.assertEqual(len(movies), len(keys))
def fill_queue_from_csv(logger, **kwargs):
user_id = str(kwargs.get('user_id'))
provider = kwargs.get('provider')
logger.info('Filling watchlist queue: start')
path = os.path.join(instance.config.get('MEDIA_ROOT'), 'watchlists',
user_id, '%s_watchlist.csv' % provider)
if os.path.exists(path):
with open(path, 'rb') as csvfile:
reader = csv.reader(csvfile)
for row in reader:
if not str(row[1]).startswith('tt'):
continue
key = Watchlist.make_key(
user_id, Movie.make_key(provider=provider, id=row[1]))
redis.lpush(Watchlist.watchlist_key, key)
logger.info('Filling watchlist queue: end')
else:
logger.info('Filling watchlist queue: watchlist file does not exists')
def test_add_already_existed_key(self):
provider = 'imdb'
with self.instance.test_request_context() as request:
u = UserFactory()
m = MovieFactory()
self.db.session.commit()
user_id = u.id
mid = getattr(m, '%s_id' % provider)
movie_key = Movie.make_key(provider=provider, id=mid)
w = Watchlist(user_id=u.id, movie_id=m.id)
self.db.session.add(w)
self.db.session.commit()
key = Watchlist.make_key(user_id=u.id, movie_key=movie_key)
add_to_watchlist(keys=(key,))
watchlist = self.db.session.query(Watchlist).filter(Watchlist.user_id == user_id).all()
self.assertEqual(len(watchlist), 1)
def add_to_watchlist(**kwargs):
logger = kwargs.get('logger', None)
keys = kwargs.get('keys', [])
provider = 'imdb' # TODO: fix this later
save_relations = kwargs.get('save_relations', False)
if logger:
logger.info('Adding movies to watchlist: start')
result = Watchlist.add(keys=keys)
if save_relations:
if logger:
logger.info('Adding movies to watchlist: save movies relations')
movie_ids = [w.movie_id for w in result]
movies = db.session.query(Movie).filter(Movie.id.in_(movie_ids)).all()
for movie in movies:
movie.save_poster(provider=provider, load_original=True)
missing_movies = movie.save_relations()
Movie.add(keys=missing_movies)
if logger:
logger.info('Adding movies to watchlist: end')
def test_add_multiple_keys_with_various_persons_and_existed_movies(self):
with self.instance.test_request_context() as request:
u1 = UserFactory()
u2 = UserFactory()
self.db.session.commit()
keys = ['watchlist:1:movie:tt0167260:imdb',
'watchlist:1:movie:tt1229238:imdb',
'watchlist:2:movie:tt1272878:imdb']
result = Watchlist.add(keys=keys)
self.assertEqual(len(result), len(keys))
for item in result:
self.assertEqual(item.status, Watchlist.PENDING_MOVIE)
movies = self.db.session.query(Movie).all()
self.assertEqual(len(movies), len(keys))
u1_movies = self.db.session.query(Watchlist).filter(Watchlist.user_id == u1.id).all()
self.assertEqual(len(u1_movies), 2)
u2_movies = self.db.session.query(Watchlist).filter(Watchlist.user_id == u2.id).all()
self.assertEqual(len(u2_movies), 1)
