from __future__ import unicode_literals, print_function

  import sys

  import hubs.app

  import hubs.widgets

  Authors:    Ralph Bean <rbean@redhat.com>

  """

  import fedmsg.config

  config = fedmsg.config.load_config()

  for item in ['triage', 'work']:

      queue = retask.queue.Queue(config['hubs.redis.%s-queue-name' % item])

      queue.connect()

  Useful for testing what happens when you recreate them.

  """

  import fedmsg.config

  import hubs.models

  session = hubs.models.init(fedmsg_config['hubs.sqlalchemy.uri'])

  openid = '%s.id.fedoraproject.org' % username

  user = hubs.models.User.get(openid)

  if not user:

  else:

      session.delete(user)

  hub = hubs.models.Hub.get(username)

  if not hub:

  else:

      session.delete(hub)

  session.commit()

  # html_logo = None

  # The name of an image file (relative to this directory) to use as a favicon of

  #

  # html_favicon = None

  #

  # Authors:  Ralph Bean <rbean@redhat.com>

  config = dict(

      # Set this to dev if you're hacking on fedmsg or an app.

      # Set to stg or prod if running in the Fedora Infrastructure

      high_water_mark=0,

      io_threads=1,

      # This is a status dir to keep a record of the last processed message

      # This is the URL of a datagrepper instance that we can query for backlog.

      # We almost always want the fedmsg-hub to be sending messages with zmq as

      # opposed to amqp or stomp.

          ]

      },

      'fmn.url': 'https://apps.fedoraproject.org/notifications',

      # Run datanommer locally, just for development.

      'datanommer.enabled': True,

      # Only do one of these so we can try to not run out of memory.

      'moksha.workers_per_consumer': 1,

  from __future__ import unicode_literals

  import datetime

  import logging

  import os

  import flask

  import flask.json

  import munch

  from flask_oidc import OpenIDConnect

  import hubs.models

  from hubs.utils import username2avatar

  app = flask.Flask(__name__)

  if 'HUBS_CONFIG' in os.environ:

      app.config.from_envvar('HUBS_CONFIG')

  fedmsg_config = fedmsg.config.load_config()

  fedmsg.meta.make_processors(**fedmsg_config)

  session = hubs.models.init(fedmsg_config['hubs.sqlalchemy.uri'])

  datanommer.models.init(fedmsg_config['datanommer.sqlalchemy.uri'])

  @app.before_request

  def store_db():

      flask.g.db = session

  # Set up OpenIDConnect

  @app.before_request

          if not hasattr(flask.session, 'auth') or not flask.session.auth:

              flask.session.auth = munch.Munch(

                  fullname=OIDC.user_getfield('name'),

                  email=OIDC.user_getfield('email'),

                  timezone=OIDC.user_getfield('zoneinfo'),

                  groups=OIDC.user_getfield('groups'),

                  logged_in=True,

              )

                  flask.session.auth.nickname)

              flask.session.auth.user = hubs.models.User.by_username(

                  flask.session.auth.nickname)

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

  # Register widgets

  hubs.widgets.registry.register_list(app.config["WIDGETS"])

  # Register routes

  # Add widget-specific routes

  hubs.widgets.registry.register_routes(app)

  from __future__ import unicode_literals

  import fedmsg.config

  import fedmsg.meta

  import retask.queue

  log = logging.getLogger('hubs.backend.triage')

  def triage(session, outbound, msg):

      topic = msg['topic']

      for suffix in config['hubs.junk_suffixes']:

          if topic.endswith(suffix):

      return 0

  if __name__ == '__main__':

      sys.exit(main(sys.argv))

  from __future__ import unicode_literals

  import fedmsg.config

  import fedmsg.meta

  import retask.queue

  log = logging.getLogger('hubs.backend.worker')

  def work(widget_idx, fn_name):

      # Get a real widget, because we update last_refreshed on it.

      widget = hubs.models.Widget.by_idx(widget_idx)

      fn_class = widget.module.get_cached_functions()[fn_name]

      # Invalidate the cache...

      fn_class(widget).rebuild()

      # TODO -- fire off an EventSource notice that we updated stuff

              task = queue.wait()  # Wait forever...  timeout is optional.

              log.info("Working on %r.  (backlog is %r)" % (task, queue.length))

              item = json.loads(task.data)

              handle(item['idx'], item['fn_name'])

              log.debug("  Done.")

      except KeyboardInterrupt:

      return 0

  if __name__ == '__main__':

      sys.exit(main(sys.argv))

  # TODO - instead of 'develop', use the version from pkg_resources to figure out

  #        the right tag to link people to.  AGPL ftw.

  CHAT_NETWORKS = [

      {

      # Right Side Widgets

      widget = hubs.models.Widget(

          plugin='contact', index=-2,

      hub.widgets.append(widget)

      widget = hubs.models.Widget(

  from __future__ import absolute_import, unicode_literals

  from logging.config import fileConfig

  import fedmsg.config

  try:

  except ImportError:

      if "hubs" not in os.listdir("."):

          raise

      sys.path.append(os.getcwd())

  from hubs.models import BASE

  # This is the Alembic Config object, which provides

  # access to the values within the .ini file in use.

  # The config_file_name property may be None when used programatically.

      # This line sets up loggers basically.

      fileConfig(context.config.config_file_name)

  url = fedmsg_config['hubs.sqlalchemy.uri']

  target_metadata = BASE.metadata

          with context.begin_transaction():

              context.run_migrations()

  if context.is_offline_mode():

      run_migrations_offline()

  else:

  def upgrade():

          sa.Column('id', sa.Integer(), nullable=False),

          sa.Column('hub_id', sa.String(length=50), nullable=False),

          sa.Column('summary', sa.String(length=128), nullable=True),

          sa.Column('avatar', sa.String(length=256), nullable=True),

          sa.Column('header_img', sa.String(length=256), nullable=True),

          sa.ForeignKeyConstraint(['hub_id'], ['hubs.name'], ),

  def downgrade():

      connection = op.get_bind()

          sa.sql.column('name', sa.String),

          sa.sql.column('summary', sa.String),

          sa.sql.column('left_width', sa.Integer),

      )

      for row in connection.execute(query):

          op.execute(hubs_table.update().where(

              ).values({

                  "summary": op.inline_literal(row["summary"]),

                  "left_width": op.inline_literal(row["left_width"]),

  import random

  import bleach

  import sqlalchemy as sa

  from alembic import command as alembic_command

  log = logging.getLogger(__name__)

  def randomheader():

                          primary_key=True)

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

      @classmethod

      def get(cls, hub, user, role):

      name = sa.Column(sa.String(50), primary_key=True)

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

      widgets = relation('Widget', cascade='all,delete', backref='hub')

      archived = sa.Column(sa.Boolean, default=False)

      user_hub = sa.Column(sa.Boolean, default=False)

      # Timestamps about various kinds of "freshness"

          self._config = json.dumps(config)

      def __json__(self):

          module = hubs.widgets.registry[self.plugin]

          root_view = module.get_views()["root"](module)

          data = root_view.get_context(self)

      fullname = sa.Column(sa.Text)

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

      saved_notifications = relation('SavedNotification', backref='users',

      def __json__(self):

          return {

          # TODO -- someday make this editable/configurable.

          return sorted(list(set([

              assoc.hub for assoc in self.associations

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

      @classmethod

      __tablename__ = 'visit_counter'

      count = sa.Column(sa.Integer, default=0, nullable=False)

      @classmethod

      def by_username(cls, username):

      @classmethod

      def get_visits_by_username_hub(cls, username, visited_hub):

      @classmethod

      def increment_visits(cls, session, username, visited_hub):

      markup = sa.Column(sa.Text)

      secondary_icon = sa.Column(sa.Text)

          self.user = username

          self.markup = markup

          self.link = link

  from __future__ import unicode_literals

  import os

  class Stream(object):

      def get_json(self):

          here = os.path.dirname(os.path.abspath(__file__))

  from __future__ import unicode_literals

  from six.moves.urllib.parse import urlparse

  import hubs.tests

  from __future__ import unicode_literals

  import json

  import hubs.tests

  import hubs.models

                  "left_width": 8,

                  "avatar": (

                      "https://seccdn.libravatar.org/avatar/9c9f7784935381befc30"

                      ),

                  "chat_channel": None,

                  "chat_domain": None,

  from mock import Mock

  from hubs.tests import APPTest

  class TestingWidget(Widget):

      name = "testing"

  class TestingView(WidgetView):

      name = "root"

  class TestingFunction(CachedFunction):

      pass

      def test_validate(self):

          class LocalTestWidget(Widget):

              views = {}

              def get_views(self):

                  return self.views

          self.assertRaisesRegexp(

              AttributeError, '.* "name" .*', LocalTestWidget)

          LocalTestWidget.name = "invalid name \xe2\x98\xba"

              {"TestingFunction": TestingFunction}

              )

          class TestView1(WidgetView):

              name = "root"

              url_rules = ["/", "/test-1/"]

          class TestView2(WidgetView):

              name = "test2"

              url_rules = ["/test-2"]

          self.assertIn("testing_root",

                        self.app.application.url_map._rules_by_endpoint)

          self.assertIn("testing_root", self.app.application.view_functions)

          self.assertEqual(len(rules), 2)

          self.assertEqual(rules[0].rule, "/<hub>/w/testing/<int:idx>/")

          self.assertEqual(rules[1].rule, "/<hub>/w/testing/<int:idx>/test-1/")

          self.assertIn("testing_test2",

                        self.app.application.url_map._rules_by_endpoint)

          self.assertIn("testing_test2", self.app.application.view_functions)

          self.assertEqual(len(rules), 1)

          self.assertEqual(rules[0].rule, "/<hub>/w/testing/<int:idx>/test-2")

  from __future__ import unicode_literals

  import unittest

  from hubs.widgets import validators

  from hubs.tests import APPTest

  class ValidatorsTest(APPTest):

      def test_username(self):

          self.assertEqual(validators.Username.from_string("ralph"), "ralph")

      @unittest.skip("Not implemented yet")

      def test_github_organization(self):

  from __future__ import unicode_literals

  import json

  import hubs.models

  from hubs.tests import APPTest

          widget = hubs.models.Widget(

              plugin='library',

              index=51,

          )

          hub.widgets.append(widget)

          hubs.app.session.commit()

  import json

  import hubs.tests.test_widgets

  import json

  import hubs.tests.test_widgets

      def test_should_invalidate_wrong_user(self):

          widget = self.widget_instance('ralph', self.plugin)

          # msg = self.get_fedmsg('2016-e371c7f6-bc8e-4632-8e33-b9102dc30b5f')

          module = hubs.widgets.registry[widget.plugin]

          func = module.get_cached_functions()['GetBadges']

          result = func(widget).should_invalidate(msg)

      def test_should_invalidate_good_match_fedbadges(self):

          widget = self.widget_instance('ralph', self.plugin)

          # msg = self.get_fedmsg('2016-1fbb1135-681b-4d3b-9a40-d0f6ebd313f4')

          module = hubs.widgets.registry[widget.plugin]

          func = module.get_cached_functions()['GetBadges']

          result = func(widget).should_invalidate(msg)

      def test_should_invalidate_good_match_hubswidget(self):

          widget = self.widget_instance('ralph', self.plugin)

          # msg = self.get_fedmsg('2016-1fbb1135-681b-4d3b-9a40-d0f6ebd313f4')

          module = hubs.widgets.registry[widget.plugin]

          func = module.get_cached_functions()['GetBadges']

          result = func(widget).should_invalidate(msg)

  import hubs.tests.test_widgets

  import hubs.models

  class TestLibrary(hubs.tests.test_widgets.WidgetTest):

      plugin = 'library'  # The name in hubs.widgets.registry

  from __future__ import unicode_literals

  import logging

  from hashlib import sha256

  import arrow

  import markdown

  import requests

  from six.moves.urllib_parse import urlencode

  from __future__ import absolute_import

  from .root import *

  from .hub import *

  from .widget import *

          return flask.abort(400)

      flask.g.db.commit()

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

  import flask

  import hubs.models

  from .utils import get_hub, login_required, RequestValidator

  import flask

  import hubs.models