def track(request):
    if request.method == 'POST':
        form = UserForm(request.POST)

        if form.is_valid():
            user = form.cleaned_data['username']
            raw_feed = build_feed(user, 5, 2)

            f = Feed(username = user)
            f.save()

            for track in raw_feed:
                art_url = 'http://i.imgur.com/BNBFGfg.jpg'
                if track[5] != None:
                    art_url = track[5]

                t = Track(id = track[0]
                        , date = track[1]
                        , title = track[2]
                        , artist = track[3]
                        , uri = track[4]
                        , art = art_url)
                t.save()

                f.tracks.add(t)

            return HttpResponseRedirect('track.html')
    else:
        form = UserForm()

    return render(request, 'subs/track.html', { 'form': form })

def create_feed(user,board_id,title,link,description,actions,public_board,get_all,token):
    """ Creates a feed and attaches it to a user object """
    user = get_user(user)
    q = Feed.query(
        Feed.channel_title==title,
        Feed.channel_link==link,
        Feed.channel_description==description,
        Feed.feed_name==title,
        Feed.token==token,
        Feed.actions.IN(actions),
        Feed.board_id==board_id,
        Feed.public_board==public_board)
    feed = q.get()
    if feed is None:
        feed = Feed(
            channel_title=title,
            channel_link=link,
            channel_description=description,
            feed_name=title,
            token=token,
            actions=actions,
            board_id=board_id,
            public_board=public_board,
            get_all=get_all,user=user.key)
        feed.put()
    if user.feeds:
        if feed.key not in user.feeds:
            user.feeds.append(feed.key)
            user.put()
    else:
        user.feeds = [feed.key]
        user.put()
    return create_url(feed.key.id())

def create_feed_from_url(url):
    """ Query the given URL, parse the results and create a Feed object. If
        the response isn't RSS then throw an error """
    f = feedparser.parse(url)

    # Handle obvious errors
    if f.bozo:
        handle_bozo_exception(f.bozo_exception)

    if 'status' in f and f.status in (200, 301, 302):
        # If we received a bozo exception raise it
        if f.bozo:
            handle_bozo_exception(f.bozo_exception)

        # If the resource has permanently moved update it's URL
        feed_url = url
        if f.status == 301:
            feed_url = f.href

        feed = Feed(parent=root_key(), name=f.channel.title, url=feed_url)
        if len(f.entries) > 0:
            feed.date_of_last_entry = datetime.fromtimestamp(
                mktime(f.entries[0].updated_parsed))
        return feed
    else:
        raise Exception("Unexpected result from feedparser.parse(): %s" % f)

    def test_get_with_permanent_redirect(self):
        # Create a dummy feed with a last_checked date well in the past
        last_checked = datetime(2013, 9, 21, 10, 0, 0, 0)
        date_of_last_entry = datetime(2013, 9, 20, 8, 45, 0, 0)
        feed = Feed(name = "Test Feed1",
                    last_checked = last_checked,
                    date_of_last_entry = date_of_last_entry,
                    url = './test-feeds/test-rss.xml',
                    parent = root_key())
        feed.put()

        # Stub out the publish_entry function so we don't have to deal with
        # the GAE mail API
        def _publish_entry(feed_title, entry, recipent_address):
            pass
        feed_utils.publish_entry = _publish_entry

        # Create a dummy function to return the feeds to check
        def _find_feeds_to_check(working_date = datetime.now()):
            return [feed]
        feed_utils.find_feeds_to_check = _find_feeds_to_check

        # Replace feedparser.parse with our own version that sets the status
        # code to 301 and the href to a new URL
        def _parse(url):
            parsed_feed = self.orig_parse_func(url)
            parsed_feed['status'] = 301
            parsed_feed['href'] = 'http://def.com'
            return parsed_feed
        feedparser.parse = _parse

        response = self.testapp.get('/check_feeds')

        # check the feed's URL has been updated
        self.assertEquals(feed.url, 'http://def.com')

 def get_feeds(self, all = False):
     """Return feeds - defaults to returning enabled feeds only"""
     if all:
         result = [f for f in Feed.select()]
     else:
         result = [f for f in Feed.select(Feed.enabled == True)]
     return result

    def testFindFeedsToCheckMoreHoursThanFeeds(self):
        feeds = [
            {
                'name': 'Test 1',
                'last_checked': datetime(2017, 5, 6, 19, 7, 33)
            },
            {
                'name': 'Test 2',
                'last_checked': datetime(2017, 5, 5, 19, 6, 9)
            },
            {
                'name': 'Test 3',
                'last_checked': datetime(2017, 5, 4, 18, 23, 56)
            }
        ]

        for feed_data in feeds:
            feed = Feed(name = feed_data['name'],
                        last_checked = feed_data['last_checked'],
                        parent = root_key())
            feed.put()

        working_date = datetime(2017, 5, 6, 19, 45, 0)
        feeds = feed_utils.find_feeds_to_check(working_date)

        # there are 4 hours left in the day so only 1 feed will be returned
        self.assertEqual(1, len(feeds))
        self.assertEqual("Test 3", feeds[0].name)

def try_push_resub():
    """Post all new items for feeds for a specific interval"""
    if request.headers.get('X-Appengine-Cron') != 'true':
        raise ndb.Return(jsonify_error(message='Not a cron call'))

    unsubscribed_feeds = Feed.query(Feed.hub != None, Feed.subscribed_at_hub == False)  # noqa
    qit = unsubscribed_feeds.iter()

    errors = 0
    success = 0
    count = 0

    futures = []

    while (yield qit.has_next_async()):
        feed = qit.next()
        futures.append((feed, Feed.subscribe_to_hub(feed)))

    for feed, future in futures:
        count += 1
        try:
            yield future
            success += 1
        except:
            errors += 1
            logger.exception('Failed to PuSH subscribe feed:%s' % (feed.feed_url, ))

    logger.info('Tried to call hub for num_unsubscribed_feeds:%s success:%s, errors:%s', count, success, errors)

    raise ndb.Return(jsonify(status='ok'))

    def post(self):
        #表单字段： url, author, title, content, allow_sendto_kindle
        f = Feed()
        f.url = self.request.get('tUrl')
        f.title = self.request.get('tTitle')
        f.put(); # save

        return self.redirect('/feed')

 def create_feed(self, title, url, days_since_checked=0, days_since_updated=0, owner=None):
     now = timezone.now()
     feed = Feed(url=url, title=title,
                                last_checked=now + datetime.timedelta(days=days_since_checked),
                                last_updated=now + datetime.timedelta(days=days_since_checked + days_since_updated),
                                owner = owner or self.default_user)
     feed.save()
     return feed

 def add_feed(self, url, site_url = None, title = None, group = None):
     """Add a feed to the database"""
     # existing feed?
     try:
         f = Feed.get(Feed.url == url)
     except Feed.DoesNotExist:
         f = Feed.create(url = url, title=title, site_url=site_url)
     db.close()
     return f

def add_feed_github(request, user=None):
#    if user is None:
#        return 'fail'


    if request.user.is_authenticated():

        user = request.REQUEST['user']
        url = 'https://github.com/%s/' % user
        feed_url = 'https://github.com/%s.atom' % user

    #    feed, create = Feed.objects.get_or_create(title=user)

        category, created = Category.objects.get_or_create(name='github', slug='github')

        feed = Feed()
        feed.title = user
        feed.url = url
        feed.category = category
        feed.feed_url = feed_url
        feed.dt_checked = datetime.datetime(1, 1, 1, 0, 0, 0)
        feed.dt_updated = datetime.datetime(1, 1, 1, 0, 0, 0)
        feed.save()

        return HttpResponse('yay')

#        return HttpResponseRedirect('/admin/reader/feed/%d/' % (feed.id,))
    else:
        return 'h4axx0r..'

def create_photo_feed(feed_type, photo, photowalk=1):
    user = photo.user
    feed = Feed(photo=photo, user=user, feed_type=feed_type)
    if feed_type is 'photowalk':
        feed.photowalk = photowalk
    feed.save()
    for stalker in followers(user):
        wall = UserWall.objects.get(user=stalker)
        wall.feeds.add(feed)
        wall.save()
    return

def setup_database(db_file_path=settings.DB_FILE_PATH):
    """
        Connect the database.

        Create the database tables if they don't exists already.
    """
    # import models here to avoid circular references
    from models import BaseModel, Feed, FeedItem

    BaseModel.db.connect()

    Feed.create_table()
    FeedItem.create_table()

def feed_create():
    """List all examples"""
    form = FeedCreate(request.form)
    if not form.validate():
        return jsonify(status='error', message='The passed arguments failed validation')

    existing_feeds = Feed.for_user_and_url(user=g.user, feed_url=form.data['feed_url'])
    if existing_feeds.count():
        feed = existing_feeds.get()
    else:
        feed = Feed.create_feed_from_form(g.user, form).get_result()

    return jsonify(status='ok', data=feed.to_json())

def add_feed(url=None):
  
    # Get url submitted via AJAX
    url = request.json['url']

    FEED_TYPES = ('application/rss+xml',
                  'text/xml',
                  'application/atom+xml',
                  'application/x.atom+xml',
                  'application/x-atom+xml')

    # Check if url already exists in feed DB
    dupe = Feed.select().where(Feed.url == url).count()
    if dupe > 0:
        return jsonify(**DUPLICATE_FEED)

    # Attempt to retrieve URL
    try:
        r = requests.get(url, timeout=5)
    except requests.exceptions.Timeout:
        return jsonify(**FEED_NOT_FOUND)

    # check request status code
    if r.status_code != requests.codes.ok:
        return jsonify(**FEED_NOT_FOUND)

    # Get Content-Type
    contenttype = r.headers['content-type']

    # If Content-type is RSS, add it directly
    if contenttype in FEED_TYPES:
        feed = Feed.create(url=url)
        return jsonify(**STATUS_OK)
    
    # If Content-type is HTML, pass to autodiscovery
    if contenttype == 'text/html':

        p = autodiscovery.Discover()
        p.feed(r.text)

        # check result in case of no feeds found
        if len(p.feeds) == 0:
            return jsonify(**FEED_NOT_FOUND)
        else:
            # TODO: Could loop over all available feeds found?
            fulluri = p.feeds[0]['fulluri'] # just adds first feed found
            feed = Feed.create(url=fulluri)
            return jsonify(**STATUS_OK)

    # dropped through to here, feed must be invalid
    return jsonify(**FEED_INVALID)

    def test_check_feed_with_probem(self):
        last_checked = datetime(2000, 1, 1)
        date_of_last_entry = datetime(2000, 1, 1)
        feed_url = 'http://x.y.z'
        feed = Feed(name = "Test Feed",
                    last_checked = last_checked,
                    date_of_last_entry = date_of_last_entry,
                    url = feed_url,
                    parent = root_key())
        feed.put()

        # Replace feedparser.parse with our own version that sets the status
        # code to 500 to simulate a server side error
        def _parse(url):
            parsed_feed = FeedParserDict(status = 500, bozo = False)
            return parsed_feed
        feedparser.parse = _parse

        reported_title = [0]
        reported_message = [0]
        reported_recipient = [0]
        orig_report_error = feed_utils.report_error
        def _report_error(title, message, recipent_address):
            reported_title[0] = title
            reported_message[0] = message
            reported_recipient[0] = recipent_address
            orig_report_error(title, message, recipent_address)
        feed_utils.report_error = _report_error

        # run the method under test
        # set logging to CRITICAL so-as not to print exception generated by
        # the test
        try:
            logging.getLogger().setLevel(logging.CRITICAL)
            response = self.testapp.get('/check_feeds')
            self.assertEquals(reported_title[0], feed.name)
            self.assertTrue('returned HTTP code 500' in reported_message[0])
            self.assertEquals(reported_recipient[0], '[email protected]')
            #self.fail("Should have raised an exception as server returned 500")
        finally:
            logging.getLogger().setLevel(logging.ERROR)

        # there should be one email message describing the problem
        messages = self.mail_stub.get_sent_messages()
        self.assertEquals(1, len(messages))
        self.assertTrue("URL '%s' returned HTTP code 500" % feed_url in
            messages[0].body.payload)

        # check the feed's last_checked date was updated
        self.assertNotEqual(feed.last_checked, last_checked)

def api_feed(request):
    api_result = {"api": "feed", "status": "success"}

    try:
        token = request.GET["token"]
        user = get_user_from_token(token)
        group_id = 0
        try:
            group_id = request.GET["group_id"]
        except:
            pass

        page = 1
        try:
            page = int(request.GET["page"])
        except:
            pass

        page_size = 10
        try:
            page_size = int(request.GET["page_size"])
        except:
            pass

        if not user:
            api_result["status"] = "failure"
            api_result["error"] = "user not found"
        else:
            if group_id == 0:
                polls = Feed.user_feed(user, page, page_size)
            else:
                polls = Feed.group_feed(user, group_id, page, page_size)

            if page == 1 and not polls:
                # create_feed_new_user(user)
                # polls = Feed.user_feed(user, page, page_size)
                pass

            if polls:
                api_result["polls"] = json_polls(polls)
            else:
                api_result["polls"] = "None"
    except Exception as e:
        api_result["status"] = "failure"
        api_result["error"] = e.message
        pass

    return JsonResponse(api_result)

def post_all_feeds():
    """Post all new items for feeds for a specific interval"""
    if request.headers.get('X-Appengine-Cron') != 'true':
        raise ndb.Return(jsonify_error(message='Not a cron call'))

    feeds = Feed.query().iter()

    errors = 0
    success = 0
    num_posted = 0
    futures = []

    while (yield feeds.has_next_async()):
        feed = feeds.next()
        futures.append((feed, Entry.publish_for_feed(feed)))

    for feed, future in futures:
        try:
            num_posts = yield future
            if num_posts is not None:
                num_posted += num_posts
            success += 1
        except:
            errors += 1
            logger.exception('Failed to Publish feed:%s' % (feed.feed_url, ))

    logger.info('Post Feeds success:%s errors: %s num_posted: %s', success, errors, num_posted)

    raise ndb.Return(jsonify(status='ok'))

def feed_register (feed_url, user_id):
    feed_new = False
    
    #app.logger.info ("RSS LINK = " + feed_url) 
    feed = dboper.get_feed_by_rsslink(feed_url) #Check if it's already in the central repository
    if not feed:      ## New feed in the repository  
        feed_new = True                
        d = Feed.parse(feed_url)
        #app.logger.info(d.feed)
        if 'image' in d.feed:
            imgurl = d.feed.image.href
        else:
            imgurl = None
            
        if 'link' in d.feed:
            sitelink = d.feed.link
        else:
            sitelink = None
            
        feed = Feed (name=d.feed.title, rsslink=feed_url, image_url=imgurl,  sitelink=sitelink)
        dboper.add_feed(feed)                           #Add new feed to the repository (if not exist)
        #app.logger.info("NEW FEED: " + feed.name)  
    
    dboper.add_user_feed_by_id(user_id, feed)   #By user_id and not g.user because g object is lost in another thread
    #app.logger.info("ADDING NEW USER FEED: " + feed.name)  
    #if feed_new:                                    #If completely new, load articles 
    app.logger.info("LOADING ARTICLES " )  
    n = dboper.load_new_user_articles(feed, user_id)
    app.logger.info("Fetched: " + str(n))

def feed_update(id=None):

    # Manual update of one or all feeds now
    if request.json['action'] == 'refresh':
        
        # Call refresh routine
        # TODO: RSS worker functions in separate package
        # TODO: Need to capture return status
        if id is None:
            rss_spawn() # Update all feeds
        else:
            try:
                feed = Feed.get(Feed.id == id)
            except Feed.DoesNotExist:
                return jsonify(**FEED_NOT_FOUND)

            rss_worker(feed) # Update single feed
        
        # return JSON status OK
        return jsonify(**STATUS_OK)

    # Mark one or all feeds read
    elif request.json['action'] == 'markread':

        if id is None:
            # Mark all posts read
            query = Post.update(is_read=True)
        else:
            # Mark posts in current feed read
            query = Post.update(is_read=True).where(Feed.id == id)
            
        query.execute()
            
    # return JSON status OK
        return jsonify(**STATUS_OK)