Python DataHubConnection.add_collaborator方法代码示例

# 需要导入模块: from core.db.connection import DataHubConnection [as 别名]
# 或者: from core.db.connection.DataHubConnection import add_collaborator [as 别名]
class DataHubManager:
  def __init__(self, user, repo_base=None, is_app=False):
    username = None
    password = None
    
    if is_app:
      app = App.objects.get(app_id=user)
      username = app.app_id
      password = hashlib.sha1(app.app_token).hexdigest()
    else:
      user = User.objects.get(username=user)
      username = user.username
      password = user.password
    
    self.user_con = DataHubConnection(
        user=username,
        repo_base=repo_base,
        password=password)
  
  ''' Basic Operations. '''

  def reset_connection(self, repo_base):
    self.user_con.reset_connection(repo_base=repo_base)

  def close_connection(self):    
    self.user_con.close()
  
  def create_repo(self, repo):  
    return self.user_con.create_repo(repo=repo)

  def list_repos(self):
    return self.user_con.list_repos()

  def delete_repo(self, repo, force=False):
    return self.user_con.delete_repo(repo=repo, force=force)

  def list_tables(self, repo):
    return self.user_con.list_tables(repo=repo)

  def get_schema(self, table):
    return self.user_con.get_schema(table=table)

  def execute_sql(self, query, params=None):
    return self.user_con.execute_sql(query=query, params=params)

  def add_collaborator(self, repo, username, privileges, auto_in_future=True):
    return self.user_con.add_collaborator(
        repo=repo,
        username=username,
        privileges=privileges,
        auto_in_future=auto_in_future)

  def delete_collaborator(self, repo, username):
    return self.user_con.delete_collaborator(repo=repo, username=username)


  '''
  The following methods run in superuser mode only
  '''
  
  ''' User/Role Management '''
  
  @staticmethod
  def create_user(username, password, create_db=True):
    superuser_con = DataHubConnection(
        user=settings.DATABASES['default']['USER'],
        password=settings.DATABASES['default']['USER'])
    return superuser_con.create_user(
        username=username, password=password, create_db=create_db)

  @staticmethod
  def remove_user(username):
    superuser_con = DataHubConnection(
        user=settings.DATABASES['default']['USER'],
        password=settings.DATABASES['default']['USER'])
    return superuser_con.remove_user(username=username)

  @staticmethod
  def change_password(username, password):
    superuser_con = DataHubConnection(
        user=settings.DATABASES['default']['USER'],
        password=settings.DATABASES['default']['USER'])
    return superuser_con.change_password(username=username, password=password)

  ''' Import/Export Files '''
  
  @staticmethod
  def import_file(repo_base, table_name, file_path, file_format='CSV',
      delimiter=',', header=True, encoding='ISO-8859-1', quote_character='"'):
    superuser_con = DataHubConnection(
        user=settings.DATABASES['default']['USER'],
        password=settings.DATABASES['default']['USER'],
        repo_base=repo_base)
    return superuser_con.import_file(
        table_name=table_name,
        file_path=file_path,
        file_format=file_format,
        delimiter=delimiter,
        header=header,
        encoding=encoding,
#.........这里部分代码省略.........

# 需要导入模块: from core.db.connection import DataHubConnection [as 别名]
# 或者: from core.db.connection.DataHubConnection import add_collaborator [as 别名]
class DataHubManager:

    def __init__(self, user, repo_base=None, is_app=False):
        username = None
        password = None

        if is_app:
            app = App.objects.get(app_id=user)
            username = app.app_id
            password = hashlib.sha1(app.app_token).hexdigest()
        else:
            user = User.objects.get(username=user)
            username = user.username
            password = user.password

        if not repo_base:
            repo_base = username

        self.username = username
        self.repo_base = repo_base

        self.user_con = DataHubConnection(
            user=username,
            repo_base=repo_base,
            password=password)

    ''' Basic Operations. '''

    def change_repo_base(self, repo_base):
        """Changes the repo base and resets the DB connection."""
        self.user_con.change_repo_base(repo_base=repo_base)

    def close_connection(self):
        self.user_con.close()

    def create_repo(self, repo):
        return self.user_con.create_repo(repo=repo)

    def list_repos(self):
        return self.user_con.list_repos()

    def list_collaborator_repos(self):
        user = User.objects.get(username=self.username)
        return Collaborator.objects.filter(user=user)

    def delete_repo(self, repo, force=False):
        # Only a repo owner can delete repos.
        if self.repo_base != self.username:
            raise PermissionDenied(
                'Access denied. Missing required privileges')

        # remove related collaborator objects
        Collaborator.objects.filter(repo_name=repo).delete()

        # finally, delete the actual schema
        res = self.user_con.delete_repo(repo=repo, force=force)
        DataHubManager.delete_user_data_folder(self.repo_base, repo)
        return res

    def list_tables(self, repo):
        return self.user_con.list_tables(repo=repo)

    def list_views(self, repo):
        return self.user_con.list_views(repo=repo)

    def delete_table(self, repo, table, force=False):
        return self.user_con.delete_table(repo=repo, table=table, force=force)

    def get_schema(self, repo, table):
        return self.user_con.get_schema(repo=repo, table=table)

    def explain_query(self, query):
        return self.user_con.explain_query(query)

    def execute_sql(self, query, params=None):
        return self.user_con.execute_sql(query=query, params=params)

    def add_collaborator(self, repo, collaborator, privileges):
        """
        Grants a user or app privileges on a repo.

        - collaborator must match an existing User's username or an existing
        App's app_id.
        - privileges must be an array of SQL privileges as strings.
        """
        res = DataHubManager.has_repo_privilege(
            self.username, self.repo_base, repo, 'USAGE')
        if not res:
            raise PermissionDenied(
                'Access denied. Missing required privileges')

        # you can't add yourself as a collaborator
        if self.username == collaborator:
            raise Exception(
                "Can't add a repository's owner as a collaborator.")

        try:
            app = App.objects.get(app_id=collaborator)
            collaborator_obj, _ = Collaborator.objects.get_or_create(
                app=app, repo_name=repo, repo_base=self.repo_base)
#.........这里部分代码省略.........

# 需要导入模块: from core.db.connection import DataHubConnection [as 别名]
# 或者: from core.db.connection.DataHubConnection import add_collaborator [as 别名]

#.........这里部分代码省略.........
        """
        return self.user_con.clone_table(
            repo=repo, table=table, new_table=new_table)

    def get_schema(self, repo, table):
        """
        Lists a table or view's schema.

        Raises NameError if the repo or table/view does not exist.
        """
        return self.user_con.get_schema(repo=repo, table=table)

    def explain_query(self, query):
        """
        Returns the result of calling EXPLAIN on the query.

        Raises ProgrammingError on query syntax errors.
        Raises ProgrammingError on insufficient repo permissions.
        """
        return self.user_con.explain_query(query)

    def execute_sql(self, query, params=None):
        """
        Executes the query and returns its result.

        Raises ProgrammingError on query syntax errors.
        Raises ProgrammingError on insufficient repo permissions.
        Raises LookupError on invalid role or repo.
        Raises ValueError on invalid query parameters.
        Raises other psycopg2 errors depending on the query.
        """
        return self.user_con.execute_sql(query=query, params=params)

    def add_collaborator(
            self, repo, collaborator, db_privileges,
            file_privileges):
        """
        Grants a user or app privileges on a repo.

        - collaborator must match an existing User's username or an existing
        App's app_id.
        - db_privileges must be an array of SQL privileges as strings.
          e.g. ['SELECT', 'UPDATE', 'INSERT']
        - file_privileges must be an array of file privileges.
          e.g. ['read', 'write']

        Returns True on success.

        Raises ValueError if collaborator owns or is already a collaborator of
        repo or if db_privileges or file_privileges are invalid.
        Raises LookupError if repo does not exist.
        Raises User.DoesNotExist if collaborator does not exist.
        Raises PermissionDenied on insufficient permissions.
        """
        # Usage is probably not the right check, but neither is CREATE.
        # The trouble is that roles INHERIT permissions from one another
        # depending on whether that flag was set during creation... and I
        # haven't figured out a way to check on whether a user can grant
        # permission to another without actually doing it.
        # For now, we limit adding_collaborators to the actual owner, who has
        # create privileges
        DataHubManager.has_repo_db_privilege(
            self.username, self.repo_base, repo, 'CREATE')

        # you can't add yourself as a collaborator
        if self.username == collaborator: