Beispiel #1
0
    def _get_media(self, api, mid):
        media = spawn(api.media, mid)
        likes = spawn(api.media_likes, media_id=mid)
        gevent.joinall([media, likes])
        media, likes = media.get(), likes.get()
        errors = get_errors(media, likes)
        if errors:
            if any([e.error_type == 'APINotAllowedError' for e in errors]):
                return render('profile-noauth.html', ukey=request.ukey)
            app.logger.error([str(e) for e in errors])
            return notfound(u'服务器暂时出问题了')

        ukey = media.user.id
        isfollow = False
        if request.ukey:
            try:
                isfollow = is_follow(ukey, api)
            except InstagramAPIError:
                return notfound(u'服务器暂时出问题了')

        isstar = False
        for i in likes:
            if request.ukey and request.ukey == i.id:
                isstar = True

        isme = False
        if request.ukey and ukey == request.ukey:
            isme = True
        return dict(media=media, isme=isme, isfollow=isfollow,
                    likes=likes[:5], isstar=isstar)
Beispiel #2
0
 def get(self):
     wd = request.args.get("wd", "")
     api = InstagramAPI(access_token=request.access_token)
     tags = gevent.spawn(api.tag_search, wd)
     gevent.joinall([tags])
     try:
         tags = tags.get()
     except InstagramAPIError, e:
         if e.error_type == "APINotAllowedError":
             return render("search-tag.html", wd=wd)
         return notfound(u"服务器暂时出问题了")
Beispiel #3
0
    def get(self):
        next_url = request.args.get('next_url', None)

        api = InstagramAPI(access_token=request.access_token)
        feed = gevent.spawn(api.user_media_feed, with_next_url=next_url)

        gevent.joinall([feed])
        try:
            feed = feed.get()
        except InstagramAPIError:
            return notfound(u'服务器暂时出问题了')

        next_url = feed[1]
        media = feed[0]
        return render('feed.html', media=media, next_url=next_url)
Beispiel #4
0
    def _get_user_avatar(self, users, api):
        users_list = []
        users_dict = {}
        for user in users:
            user = gevent.spawn(api.user, user_id=user.ukey)
            users_list.append(user)

        try:
            gevent.joinall(users_list)
        except InstagramAPIError:
            return notfound(u'服务器暂时出问题了')
        for user in users_list:
            user = user.value
            if user:
                users_dict[user.id] = user.profile_picture
        return users_dict
Beispiel #5
0
 def get(self):
     if has_login():
         return redirect(url_for('view.members'))
     redirect_uri = INSTAGRAM_REDIRECT_URI
     if request.args.get('uri', ''):
         redirect_uri += '?uri=' + request.args.get('uri')
     api = InstagramAPI(client_id=INSTAGRAM_CLIENT_ID,
                        client_secret=INSTAGRAM_CLIENT_SECRET,
                        redirect_uri=redirect_uri)
     redirect_uri = gevent.spawn(api.get_authorize_login_url,
                                 scope=INSTAGRAM_SCOPE)
     gevent.joinall([redirect_uri])
     try:
         redirect_uri = redirect_uri.get()
     except InstagramAPIError:
         return notfound(u'服务器暂时出问题了')
     return redirect(redirect_uri)
Beispiel #6
0
    def get(self, name):
        next_url = request.args.get('next_url', None)

        api = InstagramAPI(access_token=request.access_token)
        tag = api.tag(name)
        media = api.tag_recent_media(tag_name=name,
                                     with_next_url=next_url)
        tag = gevent.spawn(api.tag, name)
        media = gevent.spawn(api.tag_recent_media,
                             tag_name=name, with_next_url=next_url)
        gevent.joinall([tag, media])
        try:
            tag, media = tag.get(), media.get()
        except InstagramAPIError:
            return notfound(u'服务器暂时出问题了')

        next_url = media[1]
        media = media[0]
        return render('tag.html', tag=tag, media=media, next_url=next_url)
Beispiel #7
0
 def get(self):
     likes = (LikeModel.query
              .filter(LikeModel.ukey == '448621019')
              .order_by(LikeModel.date_created.desc())
              .limit(5).all())
     access_token = random.choice(OPEN_ACCESS_TOKENS)
     api = InstagramAPI(access_token=access_token)
     media = api.media(likes[0].media)
     if isinstance(media, InstagramAPIError):
         return notfound(u'服务器暂时出问题了')
     medias = ShowModel.query.filter(
         ShowModel.mid.in_([x.media for x in likes[1:]]))
     users = (RecommendModel.query
              .order_by(RecommendModel.order.desc())
              .limit(24).all())
     return render('home.html',
                   media=media,
                   medias=medias,
                   users=users)
Beispiel #8
0
    def get(self, ukey):
        next_url = request.args.get('next_url', None)
        if next_url and 'instagram' not in next_url:
            next_url = signer.loads(next_url)
        api = InstagramAPI(access_token=request.access_token)

        user = gevent.spawn(wrap_errors(InstagramAPIError, api.user),
                            user_id=ukey)
        feeds = gevent.spawn(wrap_errors(InstagramAPIError,
                             api.user_recent_media),
                             user_id=ukey, with_next_url=next_url)
        if request.ukey:
            isfollows = spawn(isfollow, ukey, api)
        else:
            isfollows = spawn(lambda x: False, ukey)

        gevent.joinall([user, feeds, isfollows])
        user, feeds, isfollows = user.get(), feeds.get(), isfollows.get()
        errors = [e for e in (user, feeds, isfollows)
                  if isinstance(e, InstagramAPIError)]
        if errors:
            if any([e.error_type == 'APINotAllowedError' for e in errors]):
                return render('profile-noauth.html', ukey=ukey)
            if any([e.error_type == 'APINotFoundError' for e in errors]):
                return notfound(u'用户不存在')
            app.logger.error([str(e) for e in errors])
            return apierror(u'服务器暂时出问题了')

        next_url = feeds[1] if feeds else None
        next_url = signer.dumps(next_url) if next_url else next_url
        feeds = feeds[0] if feeds else []
        isme = False
        if request.ukey and ukey == request.ukey:
            isme = True
        return render(
            'profile.html',
            user=user,
            feeds=feeds,
            isme=isme,
            isfollow=isfollows,
            next_url=next_url
        )
Beispiel #9
0
    def _get_users(self, ukey, user_type='followed'):
        next_url = request.args.get('next_url', None)
        if next_url and 'instagram' not in next_url:
            next_url = signer.loads(next_url)
        api = InstagramAPI(access_token=request.access_token)
        user = spawn(api.user, ukey)
        if user_type == 'following':
            users = spawn(api.user_follows, ukey, with_next_url=next_url)
        else:
            users = spawn(api.user_followed_by, ukey, with_next_url=next_url)
        isfollows = False
        if request.ukey:
            isfollows = spawn(isfollow, ukey, api)
        else:
            isfollows = spawn(lambda x: False, ukey)

        gevent.joinall([user, users, isfollows])
        user, users, isfollows = user.get(), users.get(), isfollows.get()
        errors = get_errors(user, users, isfollows)
        if errors:
            app.logger.error([str(e) for e in errors])
            return notfound(u'服务器暂时出问题了')

        next_url = users[1]
        next_url = signer.dumps(next_url) if next_url else next_url
        users = users[0]

        isme = False
        if request.ukey and ukey == request.ukey:
            isme = True
        context = {
            'user': user,
            'users': users,
            'next_url': next_url,
            'isfollows': isfollows,
            'isme': isme,
        }
        return context