mirror of
https://github.com/YunoHost-Apps/seafile_ynh.git
synced 2024-09-03 20:26:01 +02:00
357 lines
14 KiB
Python
357 lines
14 KiB
Python
|
|
from service import ccnet_rpc, monitor_rpc, seafserv_rpc, \
|
|
seafserv_threaded_rpc, ccnet_threaded_rpc
|
|
|
|
"""
|
|
WebAccess:
|
|
|
|
string repo_id
|
|
string obj_id
|
|
string op
|
|
string username
|
|
"""
|
|
|
|
class SeafileAPI(object):
|
|
|
|
def __init__(self):
|
|
pass
|
|
|
|
# fileserver token
|
|
def get_fileserver_access_token(self, repo_id, obj_id, op, username):
|
|
"""Generate token for access file/dir in fileserver
|
|
|
|
op: the operation, 'view', 'download', 'download-dir'
|
|
|
|
Return: the access token in string
|
|
"""
|
|
return seafserv_rpc.web_get_access_token(repo_id, obj_id, op, username)
|
|
|
|
def query_fileserver_access_token(self, token):
|
|
"""Get the WebAccess object
|
|
|
|
token: the access token in string
|
|
|
|
Return: the WebAccess object
|
|
"""
|
|
return seafserv_rpc.web_query_access_token(token)
|
|
|
|
# password
|
|
def is_password_set(self, repo_id, username):
|
|
return seafserv_rpc.is_passwd_set(repo_id, username)
|
|
|
|
def get_decrypt_key(self, repo_id, username):
|
|
return seafserv_rpc.get_decrypt_key(repo_id, username)
|
|
|
|
# repo manipulation
|
|
def create_repo(self, name, desc, username, passwd):
|
|
return seafserv_threaded_rpc.create_repo(name, desc, username, passwd)
|
|
|
|
def create_enc_repo(self, repo_id, name, desc, username, magic, random_key, enc_version):
|
|
return seafserv_threaded_rpc.create_enc_repo(repo_id, name, desc, username, magic, random_key, enc_version)
|
|
|
|
def get_repo(self, repo_id):
|
|
return seafserv_threaded_rpc.get_repo(repo_id)
|
|
|
|
def remove_repo(self, repo_id):
|
|
return seafserv_threaded_rpc.remove_repo(repo_id)
|
|
|
|
def get_repo_list(self, start, limit):
|
|
return seafserv_threaded_rpc.get_repo_list(start, limit)
|
|
|
|
def edit_repo(self, repo_id, name, description, username):
|
|
return seafserv_threaded_rpc.edit_repo(repo_id, name, description, username)
|
|
|
|
def is_repo_owner(self, username, repo_id):
|
|
return seafserv_threaded_rpc.is_repo_owner(username, repo_id)
|
|
|
|
def set_repo_owner(self, email, repo_id):
|
|
return seafserv_threaded_rpc.set_repo_owner(email, repo_id)
|
|
|
|
def get_repo_owner(self, repo_id):
|
|
return seafserv_threaded_rpc.get_repo_owner(repo_id)
|
|
|
|
def get_owned_repo_list(self, username):
|
|
return seafserv_threaded_rpc.list_owned_repos(username)
|
|
|
|
def get_orphan_repo_list(self):
|
|
return seafserv_threaded_rpc.get_orphan_repo_list()
|
|
|
|
def get_repo_size(self, repo_id):
|
|
return seafserv_threaded_rpc.server_repo_size(repo_id)
|
|
|
|
def revert_repo(self, repo_id, commit_id, username):
|
|
return seafserv_threaded_rpc.revert_on_server(repo_id, commit_id, username)
|
|
|
|
def diff_commits(self, repo_id, old_commit, new_commit):
|
|
return seafserv_threaded_rpc.get_diff(repo_id, old_commit, new_commit)
|
|
|
|
def get_commit_list(self, repo_id, offset, limit):
|
|
return seafserv_threaded_rpc.get_commit_list(repo_id, offset, limit)
|
|
|
|
# repo permission checking
|
|
def check_repo_access_permission(self, repo_id, username):
|
|
"""
|
|
Returns 'rw', 'r' or None
|
|
"""
|
|
return seafserv_threaded_rpc.check_permission(repo_id, username)
|
|
|
|
# file/dir
|
|
def post_file(self, repo_id, tmp_file_path, parent_dir, filename, username):
|
|
"""Add a file to a directory"""
|
|
return seafserv_threaded_rpc.post_file(repo_id, tmp_file_path, parent_dir,
|
|
filename, username)
|
|
|
|
def post_empty_file(self, repo_id, parent_dir, filename, username):
|
|
return seafserv_threaded_rpc.post_empty_file(repo_id, parent_dir,
|
|
filename, username)
|
|
|
|
def put_file(self, repo_id, tmp_file_path, parent_dir, filename,
|
|
username, head_id):
|
|
"""Update an existing file
|
|
|
|
head_id: the original commit id of the old file
|
|
"""
|
|
return seafserv_threaded_rpc.put_file(repo_id, tmp_file_path, parent_dir,
|
|
filename, username, head_id)
|
|
|
|
def del_file(self, repo_id, parent_dir, filename, username):
|
|
return seafserv_threaded_rpc.del_file(repo_id, parent_dir, filename, username)
|
|
|
|
def copy_file(self, src_repo, src_dir, src_filename, dst_repo,
|
|
dst_dir, dst_filename, username, need_progress, synchronous=0):
|
|
return seafserv_threaded_rpc.copy_file(src_repo, src_dir, src_filename,
|
|
dst_repo, dst_dir, dst_filename,
|
|
username, need_progress, synchronous)
|
|
|
|
def move_file(self, src_repo, src_dir, src_filename, dst_repo, dst_dir,
|
|
dst_filename, username, need_progress, synchronous=0):
|
|
return seafserv_threaded_rpc.move_file(src_repo, src_dir, src_filename,
|
|
dst_repo, dst_dir, dst_filename,
|
|
username, need_progress, synchronous)
|
|
|
|
def get_copy_task(self, task_id):
|
|
return seafserv_rpc.get_copy_task(task_id)
|
|
|
|
def cancel_copy_task(self, task_id):
|
|
return seafserv_rpc.cancel_copy_task(task_id)
|
|
|
|
def rename_file(self, repo_id, parent_dir, oldname, newname, username):
|
|
return seafserv_threaded_rpc.rename_file(repo_id, parent_dir,
|
|
oldname, newname, username)
|
|
|
|
def is_valid_filename(self, repo_id, filename):
|
|
return seafserv_threaded_rpc.is_valid_filename(repo_id, filename)
|
|
|
|
def get_file_size(self, store_id, version, file_id):
|
|
return seafserv_threaded_rpc.get_file_size(store_id, version, file_id)
|
|
|
|
def get_file_id_by_path(self, repo_id, path):
|
|
return seafserv_threaded_rpc.get_file_id_by_path(repo_id, path)
|
|
|
|
def get_file_id_by_commit_and_path(self, repo_id, commit_id, path):
|
|
return seafserv_threaded_rpc.get_file_id_by_commit_and_path(repo_id,
|
|
commit_id, path)
|
|
|
|
def get_file_revisions(self, repo_id, path, max_revision, limit):
|
|
return seafserv_threaded_rpc.list_file_revisions(repo_id, path,
|
|
max_revision, limit)
|
|
|
|
def get_files_last_modified(self, repo_id, parent_dir, limit):
|
|
"""Get last modification time for files in a dir
|
|
|
|
limit: the max number of commits to analyze
|
|
"""
|
|
return seafserv_threaded_rpc.calc_files_last_modified(repo_id,
|
|
parent_dir, limit)
|
|
|
|
def post_dir(self, repo_id, parent_dir, dirname, username):
|
|
"""Add a directory"""
|
|
return seafserv_threaded_rpc.post_dir(repo_id, parent_dir, dirname, username)
|
|
|
|
def list_file_by_file_id(self, repo_id, file_id, offset=-1, limit=-1):
|
|
return seafserv_threaded_rpc.list_file(repo_id, file_id, offset, limit)
|
|
|
|
def get_dir_id_by_path(self, repo_id, path):
|
|
return seafserv_threaded_rpc.get_dir_id_by_path(repo_id, path)
|
|
|
|
def list_dir_by_dir_id(self, repo_id, dir_id, offset=-1, limit=-1):
|
|
return seafserv_threaded_rpc.list_dir(repo_id, dir_id, offset, limit)
|
|
|
|
def list_dir_by_path(self, repo_id, path, offset=-1, limit=-1):
|
|
dir_id = seafserv_threaded_rpc.get_dir_id_by_path(repo_id, path)
|
|
return seafserv_threaded_rpc.list_dir(repo_id, dir_id, offset, limit)
|
|
|
|
def list_dir_by_commit_and_path(self, repo_id,
|
|
commit_id, path, offset=-1, limit=-1):
|
|
dir_id = seafserv_threaded_rpc.get_dirid_by_path(repo_id, commit_id, path)
|
|
return seafserv_threaded_rpc.list_dir(repo_id, dir_id, offset, limit)
|
|
|
|
def get_dir_id_by_commit_and_path(self, repo_id, commit_id, path):
|
|
return seafserv_threaded_rpc.get_dirid_by_path(repo_id, commit_id, path)
|
|
|
|
def revert_file(self, repo_id, commit_id, path, username):
|
|
return seafserv_threaded_rpc.revert_file(repo_id, commit_id, path, username)
|
|
|
|
def revert_dir(self, repo_id, commit_id, path, username):
|
|
return seafserv_threaded_rpc.revert_dir(repo_id, commit_id, path, username)
|
|
|
|
def get_deleted(self, repo_id, show_days):
|
|
return seafserv_threaded_rpc.get_deleted(repo_id, show_days)
|
|
|
|
# share repo to user
|
|
def share_repo(self, repo_id, from_username, to_username, permission):
|
|
return seafserv_threaded_rpc.add_share(repo_id, from_username,
|
|
to_username, permission)
|
|
|
|
def get_share_out_repo_list(self, username, start, limit):
|
|
return seafserv_threaded_rpc.list_share_repos(username, "from_email",
|
|
start, limit)
|
|
|
|
def get_share_in_repo_list(self, username, start, limit):
|
|
return seafserv_threaded_rpc.list_share_repos(username, "to_email",
|
|
start, limit)
|
|
|
|
def remove_share(self, repo_id, from_username, to_username):
|
|
return seafserv_threaded_rpc.remove_share(repo_id, from_username,
|
|
to_username)
|
|
|
|
def set_share_permission(self, repo_id, from_username, to_username, permission):
|
|
return seafserv_threaded_rpc.set_share_permission(repo_id, from_username,
|
|
to_username, permission)
|
|
|
|
# share repo to group
|
|
def group_share_repo(self, repo_id, group_id, username, permission):
|
|
# deprecated, use ``set_group_repo``
|
|
return seafserv_threaded_rpc.group_share_repo(repo_id, group_id,
|
|
username, permission)
|
|
|
|
def set_group_repo(self, repo_id, group_id, username, permission):
|
|
return seafserv_threaded_rpc.group_share_repo(repo_id, group_id,
|
|
username, permission)
|
|
|
|
def group_unshare_repo(self, repo_id, group_id, username):
|
|
# deprecated, use ``unset_group_repo``
|
|
return seafserv_threaded_rpc.group_unshare_repo(repo_id, group_id, username)
|
|
|
|
def unset_group_repo(self, repo_id, group_id, username):
|
|
return seafserv_threaded_rpc.group_unshare_repo(repo_id, group_id, username)
|
|
|
|
def get_shared_groups_by_repo(self, repo_id):
|
|
return seafserv_threaded_rpc.get_shared_groups_by_repo(repo_id)
|
|
|
|
def get_group_repoids(self, group_id):
|
|
"""
|
|
Return the list of group repo ids
|
|
"""
|
|
repo_ids = seafserv_threaded_rpc.get_group_repoids(group_id)
|
|
if not repo_ids:
|
|
return []
|
|
l = []
|
|
for repo_id in repo_ids.split("\n"):
|
|
if repo_id == '':
|
|
continue
|
|
l.append(repo_id)
|
|
return l
|
|
|
|
def get_group_repo_list(self, group_id):
|
|
ret = []
|
|
for repo_id in self.get_group_repoids(group_id):
|
|
r = self.get_repo(repo_id)
|
|
if r is None:
|
|
continue
|
|
ret.append(r)
|
|
return ret
|
|
|
|
def get_group_repos_by_owner(self, username):
|
|
return seafserv_threaded_rpc.get_group_repos_by_owner(username)
|
|
|
|
def set_group_repo_permission(self, group_id, repo_id, permission):
|
|
return seafserv_threaded_rpc.set_group_repo_permission(group_id, repo_id,
|
|
permission)
|
|
|
|
# token
|
|
def generate_repo_token(self, repo_id, username):
|
|
"""Generate a token for sync a repo
|
|
"""
|
|
return seafserv_threaded_rpc.generate_repo_token(repo_id, username)
|
|
|
|
def delete_repo_token(self, repo_id, token, user):
|
|
return seafserv_threaded_rpc.delete_repo_token(repo_id, token, user)
|
|
|
|
def list_repo_tokens(self, repo_id):
|
|
return seafserv_threaded_rpc.list_repo_tokens(repo_id)
|
|
|
|
def list_repo_tokens_by_email(self, username):
|
|
return seafserv_threaded_rpc.list_repo_tokens_by_email(username)
|
|
|
|
# quota
|
|
def get_user_self_usage(self, username):
|
|
"""Get the sum of repos' size of the user"""
|
|
return seafserv_threaded_rpc.get_user_quota_usage(username)
|
|
|
|
def get_user_share_usage(self, username):
|
|
return seafserv_threaded_rpc.get_user_share_usage(username)
|
|
|
|
def get_user_quota(self, username):
|
|
return seafserv_threaded_rpc.get_user_quota(username)
|
|
|
|
def set_user_quota(self, username, quota):
|
|
return seafserv_threaded_rpc.set_user_quota(username, quota)
|
|
|
|
def check_quota(self, repo_id):
|
|
pass
|
|
|
|
# password management
|
|
def check_passwd(self, repo_id, magic):
|
|
return seafserv_threaded_rpc.check_passwd(repo_id, magic)
|
|
|
|
def set_passwd(self, repo_id, user, passwd):
|
|
return seafserv_threaded_rpc.set_passwd(repo_id, user, passwd)
|
|
|
|
def unset_passwd(self, repo_id, user, passwd):
|
|
return seafserv_threaded_rpc.unset_passwd(repo_id, user, passwd)
|
|
|
|
# organization wide repo
|
|
def add_inner_pub_repo(self, repo_id, permission):
|
|
return seafserv_threaded_rpc.set_inner_pub_repo(repo_id, permission)
|
|
|
|
def remove_inner_pub_repo(self, repo_id):
|
|
return seafserv_threaded_rpc.unset_inner_pub_repo(repo_id)
|
|
|
|
def get_inner_pub_repo_list(self):
|
|
return seafserv_threaded_rpc.list_inner_pub_repos()
|
|
|
|
def count_inner_pub_repos(self):
|
|
return seafserv_threaded_rpc.count_inner_pub_repos()
|
|
|
|
def is_inner_pub_repo(self, repo_id):
|
|
return seafserv_threaded_rpc.is_inner_pub_repo(repo_id)
|
|
|
|
|
|
# permission
|
|
def check_permission(self, repo_id, user):
|
|
return seafserv_threaded_rpc.check_permission(repo_id, user)
|
|
|
|
# virtual repo
|
|
def create_virtual_repo(self, origin_repo_id, path, repo_name, repo_desc, owner):
|
|
return seafserv_threaded_rpc.create_virtual_repo(origin_repo_id,
|
|
path,
|
|
repo_name,
|
|
repo_desc,
|
|
owner)
|
|
|
|
def get_virtual_repos_by_owner(self, owner):
|
|
return seafserv_threaded_rpc.get_virtual_repos_by_owner(owner)
|
|
|
|
# @path must begin with '/', e.g. '/example'
|
|
def get_virtual_repo(self, origin_repo, path, owner):
|
|
return seafserv_threaded_rpc.get_virtual_repo(origin_repo, path, owner)
|
|
|
|
def change_repo_passwd(self, repo_id, old_passwd, new_passwd, user):
|
|
return seafserv_threaded_rpc.change_repo_passwd(repo_id, old_passwd,
|
|
new_passwd, user)
|
|
|
|
def delete_repo_tokens_by_peer_id(self, username, device_id):
|
|
return seafserv_threaded_rpc.delete_repo_tokens_by_peer_id(username, device_id)
|
|
|
|
seafile_api = SeafileAPI()
|