quay/config_app/config_endpoints/api/superuser_models_interface.py

from abc import ABCMeta, abstractmethod
from collections import namedtuple
from six import add_metaclass

from config_app.config_endpoints.api import format_date


def user_view(user):
  return {
    'name': user.username,
    'kind': 'user',
    'is_robot': user.robot,
  }


class RepositoryBuild(namedtuple('RepositoryBuild',
                                 ['uuid', 'logs_archived', 'repository_namespace_user_username',
                                  'repository_name',
                                  'can_write', 'can_read', 'pull_robot', 'resource_key', 'trigger',
                                  'display_name',
                                  'started', 'job_config', 'phase', 'status', 'error',
                                  'archive_url'])):
  """
  RepositoryBuild represents a build associated with a repostiory
  :type uuid: string
  :type logs_archived: boolean
  :type repository_namespace_user_username: string
  :type repository_name: string
  :type can_write: boolean
  :type can_write: boolean
  :type pull_robot: User
  :type resource_key: string
  :type trigger: Trigger
  :type display_name: string
  :type started: boolean
  :type job_config: {Any -> Any}
  :type phase: string
  :type status: string
  :type error: string
  :type archive_url: string
  """

  def to_dict(self):

    resp = {
      'id': self.uuid,
      'phase': self.phase,
      'started': format_date(self.started),
      'display_name': self.display_name,
      'status': self.status or {},
      'subdirectory': self.job_config.get('build_subdir', ''),
      'dockerfile_path': self.job_config.get('build_subdir', ''),
      'context': self.job_config.get('context', ''),
      'tags': self.job_config.get('docker_tags', []),
      'manual_user': self.job_config.get('manual_user', None),
      'is_writer': self.can_write,
      'trigger': self.trigger.to_dict(),
      'trigger_metadata': self.job_config.get('trigger_metadata', None) if self.can_read else None,
      'resource_key': self.resource_key,
      'pull_robot': user_view(self.pull_robot) if self.pull_robot else None,
      'repository': {
        'namespace': self.repository_namespace_user_username,
        'name': self.repository_name
      },
      'error': self.error,
    }

    if self.can_write:
      if self.resource_key is not None:
        resp['archive_url'] = self.archive_url
      elif self.job_config.get('archive_url', None):
        resp['archive_url'] = self.job_config['archive_url']

    return resp


class Approval(namedtuple('Approval', ['approver', 'approval_type', 'approved_date', 'notes'])):
  """
  Approval represents whether a key has been approved or not
  :type approver: User
  :type approval_type: string
  :type approved_date: Date
  :type notes: string
  """

  def to_dict(self):
    return {
      'approver': self.approver.to_dict() if self.approver else None,
      'approval_type': self.approval_type,
      'approved_date': self.approved_date,
      'notes': self.notes,
    }


class ServiceKey(
  namedtuple('ServiceKey', ['name', 'kid', 'service', 'jwk', 'metadata', 'created_date',
                            'expiration_date', 'rotation_duration', 'approval'])):
  """
  ServiceKey is an apostille signing key
  :type name: string
  :type kid: int
  :type service: string
  :type jwk: string
  :type metadata: string
  :type created_date: Date
  :type expiration_date: Date
  :type rotation_duration: Date
  :type approval: Approval

  """

  def to_dict(self):
    return {
      'name': self.name,
      'kid': self.kid,
      'service': self.service,
      'jwk': self.jwk,
      'metadata': self.metadata,
      'created_date': self.created_date,
      'expiration_date': self.expiration_date,
      'rotation_duration': self.rotation_duration,
      'approval': self.approval.to_dict() if self.approval is not None else None,
    }


class User(namedtuple('User', ['username', 'email', 'verified', 'enabled', 'robot'])):
  """
  User represents a single user.
  :type username: string
  :type email: string
  :type verified: boolean
  :type enabled: boolean
  :type robot: User
  """

  def to_dict(self):
    user_data = {
      'kind': 'user',
      'name': self.username,
      'username': self.username,
      'email': self.email,
      'verified': self.verified,
      'enabled': self.enabled,
    }

    return user_data


class Organization(namedtuple('Organization', ['username', 'email'])):
  """
  Organization represents a single org.
  :type username: string
  :type email: string
  """

  def to_dict(self):
    return {
      'name': self.username,
      'email': self.email,
    }


@add_metaclass(ABCMeta)
class SuperuserDataInterface(object):
  """
  Interface that represents all data store interactions required by a superuser api.
  """

  @abstractmethod
  def list_all_service_keys(self):
    """
    Returns a list of service keys
    """