Ejemplo n.º 1
0
def get_forums_list(account_id):
    public_key = settings.CONNECTED_ACCOUNTS_DISQUS_CONSUMER_KEY
    secret_key = settings.CONNECTED_ACCOUNTS_DISQUS_CONSUMER_SECRET
    disqus = DisqusAPI(secret_key=secret_key, public_key=public_key)

    forums = []

    try:
        connected_account = Account.objects.get(pk=account_id)
    except Account.DoesNotExist:
        raise DisqusAPIError(_('Account does not exist!'))
    else:
        try:
            forums_list = disqus.users.listForums(
                access_token=connected_account.get_token())
        except (APIError, InvalidAccessToken) as e:
            raise DisqusAPIError(e.message)
        else:
            for forum in forums_list:
                shortname = forum['id']
                label_from_instance = '{name} ({shortname})'.format(
                    name=forum['name'], shortname=shortname)
                forums.append((shortname, label_from_instance))

    return forums
Ejemplo n.º 2
0
def disqus_static(generator):
    disqus = DisqusAPI(generator.settings['DISQUS_SECRET_KEY'],
                       generator.settings['DISQUS_PUBLIC_KEY'])
    # first retrieve the threads
    threads = Paginator(disqus.threads.list,
                        forum=generator.settings['DISQUS_SITENAME'])
    # build a {thread_id: title} dict
    thread_dict = {}
    for thread in threads:
        thread_dict[thread['id']] = thread['title']

    # now retrieve the posts
    posts = Paginator(disqus.posts.list,
                      forum=generator.settings['DISQUS_SITENAME'])

    # build a {post_id: [child_post1, child_post2, ...]} dict
    child_dict = {}
    for post in posts:
        if post['id'] not in child_dict.keys():
            child_dict[post['id']] = []
        if post['parent'] is not None:
            if str(post['parent']) not in child_dict.keys():
                child_dict[str(post['parent'])] = []
            child_dict[str(post['parent'])].append(post)

    # build a {title: [post1, post2, ...]} dict
    post_dict = {}
    for post in posts:
        build_post_dict(post_dict, child_dict, thread_dict, post)

    for article in generator.articles:
        if article.title in post_dict:
            article.disqus_comments = post_dict[article.title]
            article.disqus_comment_count = sum(
                [postcounter(post) for post in post_dict[article.title]])
Ejemplo n.º 3
0
 def get(self):
   if not self.current_user_can('manage_disqus'):
     return self.write("not authorized")
   
   from disqusapi import DisqusAPI
   disqus = DisqusAPI(settings.get('disqus_secret_key'), settings.get('disqus_public_key'))
   for result in disqus.trends.listThreads():
       self.write(result)
Ejemplo n.º 4
0
def write_comments_api(posts):
    disqus = DisqusAPI(
        os.environ.get('DISQUS_SECRET'),
        os.environ.get('DISQUS_APIKEY'),
        )

    access_token = os.environ.get('DISQUS_ACCESS_TOKEN')

    for id, post in posts.items():
        if not post.get("comments"):
            continue

        thread_id = None
        title = post.get("title")
        date_added = post.get("date")
        url = "http://chase-seibert.github.com/blog/%s/%02d/%02d/%s.html" % (
                date_added.year,
                date_added.month,
                date_added.day,
                slugify(title))
        print url

        try:
            thread = disqus.threads.create(
                access_token=access_token,
                method="POST",
                forum="chaseseibertblog",
                title=title,
                url=url)
            print "Created thread: " + thread.get("id")
            thread_id = thread.get("id")
        except APIError:
            # already exists
            thread = disqus.threads.list(
                access_token=access_token,
                forum="chaseseibertblog",
                thread="link:%s" % url,
                )[0]
            print "Thread already exists: " + thread.get("id")
            thread_id = thread.get("id")

        for comment in post.get("comments", []):

            try:

                new_comment = disqus.posts.create(
                    access_token=access_token,
                    method="POST",
                    thread=thread_id,
                    message=comment.get("message"),
                    #author_name=comment.get("author"),
                    #author_email="*****@*****.**",
                    date=time.mktime(comment.get("date").timetuple()))

                print "Created comment: " + new_comment.get("id")
            except UnicodeEncodeError:
                pass
Ejemplo n.º 5
0
	def getDQComments(self):
		# http://disqus.com/api/docs/posts/list/
		# https://github.com/disqus/disqus-python
 		from disqusapi import DisqusAPI
 		from mezzanine.conf import settings
 		settings.use_editable()
 		
 		disqus = DisqusAPI(settings.COMMENTS_DISQUS_API_SECRET_KEY, settings.COMMENTS_DISQUS_API_PUBLIC_KEY)
 		posts = disqus.forums.listPosts(forum='digipal')
 		for post in posts:
 			print post
 		print posts
Ejemplo n.º 6
0
 def to_representation(self, instance):
     try:
         DISQUS = DisqusAPI(settings.DISQUS_SECRET_KEY, settings.DISQUS_PUBLIC_KEY)
         thread = 'link:%s' % settings.FORUM_URL_REGEX % (
         settings.SITE_DOMAIN, instance.competition.slug, instance.slug)
         instance.disqus_posts = DISQUS.threads.listPosts(
             method='GET',
             forum=settings.DISQUS_SHORTNAME,
             thread=thread,
             limit=1
         )
         instance.disqus_details = DISQUS.threads.details(
             method='GET',
             forum=settings.DISQUS_SHORTNAME,
             thread=thread
         )
     except Exception as e:
         instance.disqus_posts = {}
         instance.disqus_details = {}
     return super(ForumTopicListSerializer, self).to_representation(instance)
 def test_setKey(self):
     api = DisqusAPI('a')
     self.assertEquals(api.key, 'a')
     api.setKey('b')
     self.assertEquals(api.key, 'b')
 def test_users_listActivity(self):
     api = DisqusAPI(self.API_SECRET)
     self.assertRaises(APIError, api.users.listActivity, foo='bar')
 def test_setVersion(self):
     api = DisqusAPI()
     self.assertEquals(api.version, '3.0')
     api.setVersion('3.1')
     self.assertEquals(api.version, '3.1')
 def test_setFormat(self):
     api = DisqusAPI()
     self.assertEquals(api.format, 'json')
     api.setFormat('jsonp')
     self.assertEquals(api.format, 'jsonp')
Ejemplo n.º 11
0
import json
import os

from disqusapi import DisqusAPI, Paginator

disqus = DisqusAPI(secret_key="KEY_HERE", public_key="KEY_HERE")

p = Paginator(
    disqus.api,
    "users.listPosts",
    user="******",
    limit="100",
    order="asc",
    method="GET",
)

for post in p:
    try:
        filename = "comments/{0[createdAt]}_{0[id]}.json".format(post)
        with open(filename, "x") as f:
            json.dump(post, f)
    except FileExistsError:
        continue

for f in os.listdir("comments"):
    # Further processing…
    pass
Ejemplo n.º 12
0
def disqus():
    return DisqusAPI(settings.DISQUS_SECRET_KEY, settings.DISQUS_PUBLIC_KEY)
Ejemplo n.º 13
0
last_themes_num = 0
last_podcast_num = 0

last_response = None

user_themes_posts = None
user_themes_timestamp = 0

last_logs = ArrayHandler(max_count=200)
logging.basicConfig(format='%(asctime)-15s %(levelname)-8s %(message)s',
                    level=logging.INFO,
                    datefmt="%Y-%m-%d %H:%M:%S",
                    handlers=[logging.StreamHandler(), last_logs])
log = logging.getLogger()

disqus = DisqusAPI(public_key=DISQUS_PUBLIC_KEY)
disqus_thread_id = 0


def minutes_word(minutes):
    word = 'минут'
    if 11 <= minutes <= 14:
        pass
    elif minutes % 10 == 1:
        word += 'у'
    elif minutes % 10 in [2, 3, 4]:
        word += 'ы'
    return word


def hours_word(hours):
Ejemplo n.º 14
0
def get_apicli():
    return DisqusAPI(public_key=conf.API_KEY, secret_key=conf.API_SECRET)
Ejemplo n.º 15
0
 def test_setKey(self):
     api = DisqusAPI('a')
     self.assertEquals(api.key, 'a')
     api.setKey('b')
     self.assertEquals(api.key, 'b')
Ejemplo n.º 16
0
 def test_setVersion(self):
     api = DisqusAPI()
     self.assertEquals(api.version, '3.0')
     api.setVersion('3.1')
     self.assertEquals(api.version, '3.1')
Ejemplo n.º 17
0
 def test_setFormat(self):
     api = DisqusAPI()
     self.assertEquals(api.format, 'json')
     api.setFormat('jsonp')
     self.assertEquals(api.format, 'jsonp')
Ejemplo n.º 18
0
def backup_disqus(short_name,
                  key,
                  secret,
                  outfile,
                  min_comments=5,
                  verbose=False):
    """
    backup disqus threads and comments for a given forum shortname

    :param short_name: Disqus forum short name / ID
    :type short_name: string
    :param key: Disqus API public key
    :type key: string
    :param secret: Disqus API secret key
    :type secret: string
    :param outfile: path to the file to write JSON output to
    :type outfile: string
    :param min_comments: minimum number of posts to have, else error and exit
    :type min_comments: integer (default 5)
    :param verbose: whether to write verbose output
    :type verbose: boolean
    """
    result = {}
    disqus = DisqusAPI(secret, key)

    if verbose:
        print("Connected to Disqus API")
    try:
        details = disqus.forums.details(forum=short_name)
    except disqusapi.APIError:
        sys.stderr.write("ERROR: unable to find forum '%s'\n" % short_name)
        sys.exit(1)
    result['forum_details'] = details
    if verbose:
        print("Got forum details for '%s': %s" % (short_name, str(details)))

    try:
        threads = Paginator(disqus.forums.listThreads, forum=short_name)
    except APIError:
        sys.stderr.write("ERROR listing threads for forum '%s'\n" % short_name)
        sys.exit(1)
    thread_count = 0
    all_threads = []
    for t in threads:
        thread_count = thread_count + 1
        all_threads.append(t)
    if verbose:
        print("Found %d threads" % thread_count)

    result['threads'] = all_threads

    try:
        posts = Paginator(disqus.forums.listPosts,
                          forum=short_name,
                          include=['unapproved', 'approved'])
    except APIError:
        sys.stderr.write("ERROR listing posts for forum '%s'\n" % short_name)
        sys.exit(1)
    post_count = 0
    all_posts = []
    for p in posts:
        post_count = post_count + 1
        all_posts.append(p)
    if verbose:
        print("Found %d posts" % post_count)

    result['posts'] = all_posts

    j = anyjson.serialize(result)
    with open(outfile, 'w') as fh:
        fh.write(j)
    sys.stderr.write("Output written to %s\n" % outfile)
    return True
import functools
import simplejson
import urllib
import urllib2

from disqusapi import InvalidAccessToken
from disqusapi import DisqusAPI

## TODO: make this read from a file
public_key = "PUT YOUR KEY HERE"
secret_key = "PUT YOUR KEY HERE"

app.secret_key = "this is my salt"

disqus = DisqusAPI(secret_key, public_key)

################################################################################
## UTILS


class User(object):
    """User object based on disqus auth token"""
    def __init__(self, username, user_id, access_token, expires_in, token_type,
                 refresh_token):
        super(User, self).__init__()
        self.username = username
        self.user_id = user_id
        self.access_token = access_token
        self.expires_in = expires_in
        self.token_type = token_type
Ejemplo n.º 20
0
#!venv/bin/python

from pprint import pprint
from requests import post

from disqusapi import DisqusAPI
disqus = DisqusAPI(
    "tomRM9FzpoPUBVaTpj9EzJBi7EGtRRJHAK9LWO1LKQxphtyHLRF9Ryq7zrnhWGZc",
    "g0hQCAzqMrVq2M8DFwpQmnviE22ZSYw4AsuQbRkMTniMD3W5lpIzyvqWEbFNRHt2")
disqus.threads.list(forum='climbingroutes')
Ejemplo n.º 21
0
# coding=utf-8
from disqusapi import DisqusAPI
import time
import sys
import linecache
from datetime import datetime
import config
import os

most_likes = config.most_likes
limit_nr = config.limit_query  #lekerdezett posztok száma
top_replies_nr = config.most_popular_partners
disqus = DisqusAPI(config.secret_key, config.public_key)
listPosts_results = []

user = config.user
username = "******" + user

if not os.path.exists('dump'):
    os.makedirs('dump')

path = "dump/" + user
f = open(path, "w")
f_stat = open(path + "stats", "w")


class CountLikesDislikes:
    def __init__(self):
        time.sleep(0.1)
        self.likes = {}
        self.dislikes = {}