$ pip install -r requirements.txt

  With that, try running the app with::

      $ python populate.py  # To create the db

  You can run it with::

      $ pip install -r test-requirements.txt

  Some credentials...

  -------------------

  import json

  import logging

  import os

  import uuid

  import flask

  import pygments.formatters

  import six

  import fmn.lib

  import hubs.models

          and flask.g.auth.logged_in

  @app.template_filter('commas')

  def commas(numeric):

      return "{:,.2f}".format(numeric)

  @app.route('/')

  def index():

      if not authenticated():

      return flask.redirect(flask.url_for('hub', name=flask.g.auth.nickname))

  @app.route('/groups')

  def groups():

      if not authenticated():

      # Get the list of promoted and non-promoted group hubs from the DB

      promoted_names = app.config.get('PROMOTED_GROUPS')

      return flask.redirect(SOURCE_URL + fname)

  @app.route('/login/', methods=('GET', 'POST'))

  @app.route('/login', methods=('GET', 'POST'))

  def login():

      default = flask.url_for('index')

      next_url = flask.request.args.get('next', default)

  @app.route('/logout/')

  @app.route('/logout')

  def logout():

      return flask.redirect(next_url)

          if not authenticated():

              flask.flash('Login required', 'errors')

              return flask.redirect(flask.url_for(

          return function(*args, **kwargs)

  @app.before_request

  def check_auth():

      flask.g.fedmsg_config = fedmsg_config

  def get_hub(session, name):

  @login_required

  def hub_subscribe(hub):

      hub = get_hub(session, hub)

      hub.subscribe(session, user)

      session.commit()

      return flask.redirect(flask.url_for('hub', name=hub.name))

  @login_required

  def hub_unsubscribe(hub):

      hub = get_hub(session, hub)

      try:

          hub.unsubscribe(session, user)

      except KeyError:

  @login_required

  def hub_star(hub):

      hub = get_hub(session, hub)

      hub.subscribe(session, user, role='stargazer')

      session.commit()

      return flask.redirect(flask.url_for('hub', name=hub.name))

  @login_required

  def hub_unstar(hub):

      hub = get_hub(session, hub)

      try:

          hub.unsubscribe(session, user, role='stargazer')

      except KeyError:

  @login_required

  def hub_join(hub):

      hub = get_hub(session, hub)

      hub.subscribe(session, user, role='member')

      session.commit()

      return flask.redirect(flask.url_for('hub', name=hub.name))

  @login_required

  def hub_leave(hub):

      hub = get_hub(session, hub)

      try:

          hub.unsubscribe(session, user, role='member')

      except KeyError:

  SECRET_KEY = 'changemeforreal'

  PROMOTED_GROUPS = [

  ]

  HUB_OF_THE_MONTH = 'commops'

  class HubsBase(object):

          obj = type(self).__name__.lower()

          topic = obj + ".update"

          fedmsg.publish(

              topic=topic,

              msg=dict(

                  changed=changed,

              )

          )

                         sa.ForeignKey('hubs.name'),

                         primary_key=True)

      user_id = sa.Column(sa.Text,

                          primary_key=True)

      role = sa.Column(sa.Enum(*roles), primary_key=True)

  class User(BASE):

      __tablename__ = 'users'

      fullname = sa.Column(sa.Text)

      created_on = sa.Column(sa.DateTime, default=datetime.datetime.utcnow)

      def __json__(self, session):

          return {

              'username': self.username,

              'avatar': username2avatar(self.username),

              'fullname': self.fullname,

              'created_on': self.created_on,

              and assoc.hub.name != self.username

          ])), key=operator.attrgetter('name'))

      @classmethod

      def by_username(cls, session, username):

      @classmethod

      def all(cls, session):

          return session.query(cls).all()

      @classmethod

          if not self:

              session.add(self)

              if not Hub.by_name(session, self.username):

                  Hub.create_user_hub(session, self.username, self.fullname)

  import Feed from './components/Feed.jsx'

          </div>

          <img id="chaticon" class="pull-xs-right m-r-2" src="{{ url_for('static', filename='img/irc_icon.png') }}" alt="IRC Chats">

        {% else %}

        {% endif %}

      </div>

      <div class="col-sm-4 col-sm-pull-4 col-xs-12">

      def populate(self):

          for user in ['devyani7', 'dhrish', 'shalini', 'ralph', 'decause']:

              fullname = user.title()

              hubs.models.User.get_or_create(

          hubs.app.session.flush()

      def handler(sender, **kwargs):

          g.auth = auth

          if not auth:

              g.auth = munch.Munch(logged_in=False)

              supposed to be.

          """

          self.username = username

          self.booksmarks = []

      def __getitem__(self, key):

          self.logged_in = True

          self.fullname = 'fullname: ' + username

          self.email = 'email: ' + username

          self.user = FakeUser(username)

          self.avatar = 'avatar_src_url'

          self.nickname = username

              'plugin': 'feed'

          }

          with self.app.session_transaction() as sess:

              sess['nickname'] = 'atelic'

          with hubs.tests.auth_set(app, self.user):

              'plugin': 'feed'

          }

          with self.app.session_transaction() as sess:

              sess['nickname'] = 'atelic'

          with hubs.tests.auth_set(app, self.user):

          resp = self.app.post('/api/hub/{}/subscribe'.format(hub.name),

                               follow_redirects=False)

          self.assertEqual(resp.status_code, 302)

      def test_subscribe_when_logged_in(self):

          hub = hubs.models.Hub.by_name(self.session, 'infra')

          resp = self.app.post('/api/hub/{}/unsubscribe'.format(hub.name),

                               follow_redirects=False)

          self.assertEqual(resp.status_code, 302)

      def test_unsubscribe_when_logged_in(self):

          hub = hubs.models.Hub.by_name(self.session, 'infra')

          resp = self.app.post('/api/hub/{}/star'.format(hub.name),

                               follow_redirects=False)

          self.assertEqual(resp.status_code, 302)

      def test_star_when_logged_in(self):

          hub = hubs.models.Hub.by_name(self.session, 'infra')

          resp = self.app.post('/api/hub/{}/unstar'.format(hub.name),

                               follow_redirects=False)

          self.assertEqual(resp.status_code, 302)

      def test_unstar_when_logged_in(self):

          hub = hubs.models.Hub.by_name(self.session, 'infra')

          resp = self.app.post('/api/hub/{}/join'.format(hub.name),

                               follow_redirects=False)

          self.assertEqual(resp.status_code, 302)

      def test_join_when_logged_in(self):

          hub = hubs.models.Hub.by_name(self.session, 'infra')

          resp = self.app.post('/api/hub/{}/leave'.format(hub.name),

                               follow_redirects=False)

          self.assertEqual(resp.status_code, 302)

      def test_star_when_logged_in(self):

          hub = hubs.models.Hub.by_name(self.session, 'infra')

      def test_index_logged_out(self):

          result = self.app.get('/', follow_redirects=False)

          self.assertEqual(result.status_code, 302)

      def test_index_logged_in(self):

          user = tests.FakeAuthorization('ralph')

              # assert the status code of the response

              self.assertEqual(result.status_code, 200)

              self.assertFalse('Not logged in.  Click to <a href="'

      def test_hub_logged_out(self):

          with app.test_request_context('/ralph'):

              # need to manually call the @app.before_request

              # since unittest don't call it

              hubs.app.check_auth()

              # assert the status code of the response

              self.assertEqual(result.status_code, 200)

              str_expected = 'Not logged in.  Click to ' \

              self.assertTrue(str_expected in result.data)

      def test_groups_logged_out(self):

          # assert the status code of the response

          self.assertEqual(result.status_code, 302)

          # this will redirect to fedora.login

      def test_groups_logged_in(self):

          user = tests.FakeAuthorization('ralph')

              result = self.app.get('/ralph', follow_redirects=True)

              self.assertEqual(result.status_code, 200)

              self.assertFalse('Not logged in.  Click to <a href="'

      def test_hub_json(self):

          result = self.app.get('/ralph/json', follow_redirects=True)

                                     follow_redirects=True)

              self.assertEqual(result.status_code, 200)

              self.assertFalse('Not logged in.  Click to <a href="'

              self.assertTrue('<a href="#" class="dropdown-item">Full Name: '

                              'fullname: ralph</a>' in result.data)

          with tests.auth_set(app, user):

              result = self.app.get('/login', follow_redirects=False)

              self.assertEqual(result.status_code, 302)

      def test_hub_add_widget_get_no_args(self):

          result = self.app.get('/ralph/add', follow_redirects=False)

  class ModelTest(hubs.tests.APPTest):

      def test_delete_user(self):

          # verify user exists

          username = 'ralph'

          self.assertIsNotNone(user)

          # check if association exists

          # delete the user

          self.session.delete(user)

          self.assertIsNone(user)

          # checking to see if the hub is still intact

          # check if widgets still are intact

          widgets = hubs.models.Widget.by_hub_id_all(self.session, hub.name)

      def test_delete_hubs(self):

          # verify the hub exists

          hub_name = 'ralph'

          hub = hubs.models.Hub.get(self.session, hub_name)

          # check if association exists

          username = 'ralph'

          assoc = hubs.models.Association.get(self.session, hub, user, 'owner')

          self.assertIsNotNone(assoc)

          # check if widgets exist

          widgets = hubs.models.Widget.by_hub_id_all(self.session, hub.name)

          # delete the hub

          self.session.delete(hub)

          self.assertIsNone(hub)

          # check if user is still intact

          self.assertIsNotNone(user)

      def test_delete_user_then_hubs(self):

          username = 'ralph'

          self.assertIsNotNone(user)

          self.session.delete(user)

          self.assertIsNone(user)

          # checking to see if the hub is still intact

      def populate(self):

          for user in ['devyani7', 'dhrish', 'shalini', 'ralph', 'decause']:

              fullname = user.title()

              hubs.models.User.get_or_create(

          hubs.app.session.flush()

  def username(session, value):

  def github_organization(session, value):

      session = hubs.models.init(

          fedmsg_config['hubs.sqlalchemy.uri'], True, True)

      print "Querying FAS for the %r users.. hang on." % letter

      users = request['people']

      for user in users:

          username = user['username']

          fullname = user['human_name']

          print "Creating account for %r" % openid

          hubs_user = hubs.models.User.get_or_create(

      session.commit()

           'pravins', 'keekri', 'linuxmodder', 'bee2502', 'jflory7']

  for username in users:

      fullname = 'Full Name Goes Here'

      hubs.models.User.get_or_create(

  session.commit()

  # Set up some memberships

  session.commit()