def test_formatted_time():
# From Josiah
dt = datetime.fromtimestamp(float(raw_time_str)).strftime("%Y-%m-%d %H:%M")
rating = Rating(timestamp=dt)
rating.save()
print(' timestamp ' + str(rating.timestamp))
assert rating.timestamp is not None
def change_or_create_user_rating_for_current_movie(current_movie, current_user, new_value):
if current_user.rating_set.filter(movie=current_movie).exists():
rating = current_user.rating_set.get(movie=current_movie)
rating.value = new_value
else:
rating = Rating(value=new_value)
rating.user = current_user
rating.movie = current_movie
rating.save()
def seed_ratings():
raters = Rater.objects.all()
movies = Movie.objects.all()
rating_id = 1
for movie in movies:
for num in range(20):
random_rater = raters[random.randint(0, len(raters)-1)]
rating = random.randint(1, 5)
date = fake.date_time()
new_rating = Rating(rating_id, random_rater.pk, movie.pk, date, rating)
new_rating.save()
rating_id += 1
def update_ratings_from_json(id, array):
movie = Movie.objects.get(pk=id)
movie.rating_set.all().delete()
new_rating_set = [
Rating(movie=movie, source=r['source'], value=r['value'])
for r in array
]
Rating.objects.bulk_create(new_rating_set)
def omdb_to_model(json):
logger.info("Processing movie data: %s", json)
# Copy, to avoid modifying input
json = dict(json)
# Response isn't a part of the movie
json.pop("Response", '')
# TODO: (Maybe) Replace "N/A" with nulls
# Ratings need special handling
ratings_json = json.pop("Ratings", None)
new_args = {omdb_name_mapping[k]: v for k, v in json.items()}
movie = Movie(**new_args)
# In case omdb tries to match the title more aggressively and the user tries multiple variants of the same title
# Not using get_or_create because we want the query (not object), for url
movie_in_db = Movie.objects.filter(title=movie.title)
if movie_in_db.exists():
return movie_in_db.first()
movie.save()
logger.info("Added new movie with id:%d, title:%s", movie.id, movie.title)
if ratings_json is not None:
ratings = [Rating(movie=movie, source=r['Source'], value=r['Value']) for r in ratings_json]
Rating.objects.bulk_create(ratings)
return movie
def setUp(self):
"""Set up the test database"""
self.m = Rating(user_id=1, movie_id=1, rating=5)
from django.contrib.auth.models import User
from movies.models import Rating, Movie
ratings = {1: [i for i in range(0,20)],
2: [i for i in range(0,5)],
3: [i for i in range(0,10)]}
print('adding ratings')
for i in ratings:
u = User.objects.create_user(str(i),str(i)+'@z.com',str(i)*10)
u.save()
for j in ratings[i]:
m = Movie.objects.get(movie_no = j+1)
r = Rating(user_id = u,movie_id = m, rating = 5)
r.save()
def test_raw_time():
rating = Rating(raw_time=raw_time)
rating.save()
assert rating.raw_time == raw_time
def post(self, request):
# Get title from service API
service_api_serializer = MovieSerialier(data=request.data)
if not service_api_serializer.is_valid():
return Response({'title': 'Not valid title provided!'},
status=status.HTTP_400_BAD_REQUEST)
# Initialize Service locator class and get data from external API
movie_service = MovieService(api_key, url)
data = movie_service.get_movie(service_api_serializer.data['title'])
print(data)
# run ModelSerializers, save models if all pass
serializers = {
'movie':
MovieExternalApiSerializer(data=data),
'imdbinfo':
ImdbInfoSeriaize(data=data),
'staff':
StaffExternalApiSerializer(data=data),
'marketinginfo':
MarketingInfoExternalApiSerializer(data=data),
'timeline':
TimelineExternalApiSerializer(data=data),
'ratings': [
RatingExternalApiSerializer(data=rating)
for rating in data['ratings']
],
}
errors = {}
for name, serializer in serializers.items():
if name != 'ratings':
if not serializer.is_valid():
errors.update(serializer.errors)
else:
for rating_serializer in serializer:
if not rating_serializer.is_valid():
errors.update(rating_serializer.errors)
if not errors:
movie = serializers['movie'].save()
ImdbInfo(movie=movie,
**serializers['imdbinfo'].validated_data).save()
Staff(movie=movie, **serializers['staff'].validated_data).save()
MarketingInfo(
movie=movie,
**serializers['marketinginfo'].validated_data).save()
Timeline(movie=movie,
**serializers['timeline'].validated_data).save()
for rating in serializers['ratings']:
Rating(movie=movie, **rating.validated_data).save()
else:
return Response({
'Errors':
errors,
'message':
'Errors occured during data retrieveing!'
})
# Return record from database to user.
return Response({
'Movie Details':
MovieExternalApiSerializer(movie).data,
'Staff Details':
StaffExternalApiSerializer(movie.staff).data,
'Timeline':
TimelineExternalApiSerializer(movie.timeline).data,
'Marketing Info':
MarketingInfoExternalApiSerializer(movie.marketinginfo).data,
'Imdb Info':
ImdbInfoSeriaize(movie.imdbinfo).data,
'Ratings': [
RatingExternalApiSerializer(rating).data
for rating in movie.rating_set.all()
],
})
def parse_rating(dictionary):
x = dictionary["results"][0]
return Rating(float(x["vote_average"]), int(x["vote_count"]))