Exemple #1
0
def movies(request):
    if request.method == 'GET':
        movie_list = Movie.objects.order_by('-release_date').all()
        serializer = MovieSerializer(movie_list, many=True)

        return Response(serializer.data)
    # TODO: 관리자 확인
    elif request.method == 'POST':
        # 영화 정보 생성
        genres = Genre.objects.filter(id__in=request.data['genres'])

        movie = Movie()
        movie.original_title = request.data['original_title']
        movie.title = request.data['title']
        movie.description = request.data['description']
        movie.poster_url = request.data['poster_url']
        movie.release_date = request.data['release_date']
        movie.trailer_url = request.data['trailer_url']
        movie.save()

        for genre in genres:
            movie.genres.add(genre)

        serializer = MovieSerializer(movie, many=False)
        return Response(serializer.data)
Exemple #2
0
def results(request):
	m = Movie()
	if request.GET.get('q') is not None:
		searchname = request.GET.get('q')
		movieData = m.getMovieData(searchname)
		return render(request, 'movie/home.html', {'movieData': movieData, 'search': True})
	else:
		return render(request, 'movie/home.html')
Exemple #3
0
 def save_movie_in_db(self, movie_data):
     try:
         movie = Movie.objects.get(name = movie_data['movie_title'])
     except:
         movie = Movie(name = movie_data['movie_title'],
             imdb_rating = movie_data['imdb_rating'],
             summary_text = movie_data['summary_text'])
         movie.save()
Exemple #4
0
def home(request):
    all_movies = get_movies_image(
        'https://www.vmovier.com/apiv3/index/getBanner')
    all_images = []
    for movie in all_movies:
        image = movie.get('image')
        images = str(image)
        all_images.append(images)

    movies = get_movies(
        'https://www.vmovier.com/apiv3/post/getPostInCate?cateid=0&p=1')

    try:
        for movie in movies:
            m_movie = Movie()
            title = movie.get('title')
            m_movie.m_title = title

            ima = movie.get('image')
            m_movie.m_image = ima

            duration = movie.get('duration')
            m_movie.m_duration = duration

            appfutitle = movie.get('appfutitle')
            m_movie.m_appfutitle = appfutitle

            postid = movie.get("postid")
            m_movie.m_positid = postid
            m_movie.save()
    except Exception as e:
        a_movies = Movie.objects.all()
        return render(request, 'home.html', context=locals())
    a_movies = Movie.objects.all()
    return render(request, 'home.html', context=locals())
Exemple #5
0
def list_create_view(request):
    if request.method == "GET":
        movies = Movie.objects.all()
        response = HttpResponse(serializers.serialize("json", movies), content_type="application/json")
        return response

    elif request.method == "POST":
        data = json.loads(request.body.decode("utf-8"))
        movie = Movie(title=data["title"])
        movie.save()
        return HttpResponse(serializers.serialize("json", [movie]), status=201, content_type="application/json")
Exemple #6
0
 def mutate(self, root, info, input=None):
     ok = True
     actors = []
     for actor_input in input.actors:
         actor = Actor.objects.get(pk=actor_input.id)
         if actor is None:
             return CreateMovie(ok=False, movie=None)
         actors.append(actor)
     movie_instance = Movie(title=input.title, year=input.year)
     movie_instance.save()
     movie_instance.actors.set(actors)
     return CreateMovie(ok=ok, movie=movie_instance)
Exemple #7
0
def list_create_view(request):
    if request.method == "GET":
        movies = Movie.objects.all()
        response = HttpResponse(serializers.serialize("json", movies),
                                content_type="application/json")
        return response

    elif request.method == "POST":
        data = json.loads(request.body.decode("utf-8"))
        movie = Movie(title=data['title'])
        movie.save()
        return HttpResponse(serializers.serialize("json", [movie]),
                            status=201, content_type="application/json")
Exemple #8
0
def list_or_create_view(request):
    if request.method == 'GET':
        movies = Movie.objects.all()
        return HttpResponse(serializers.serialize('json', movies),
                            content_type='applcation/json', status=200)

    elif request.method == 'POST':
        data = json.loads(request.body.decode("utf-8"))
        movie = Movie(title=data['title'])
        movie.save()
        return HttpResponse(serializers.serialize("json", [movie]),
                            content_type="application/json", status=201)
    else:
        return HttpResponse(status=404)
Exemple #9
0
def save_to_db(title, image, overview, popularity, vote_average, release_date,
               year, genre_list):
    movie = Movie(name=title,
                  image=image,
                  category=get_category(year),
                  description=overview,
                  vote_average=vote_average,
                  popularity=popularity,
                  release_date=release_date)
    movie.save()

    for x in genre_list:
        MovieGenre(movie=Movie.objects.get(id=movie.id),
                   genre=Genre.objects.get(genre_pk=x)).save()
Exemple #10
0
 def save(self):
     try:
         movie = Movie(
             name=self.validated_data['name'],
             description=self.validated_data['description'],
             created_by=self.validated_data['created_by'],
         )
         movie.save()
         return movie
     except KeyError:
         raise serializers.ValidationError({
             "response":
             "You must have a name, some content, and created by."
         })
Exemple #11
0
def pachong2(pachong):
    top250 = pachong()
    save_list = []
    for i in top250:
        save_list.append(Movie(uid=i[0],name=i[1],info=i[2]))
    if Movie.objects.count()==0:
        Movie.objects.bulk_create(save_list)
Exemple #12
0
    def get_genre_based_recommendations(self, max_recommendations):
        """
        Returns movie recommendations solely based on personality-genre associations.
        Returns the recommendations as well as the list of genres for this user.
        """
        genres = get_genres_for_user(self, max_distance=2, max_genres=4)

        genre_ids = [
            g['id'] for g in tmdb.Genres().movie_list()['genres']
            if g['name'] in genres
        ]

        recommendations = []

        args = {
            'page': 1,
            'vote_count_gte': 20,
            'vote_average_gte': 7,
            'sort_by': 'vote_average.desc'
        }

        # If at least one rule can be applied, predict movies of the associated genres with a high rating.
        # Otherwise, just predict movies of all genres with high ratings.
        if len(genres) > 0:
            args['with_genres'] = genre_ids

        recs = tmdb.Discover().movie(**args)
        recommendations += recs['results']
        rated_movie_ids = [
            r.movie.tmdb_id for r in Rating.objects.filter(rated_by=self)
        ]

        # Filter out movies that the user has already seen
        recommendations = [
            r for r in recommendations if r['id'] not in rated_movie_ids
        ]

        while len(recommendations) < max_recommendations and recs[
                'page'] < recs['total_pages']:
            args['page'] += 1
            recs = tmdb.Discover().movie(**args)
            recommendations += recs['results']
            # Filter out movies that the user has already seen
            recommendations = [
                r for r in recommendations if r['id'] not in rated_movie_ids
            ]

        if len(recommendations) > max_recommendations:
            recommendations = recommendations[:max_recommendations]

        # Save recommended Movies in DB
        for rec in recommendations:
            movie = Movie.objects.filter(tmdb_id=rec['id'])
            if not movie.exists():
                Movie(tmdb_id=rec['id'], title=rec['title']).save()

        return recommendations, genres
Exemple #13
0
def movies(request, arg0='', arg1=''):
    if request.method == "POST":
        # check if title is given
        if arg0 == '':
            response = {"response": False, "error": "search title is missing"}
        else:
            movie_data = fetch_movie_data(arg0.replace(" ", "+"))

            # if title is found
            if movie_data['Response'] == "True":
                # if title is not in local db yet
                if not Movie.objects.filter(
                        imdbID=movie_data['imdbID']).exists():
                    # save to db
                    save_movie_data(movie_data)

                response = {"response": True, "result": movie_data}

            # if title is not in omdb
            else:
                response = {
                    "response": False,
                    "error": "title is not found in OMDb"
                }

    elif request.method == "GET":
        if arg0 and arg1 == 'DESC' and Movie.model_field_exists(arg0):
            response = {
                "response": True,
                "result":
                list(Movie.objects.all().order_by("-" + arg0).values())
            }
        elif arg0 and Movie.model_field_exists(arg0):
            response = {
                "response": True,
                "result": list(Movie.objects.all().order_by(arg0).values())
            }
        else:
            response = {
                "response": True,
                "result": list(Movie.objects.all().values())
            }

    return JsonResponse(response)
Exemple #14
0
def forge():
    '''Generate fake data.'''
    db.create_all()
    name = 'Han Star'

    movies = [
        {
            'title': 'My Neighbor Totoro',
            'year': '1988'
        },
        {
            'title': 'Dead Poets Society',
            'year': '1989'
        },
        {
            'title': 'A Perfect World',
            'year': '1993'
        },
        {
            'title': 'Leon',
            'year': '1994'
        },
        {
            'title': 'Mahjong',
            'year': '1996'
        },
        {
            'title': 'Swallowtail Butterfly',
            'year': '1996'
        },
        {
            'title': 'King of Comedy',
            'year': '1999'
        },
        {
            'title': 'Devils on the Doorstep',
            'year': '1999'
        },
        {
            'title': 'WALL-E',
            'year': '2008'
        },
        {
            'title': 'The Pork of Music',
            'year': '2012'
        },
    ]

    user = User(name=name)
    db.session.add(user)
    for m in movies:
        movie = Movie(title=m['title'], year=m['year'])
        db.session.add(movie)
    db.session.commit()
    click.echo("Done....")
Exemple #15
0
    def save_movie(self):
        # """[summary]
        # """
        homepage = (self.imdb_movie_url if not self.movie_data.get("homepage")
                    else self.movie_data.get("homepage"))
        rating = (self.imdb_rating if self.imdb_rating else float(
            self.movie_data.get("vote_average", None)))
        try:
            Movie(
                **{
                    "title":
                    self.movie_data.get("title", None),
                    "release_date":
                    self.movie_data.get("release_date", None),
                    "runtime":
                    self.movie_data.get("runtime", None),
                    "poster_path": (
                        f"https://image.tmdb.org/t/p/w500"
                        f"{self.movie_data.get('poster_path', None)}"),
                    "overview":
                    self.movie_data.get("overview", None),
                    "imdb_id":
                    self.movie_data.get("imdb_id", None),
                    "imdb_rating":
                    rating,
                    "imdb_movie_url":
                    self.imdb_movie_url,
                    "homepage":
                    homepage,
                    # 'trailer': self.
                    # 'geners:
                    "resolution":
                    self.get_resolution_from_filename(),
                    "filename":
                    self.filename,
                }).save()
        except Exception as err:
            if "UNIQUE constraint failed: movie_movie.imdb_id" in str(err):
                movie = Movie.objects.get(imdb_id=self.imdb_id)
                import ipdb

                ipdb.set_trace()
                if self.imdb_rating != movie.imdb_rating:
                    Movie.objects.filter(imdb_id=self.imdb_id).update(
                        **{"imdb_rating": self.imdb_rating})
                    print(
                        f"{movie.title}'s rating was updated to {self.imdb_rating}"
                    )
                else:
                    print(
                        f"{movie.title}'s rating is till: {movie.imdb_rating}")
            else:
                raise Exception(err)
        else:
            print(f"Saved successfully.")
Exemple #16
0
 def setUp(self):
     self.movie = Movie(
         title='test',
         data={'test_data': 'test_value'}
     )
     self.movies = [
         Movie(
             title=f'title{index}',
             data={
                 'test_data': 'other_value',
                 'special_filter': f'special_value{index}'
             }
         )
         for index in range(6)
     ]
     self.example_get_movie_data = {
         'Response': 'True',
         'Title': 'Test-man 3 big testing',
         'Rating': '5/7',
     }
Exemple #17
0
def add(data, db_session, username):
    logger.info(LogMsg.START, username)
    schema_validate(data, MOVIE_ADD_SCHEMA_PATH)
    logger.debug(LogMsg.SCHEMA_CHECKED)
    model_instance = Movie()
    populate_basic_data(model_instance, username, data.get('tags'))
    logger.debug(LogMsg.POPULATING_BASIC_DATA)
    model_instance.description = data.get('description')
    model_instance.title = data.get('title')
    model_instance.images = data.get('images')
    model_instance.director = data.get('director')
    model_instance.producer = data.get('producer')
    model_instance.pub_year = data.get('pub_year')
    model_instance.genre = data.get('genre')
    model_instance.writer = data.get('writer')

    db_session.add(model_instance)
    logger.debug(LogMsg.DB_ADD)
    logger.info(LogMsg.END, model_to_dict(model_instance))
    return model_instance
Exemple #18
0
def get_movie(request):
    request = json.loads(request.body)
    global td
    u_id = request["u_id"]
    m_id = request["m_id"]
    title = request["title"]
    print(title)
    average_score = -1
    expecting_score = -1

    if m_id == -1:
        try:
            movie = Movie.objects.get(title=title)
            m_id = movie.m_id
            print("-----movie exist-----")
        except Movie.DoesNotExist:
            movie = Movie(title=title)
            movie.save()
            m_id = Movie.objects.get(title=title).m_id
            print("-----movie does not exist-----")
    try:
        rating = Rating.objects.get(movie=m_id, user=u_id)
        score = rating.rate
    except Rating.DoesNotExist:
        score = -1

    if m_id <= td.movie_num:
        if u_id <= td.user_num:
            expecting_score = td.prediction_result[u_id][m_id]
            if td.movies.movie_list[m_id].total_rate_num != 0:
                average_score = td.movies.movie_list[m_id].total_rate / td.movies.movie_list[m_id].total_rate_num

    jsonData = OrderedDict()
    jsonData["m_id"] = m_id
    jsonData["title"] = title
    jsonData["averageScore"] = average_score
    jsonData["expectingScore"] = expecting_score
    jsonData["score"] = score
    return HttpResponse(json.dumps(jsonData, ensure_ascii=False, indent="\t"), content_type="application/json")
Exemple #19
0
def addmovie(request):
	form = MovieForm()
	if request.method == 'POST': # If the form has been submitted...
		form = MovieForm(request.POST) # A form bound to the POST data
		if form.is_valid(): # All validation rules pass
			m = Movie()
			m.name = form.cleaned_data['name']
			m.sourcefile = form.cleaned_data['url']
			m.save()
			m.download_file()
			return HttpResponseRedirect('/movies/') # Redirect after POST<	
	return render(request, 'movie/addmovie.html', {'form': form})
Exemple #20
0
 def get_movies(self, request, *args, **kwargs):
     movie = Movie(name="a",
                   director='a',
                   actors='a',
                   types='a',
                   country='a',
                   language='a',
                   date='a',
                   length='a',
                   rate='a',
                   watcher='a',
                   tags='a')
     movie_json = MovieSerializer(movie)
     return Response(movie_json.data)
Exemple #21
0
    def setUp(self):
        # 配置更新
        app.config.update(TESTING=True,
                          SQLALCHEMY_DATABASE_URI='sqlite:///:memory:')
        # 创建数据库和表
        db.create_all()
        # 创建测试数据
        user = User(name="Test", username='******')
        user.set_password('123')
        movie = Movie(title='Test Movie', year='2020')
        # 使用add_all放管服测试添加多个实例
        db.session.add_all([user, movie])
        db.session.commit()

        self.client = app.test_client()  # 创建客户端测试
        self.runner = app.test_cli_runner()  # 创建测试命令运行器
Exemple #22
0
def movie_add():
    form = MovieForm()
    if form.validate_on_submit():
        data = form.data
        file_logo = secure_filename(form.logo.data.filename)
        if not os.path.exists(app.config["UP_DIR"]):
            os.makedirs(app.config["UP_DIR"])
            os.chmod(app.config["UP_DIR"], "rw")
        logo = change_filename(file_logo)
        form.logo.data.save(app.config["UP_DIR"] + logo)

        movies = Movie(
            title = data["title"],
            url = data["url"],
            description = data["info"],
            star = data["star"],
            logo = logo,
            tag_id = data["tag_id"],
            length = data["length"],
            area = data["area"],
            release_time = data["release_time"],
            play_num = 0,
            comment_num = 0
        )

        db.session.add(movies)
        db.session.commit()
        flash("添加电影成功", "OK")

        # 添加操作日志
        operatelog = OperateLog(
            admin_id=session["admin_id"],
            ip=request.remote_addr,
            reason="添加电影:" + data["title"]
        )

        db.session.add(operatelog)
        db.session.commit()
        return redirect(url_for("admin.movie_add"))

    return render_template("admin/movie_add.html", form=form)
Exemple #23
0
def get_all(data, db_session, username):
    logger.info(LogMsg.START, username)

    if data.get('sort') is None:
        data['sort'] = ['creation_date-']

    result = Movie.mongoquery(
        db_session.query(Movie)).query(**data).end().all()
    final_res = []
    rated_movies = users_rated_movie_ids(username, db_session)
    for item in result:
        model_dict = model_to_dict(item)
        model_dict['rated_by_user'] = False
        if item.id in rated_movies:
            model_dict['rated_by_user'] = True
        final_res.append(model_dict)

    logger.debug(LogMsg.GET_SUCCESS, final_res)
    logger.info(LogMsg.END)

    return final_res
Exemple #24
0
def index():
    """首页 增加"""
    if request.method == 'POST':
        # post请求 获取表单
        if not current_user.is_authenticated:  # 未认证
            return redirect(url_for('login'))
        title = request.form.get('title')  # name值
        year = request.form.get('year')
        # 验证数据
        if not title or not year or len(year) > 4 or len(title) > 60:
            flash('Invalid input..')  # 显示错误消息
            return redirect(url_for('index'))  # 重定向事业
        # 保存数据表
        movie = Movie(title=title, year=year)
        db.session.add(movie)
        db.session.commit()
        flash('Item create.')  # 显示创建成功
        return redirect(url_for('index'))

    movies = Movie.query.all()  # 从数据库获取电影
    return render_template('index.html', movies=movies)  # 使用上下文模板函数
Exemple #25
0
 def get_movies(self, request, *args, **kwargs):
     token = request.GET["uid"]
     new_movies = []
     movies = pick_movies(token)
     for movie in movies:
         if "summary" in movie:
             summary = movie["summary"]
         else:
             summary = ""
         movie = Movie(
             id=movie["movie_id"],
             name=movie["name"],
             directors=",".join(flatten(movie["directors"]))
             if movie["directors"] else "",
             actors=",".join(flatten(movie["actors"]))
             if movie["actors"] else "",
             language=",".join(flatten(movie["language"]))
             if movie["language"] else "",
             types=",".join(flatten(movie["types"]))
             if movie["types"] else "",
             countries=",".join(flatten(movie["countries"]))
             if movie["countries"] else "",
             year=movie["year"] if movie["year"] else "",
             length=movie["length"] if movie["length"] else "",
             rate=movie["rate"],
             editors=",".join(flatten(movie["editors"]))
             if movie["editors"] else "",
             people=movie["people"],
             tags=",".join(flatten(movie["tags"])) if movie["tags"] else "",
             cover_url="/photos/" + movie["movie_id"],
             summary=summary,
         )
         print movie
         new_movies.append(movie)
     movie_json = MovieSerializer(new_movies)
     return Response(movie_json.data)
Exemple #26
0
class MoviesViewSetTest(TestCase):

    def setUp(self):
        self.movie = Movie(
            title='test',
            data={'test_data': 'test_value'}
        )
        self.movies = [
            Movie(
                title=f'title{index}',
                data={
                    'test_data': 'other_value',
                    'special_filter': f'special_value{index}'
                }
            )
            for index in range(6)
        ]
        self.example_get_movie_data = {
            'Response': 'True',
            'Title': 'Test-man 3 big testing',
            'Rating': '5/7',
        }

    def test_default_get_behavior(self):
        self.movie.save()
        request = factory.get('/', '', content_type='application/json')

        response = self.get_view(request)

        self.assertEquals(response.status_code, status.HTTP_200_OK)
        self.assertListEqual(
            response.data, [
                {'title': 'test', 'data': {'test_data': 'test_value'}}
            ]
        )

    def test_get_no_results(self):
        request = factory.get('/', '', content_type='application/json')

        response = self.get_view(request)

        self.assertEquals(response.status_code, status.HTTP_200_OK)
        self.assertListEqual(response.data, [])

    def test_get_many_results(self):
        Movie.objects.bulk_create(self.movies)
        request = factory.get('/', '', content_type='application/json')

        response = self.get_view(request)

        self.assertEquals(response.status_code, status.HTTP_200_OK)
        self.assertEquals(len(response.data), len(self.movies))

    def test_get_with_filter(self):
        Movie.objects.bulk_create([self.movie, *self.movies])
        request = factory.get(
            '/',
            data={'test_data': 'test_value'},
            content_type='application/json'
        )

        response = self.get_view(request)

        self.assertEquals(response.status_code, status.HTTP_200_OK)
        self.assertListEqual(
            response.data, [
                {'title': 'test', 'data': {'test_data': 'test_value'}}
            ]
        )

    def test_get_with_two_keywords_filter(self):
        Movie.objects.bulk_create([self.movie, *self.movies])
        request = factory.get(
            '/',
            data={
                'test_data': 'test_value',
                'special_filter': 'special_value1'
            },
            content_type='application/json'
        )

        response = self.get_view(request)

        self.assertEquals(response.status_code, status.HTTP_200_OK)
        self.assertListEqual(
            response.data, [
                {'title': 'test', 'data': {'test_data': 'test_value'}},
                {'title': 'title1', 'data': {
                    'test_data': 'other_value',
                    'special_filter': 'special_value1'
                }},
            ]
        )

    @mock.patch('movie.views.get_movie_data')
    def test_default_post_behavior(self, mock_get_movie_data):
        mock_get_movie_data.return_value = self.example_get_movie_data
        request = factory.post(
            '/',
            data={'title': 'test-man 3'},
            format='json'
        )

        self.assertFalse(Movie.objects.all().exists())

        response = self.post_view(request)

        self.assertEquals(response.status_code, status.HTTP_201_CREATED)
        self.assertEquals(
            Movie.objects.get().title,
            mock_get_movie_data.return_value['Title']
        )

    def test_no_title_in_post(self):
        request = factory.post('/', data={}, format='json')

        response = self.post_view(request)

        self.assertFalse(Movie.objects.all().exists())
        self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST)
        self.assertDictEqual(
            response.data, {'Error': 'Movie title not provided.'}
        )

    @mock.patch('movie.views.get_movie_data')
    def test_post_movie_with_given_title_already_exists(
        self, mock_get_movie_data
    ):
        mock_get_movie_data.return_value = self.example_get_movie_data
        self.movie.title = mock_get_movie_data.return_value['Title']
        self.movie.save()
        request = factory.post(
            '/',
            data={'title': 'test-man 3'},
            format='json'
        )

        response = self.post_view(request)

        self.assertEquals(Movie.objects.all().count(), 1)
        self.assertEquals(response.status_code, status.HTTP_204_NO_CONTENT)
        self.assertDictEqual(
            response.data, {'Error': 'Move with title already exists.'}
        )

    @property
    def get_view(self):
        return MoviesView.as_view({'get': 'list'})

    @property
    def post_view(self):
        return MoviesView.as_view({'post': 'create'})
Exemple #27
0
def add(name, debug, log):
    if debug == 'y':
        debug = True
    else:
        debug = False

    name = re.sub(u"\s+", "%20", name)
    conn.request("GET", film.format(name), payload)
    res = conn.getresponse()
    data_movie = json.loads(res.read())

    if not data_movie['total_results']:
        print("Could not find ", name)
        log.write(name + '\n')
        log.flush()
    else:
        movie_data = data_movie['results'][0]

        # populating movie database
        if Movie.objects.filter(name=movie_data['title']):
            movie_object = Movie.objects.filter(name=movie_data['title'])[0]
        else:
            if movie_data['poster_path']:
                movie_object = Movie(name=movie_data['title'],
                                     release=movie_data['release_date'],
                                     poster=str(poster_path +
                                                movie_data['poster_path']))
            else:
                movie_object = Movie(name=movie_data['title'],
                                     release=movie_data['release_date'])
        movie_id = movie_data['id']

        if debug:
            click.echo(u'Movie name, Release date: {}'.format(movie_object))

        if debug:
            # print genres for debugging
            for j in movie_data['genre_ids']:
                click.echo(u'Genre: {}'.format(genre_dict[str(j)]))

        # getting movie credits to store crew and cast
        conn.request("GET", credit.format(movie_id), payload)
        res = conn.getresponse()
        crew_data = json.loads(res.read())

        # print director for debugging
        if debug:
            for k in crew_data['crew']:
                if k['job'] == "Director":
                    click.echo(u'Director: {}'.format(k["name"]))

        cast_range = min(10, len(
            crew_data['cast']))  # number of actors to be saved is less than 10

        # print actors for debugging
        if debug:
            for m in range(0, cast_range):
                click.echo(u'Actor: {}'.format(crew_data['cast'][m]['name']))

        # getting keywords for movie
        conn.request("GET", keywords.format(movie_id), payload)
        res = conn.getresponse()
        key_word_data = json.loads(res.read())

        # print keywords for debugging
        if debug:
            for keyword in key_word_data["keywords"]:
                click.echo(u'Keyword: {}'.format(keyword["name"]))

        if debug:
            save = ''
            while save != 'y' and save != 'n':
                save = click.prompt(
                    "\nDo you want to save the movie to database? \n(y) for \"yes\" and (n) for \"no\""
                )
        else:
            save = 'y'

        if save == 'y':
            movie_object.save()

            # populating genre database
            for j in movie_data['genre_ids']:
                if Genre.objects.filter(name=genre_dict[str(j)]):
                    genre_object = Genre.objects.filter(
                        name=genre_dict[str(j)])[0]
                    genre_object.movie_name.add(movie_object)
                else:
                    genre_object = Genre(name=genre_dict[str(j)])
                    genre_object.save()
                    genre_object.movie_name.add(movie_object)

            # populating director database
            for k in crew_data['crew']:
                if k['job'] == "Director":
                    if Director.objects.filter(name=k['name']):
                        director_object = Director.objects.filter(
                            name=k['name'])[0]
                        director_object.movie_name.add(movie_object)
                        break
                    else:
                        director_object = Director(name=k['name'])
                        director_object.save()
                        director_object.movie_name.add(movie_object)

            # populating actor database
            for m in range(0, cast_range):
                if Actor.objects.filter(name=crew_data['cast'][m]['name']):
                    actor_object = Actor.objects.filter(
                        name=crew_data['cast'][m]['name'])[0]
                    actor_object.movie_name.add(movie_object)
                else:
                    actor_object = Actor(name=crew_data['cast'][m]['name'])
                    actor_object.save()
                    actor_object.movie_name.add(movie_object)

            # populating keyword database
            for keyword in key_word_data["keywords"]:
                if Keyword.objects.filter(database_id=keyword["id"]):
                    keyword_object = Keyword.objects.filter(
                        database_id=keyword["id"])[0]
                    keyword_object.movie_name.add(movie_object)
                else:
                    keyword_object = Keyword(database_id=keyword["id"],
                                             name=keyword["name"])
                    keyword_object.save()
                    keyword_object.movie_name.add(movie_object)

            print(u"stored: {} {}\n".format(movie_data['title'],
                                            movie_data['release_date']))
        else:
            click.echo("Movie not stored in database")
Exemple #28
0
def add_movie(request):
    """
    POST: /api/movies/add/
    Specify the name ,producer, director_name, music_by, writer, cast,
    release_date, runtime, budget, country, language
    cast: comma seperated value of the star cast
    release_date: date specified in dd-mm-yyyy format
    runtime: in minutes
    budget: in dollars/inr
    """
    if request.method == "POST":
        
        movie_id = ""
        movie = Movie()
        try:
            movie.name = request.POST.get("name",)
            movie.producer = request.POST.get("producer")
            movie.director_name = request.POST.get("director_name")
            movie.writer = request.POST.get("writer")
            movie.music_by = request.POST.get("music_by")
            movie.cast = request.POST.get("cast")

            movie.release_date = datetime.strptime(request.POST.get("release_date"), '%d-%m-%Y')

            movie.runtime = int(request.POST.get("runtime"))
            movie.budget = int(request.POST.get("budget"))
            movie.country = request.POST.get("country")
            movie.language = request.POST.get("language")

            movie.save()
        except Exception,e:
            print e
            ####### Missing request parameters ###########
            response =  HttpResponse(json.dumps({"status": "unsuccessful"}), 
                content_type="application/json", status=404)
            response['Access-Control-Allow-Origin'] = '*'
            return response

        response = HttpResponse(json.dumps({"id": movie.id}), 
            content_type="application/json", status=200)
        response['Access-Control-Allow-Origin'] = '*'
        return response
Exemple #29
0
 def test_movie_string_representation(self):
     movie = Movie(title="Movie title")
     self.assertEqual(str(movie), movie.title)
Exemple #30
0
def create_movie_list_object(res_dic):
    if res_dic is not None and len(res_dic) != 0:
        movie_url = res_dic["story"][0]["link"]
        if movie_url != "":
            daum_code = movie_url.split("=")[1]

        movie = None

        try:
            movie = Movie.objects.get(daum_code=daum_code)
        except:
            title = res_dic["title"][0]["content"]
            genre = res_dic["genre"][0]["content"]
            story = res_dic["story"][0]["content"]
            movie_img = res_dic["thumbnail"][0]["content"]
            first_run_date = res_dic["open_info"][0]["content"]
            nation = res_dic["nation"][0]["content"]
            to_date = datetime.strptime(first_run_date.replace(".", "-"), "%Y-%m-%d")

            appear_dic = crawlingMixin.get_actor_director(movie_url)

            director_arr = [
                Director.objects.get_or_create(daum_code=director["daum_id"],
                                               defaults={
                                                   "name": director["name"],
                                                   "img": director["img"]})[0]
                for director in appear_dic["directors"]
                ]

            actor_arr = [
                {"actor": Actor.objects.get_or_create(daum_code=actor["daum_id"],
                                                      defaults={
                                                          "name": actor["name"],
                                                          "img": actor["img"]})[0],
                 "role": actor["role"]}
                for actor in appear_dic["actors"]
                ]

            movie = Movie(daum_code=daum_code,
                          title=title,
                          genre=genre,
                          story=story,
                          img=movie_img,
                          nation_code=nation)
            if to_date != "":
                movie.first_run_date = to_date.date()
            movie.save()

            movie.director.add(*director_arr)
            stillcut_list = [
                res_dic["photo"+str(i)]["content"].split("=")[1].replace("%3A", ":").replace("%2F","/")
                for i in range(1, 6)
            ]

            for img_url in stillcut_list:
                StillCut.objects.get_or_create(img=img_url,
                                               movie=movie)

            for actor in actor_arr:
                MovieActorDetail.objects.get_or_create(actor=actor["actor"],
                                                       movie=movie,
                                                       defaults={
                                                           "role": actor["role"]
                                                       })
        finally:
            return movie
    else:
        pass
Exemple #31
0
def read_databases():
    person_data = open("./databases/name.basics.tsv/data.tsv", "r")

    lines = person_data.readlines()
    for i in range(1, len(lines)):
        line = lines[i].strip().split("\t")
        try:
            person = Person.objects.get(imdb_id=line[0])
        except:
            person = Person(imdb_id=line[0],
                            name=line[1],
                            birth_year=line[2],
                            death_year=line[3],
                            primary_profession=line[4],
                            known_for_titles=line[5])
            person.save()
    person_data.close()

    crew_data = open("./databases/title.crew.tsv/data.tsv", "r")

    lines = crew_data.readlines()
    for i in range(1, len(lines)):
        line = lines[i].strip().split("\t")
        try:
            movie = Movie.objects.get(imdb_id=line[0])
        except:
            movie = Movie(imdb_id=line[0], directors=line[1], writers=line[2])
            movie.save()
    crew_data.close()

    principals_data = open("./databases/title.principals.tsv/data.tsv", "r")

    lines = principals_data.readlines()
    for i in range(1, len(lines)):
        line = lines[i].strip().split("\t")
        try:
            movie = Movie.objects.get(imdb_id=line[0])
            person = Person.objects.get(imdb_id=line[2])
        except:
            movie = Movie(imdb_id=line[0])
            person = Person(imdb_id=line[2])
            movie.save()
        if line[3] == 'director':
            movie.directors = line[3]
        elif line[3] == 'writer':
            movie.writers = line[3]
        elif line[3] == 'actor' or line[3] == 'actress':
            movie.casts.add(person)
        movie.save()

    principals_data.close()

    rating_data = open("./databases/title.ratings.tsv/data.tsv", "r")

    lines = rating_data.readlines()
    for i in range(1, len(lines)):
        line = lines[i].strip().split("\t")
        try:
            movie = Movie.objects.get(imdb_id=line[0])
        except:
            movie = Movie(imdb_id=line[0])
            movie.save()
        movie.imdb_rating = float(line[1])
        movie.imdb_num_votes = int(line[2])
        movie.save()

    rating_data.close()
Exemple #32
0
def download_movie(title):

    url = 'http://www.omdbapi.com/?{}={}&plot=full&apikey=4ae80ea6'.format(
        's', title)
    response = requests.get(url)
    for i in response.json()['Search']:
        if not Movie.objects.filter(title=i['Title']).exists():
            key = i['imdbID']
            response_two = requests.get(
                'http://www.omdbapi.com/?i={}&plot=full&apikey=4ae80ea6'.
                format(key))
            model = Movie()
            Title = response_two.json()['Title']
            model.title = response_two.json()['Title']
            duration = response_two.json()['Runtime']
            duration = duration.split()
            if duration[0] != 'N/A':
                model.duration = int(duration[0])
            model.detail = response_two.json()['Plot']
            gender = response_two.json()['Genre']
            gender = gender.split(',')
            model.gender = gender[0]
            model.original_languaje = response_two.json()['Language']
            model.country = response_two.json()['Country']
            release_date = response_two.json()['Released']
            if release_date != 'N/A':
                model.release_date = datetime.strptime(release_date,
                                                       '%d %b %Y')

            # Image
            image_url = response_two.json()['Poster']
            image_response = requests.get(image_url)
            image_response = image_response.content
            image = open(settings.MEDIA_ROOT + '/' + Title + '.jpg', 'wb')
            image.write(image_response)
            image.close()
            model.poster = Title + '.jpg'

            model.save()

            # Forey Key Actor
            Actors = response_two.json()['Actors']
            Actors = Actors.split(', ')
            tem_actor = []
            for actor in Actors:
                instance, get = Actor.objects.get_or_create(name=actor)
                tem_actor.append(instance)

            # Forey Key Director
            Directors = response_two.json()['Director']
            Directors = Directors.split(', ')
            tem_director = []
            for director in Directors:
                instance, get = Director.objects.get_or_create(name=director)
                tem_director.append(instance)

            model = Movie.objects.get(title=Title)
            for j in tem_actor:
                model.actors.add(j)

            for k in tem_director:
                model.directors.add(k)

            model.save()

    Suggest.objects.get(title=title).delete()

    return title
Exemple #33
0
def save_movie_data(movie_data):
    movie_data.pop('Response')
    new_movie_data = Movie(**movie_data)
    new_movie_data.save()
Exemple #34
0
from django.db.models import Q
from movie.models import Movie, Actor, Act
from .MngIMDB import MngIMDB, moviedata
movie_list = []
mng = MngIMDB()
movie_list = mng.load_data_from_csv()
mng.setUpClass()

for movie in movie_list:
    lookupsmovietitle = Q(title__icontains=movie.title)
    lookupsmovieid = Q(movieid__icontains=movie.movieid)
    movies = Movie.objects.filter(lookupsmovietitle
                                  | lookupsmovieid).distinct()
    if movies:
        continue
    newmovie = Movie()
    newmovie.title = movie.title
    newmovie.rate = movie.rate
    newmovie.year = movie.year
    genres = str(movie.genres)
    newmovie.genres = genres.replace(",", "|")
    newmovie.plot = movie.plot
    newmovie.length = movie.length
    results = mng.search_movie(movie.title)
    newmovie.poster = results['']
    newmovie.trailer = results['trailer']
    newmovie.movieid = results['movieid']
    newmovie.poster = results['poto']
    newmovie.rate = results['rateing']
    newmovie.save()
    actors = str(movie.actors).split(',')