*~

  __pycache__/

  #*

\ No newline at end of file

  # Author: Mike Ruckman <roshi@fedoraproject.org>

  import hug

  from sqlalchemy.orm import sessionmaker

  from marshmallow_sqlalchemy import ModelSchema

  session = Session()

  class ProjectSchema(ModelSchema):

      '''Make it so we can serialize our objects to json.'''

      class Meta:

          model = Project

  schema = ProjectSchema()

  @hug.directive()

  def cors(support="*", response=None, **kwargs):

      '''Set the 'Access-Control-Allow-Origin' header for all requests,

      '''

      response and response.set_header('Access-Control-Allow-Origin', '*')

  @hug.get(accept=('GET', 'OPTIONS'))

  def all(hug_cors):

      '''Return a list of all projects in the database.'''

      return [schema.dump(x).data for x in session.query(Project).all()]

  @hug.get()

  def migrated(hug_cors):

      '''Return a list of all migrated projects.'''

      migrated = [schema.dump(x).data for x in session.query(Project).filter_by(status=u'MIGRATED').all()]

  @hug.get()

  def working(hug_cors):

      '''Return a list of all working projects.'''

      return [schema.dump(x).data for x in session.query(Project).filter_by(status=u'WORKING').all()]

  @hug.get()

  def counts(hug_cors):

      '''Return the counts of each status.'''

  Base = declarative_base()

  class Project(Base):

      __tablename__ = 'projects'

      status = Column(String)

      pagure_link = Column(String)

      contact = Column(String)

      def get_project_issues(self):

          '''Update self.status to WORKING if there are issues attached to it.'''

          issues_url = config.API_URL + "{}/issues".format(self.name)

          issues = requests.get(issues_url)

          if issues.status_code == 404:

              logging.debug("Issues not found for: {}".format(self.name))

              return None

          issues = json.loads(issues.text)

          if issues['total_issues'] is not 0:

              self.update_status("WORKING")

          else:

      def update_status(self, status):

          self.status = status

  def get_session():

      '''Return a session object to interact with the database.'''

      Session.configure(bind=engine)

      return Session()

  def setup_database():

      '''Do the initial setup of the database. This should be run once.'''

      Base.metadata.create_all(engine)

      session = get_session()

      logging.info("Reading in the package list...\n")

      with open('UpstreamFirstPackageList.csv', 'r') as rawlist:

          packages = rawlist.readlines()

          # Remove the header row

          packages = packages[1:]

      logging.info("There are {} packages initially\n".format(len(packages)))

      for package in clean_list(packages):

          package = hawkey.split_nevra(package)

      # Now run the main() method to update with info from the forge.

      main()

  def clean_list(package_list):

      '''Clean out the packages that won't be getting tests for Fedora.'''

      clean = []

      for package in package_list:

          pname, comment = package.split(',')

          if "N/A" not in comment:

              clean.append(pname)

      return clean

  def parse_fork(project):

      '''Split out the information from a fork so we can update the status of the correct

      project.

      return project.split('/')[2]

  def update_project(project=None, poc=None, session=None):

      '''Query the database for an existing entry, if it exists, update it.

      If it doesn't exist, ignore it (since the database is pre-seeded with

              proj.update_status(u"MIGRATED")

          else:

              pass

          session.add(proj)

          session.commit()

          session.close()

  def main():

      '''Pull the data from the remote source, compare all items to what we have

      in the database and update anything that needs updated.

      '''

      session = get_session()

      upstream_tests = requests.get(config.API_URL + "projects")

      upstream_tests = json.loads(upstream_tests.text)['projects']

      session.commit()

      session.close()

  if __name__ == '__main__':

      parser = argparse.ArgumentParser(description='Script to update the local uf-monitor database.')

      parser.add_argument('--create', help='Initialize the database', action='store_true')

      engine = create_engine(config.DATASTORE, echo=False)

      args = parser.parse_args()