mirror of
https://github.com/PGYER/codefever.git
synced 2026-05-07 05:57:30 +08:00
2186 lines
72 KiB
PHP
Executable File
2186 lines
72 KiB
PHP
Executable File
<?php
|
||
require_once APPPATH . '/libraries/Avatars/MaterialDesign.Avatars.class.php';
|
||
require_once APPPATH . '/libraries/storage.php';
|
||
require_once APPPATH . '/controllers/api/base.php';
|
||
|
||
use service\Network\Request;
|
||
use service\Network\Response;
|
||
use service\Utility\Helper;
|
||
use service\AccessControl\UserAccessController;
|
||
use service\Utility\UUID;
|
||
use service\Constant\MergeRequestStatus;
|
||
|
||
class Repository extends Base
|
||
{
|
||
public function __construct()
|
||
{
|
||
parent::__construct();
|
||
$this->load->model('Repository_model', 'repositoryModel');
|
||
$this->load->model('Group_model', 'groupModel');
|
||
}
|
||
|
||
public function create_post()
|
||
{
|
||
$userInfo = Request::parse()->authData['userData'];
|
||
$data = Request::parse()->parsed;
|
||
|
||
// check input
|
||
if (!$data['displayName'] || !$data['group'] || !$data['name']) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
// check group permission
|
||
if (!$this->service->requestGroupPermission(
|
||
$data['group'],
|
||
$userInfo['u_key'],
|
||
UserAccessController::UAC_GROUP_CREATE_REPO
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
// check duplicate
|
||
$result = $this->repositoryModel->searchByName($data['name'], $data['group']);
|
||
if ($result) {
|
||
Response::reject(0x0401);
|
||
}
|
||
|
||
$result = $this->repositoryModel->searchByDisplayName($data['displayName'], $data['group']);
|
||
if ($result) {
|
||
Response::reject(0x0402);
|
||
}
|
||
|
||
// create repository
|
||
$result = $this->repositoryModel->create(
|
||
$data['displayName'],
|
||
$data['name'],
|
||
$data['description'],
|
||
$data['group'],
|
||
$userInfo['u_key']
|
||
);
|
||
|
||
if ($result) {
|
||
$groupInfo = $this->groupModel->get($result['g_key']);
|
||
|
||
$this->service->newEvent('REPO_CREATE', [
|
||
'rKey' => $result['r_key'],
|
||
'gKey' => $result['g_key'],
|
||
'name' => $groupInfo['g_display_name'] . '/' . $result['r_display_name']
|
||
], $userInfo['u_key']);
|
||
|
||
$createdData = $this->repositoryModel->get($result['r_key']);
|
||
$createdData = $this->repositoryModel->normalize([$createdData])[0];
|
||
Response::output($createdData);
|
||
}
|
||
|
||
return Response::reject(0x0405);
|
||
}
|
||
|
||
public function fork_post()
|
||
{
|
||
$userInfo = Request::parse()->authData['userData'];
|
||
$data = Request::parse()->parsed;
|
||
|
||
// check input
|
||
if (!$data['displayName'] || !$data['group'] || !$data['name'] || !$data['forkID']) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
// check source reposiroty permission
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$data['forkID'],
|
||
$userInfo['u_key'],
|
||
UserAccessController::UAC_REPO_READ
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
// check group permission
|
||
if (!$this->service->requestGroupPermission(
|
||
$data['group'],
|
||
$userInfo['u_key'],
|
||
UserAccessController::UAC_GROUP_CREATE_REPO
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
// check duplicate
|
||
$result = $this->repositoryModel->searchByName($data['name'], $data['group']);
|
||
if ($result) {
|
||
Response::reject(0x0401);
|
||
}
|
||
|
||
$result = $this->repositoryModel->searchByDisplayName($data['displayName'], $data['group']);
|
||
if ($result) {
|
||
Response::reject(0x0402);
|
||
}
|
||
|
||
// create repository
|
||
$result = $this->repositoryModel->fork(
|
||
$data['displayName'],
|
||
$data['name'],
|
||
$data['description'],
|
||
$data['group'],
|
||
$userInfo['u_key'],
|
||
$data['forkID']
|
||
);
|
||
|
||
if ($result) {
|
||
$sourceRepoInfo = $this->repositoryModel->get($result['r_fork_r_key']);
|
||
$sourceGroupInfo = $this->groupModel->get($sourceRepoInfo['g_key']);
|
||
|
||
$targetGroupInfo = $this->groupModel->get($result['g_key']);
|
||
|
||
$this->service->newEvent('REPO_FORK', [
|
||
'rKey' => $result['r_key'],
|
||
'gKey' => $result['g_key'],
|
||
'forkFrom' => $result['r_fork_r_key'],
|
||
'name' => $targetGroupInfo['g_display_name'] . '/' . $result['r_display_name'],
|
||
'sourceName' => $sourceGroupInfo['g_display_name'] . '/' . $sourceRepoInfo['r_display_name']
|
||
], $userInfo['u_key']);
|
||
|
||
$createdData = $this->repositoryModel->get($result['r_key']);
|
||
$createdData = $this->repositoryModel->normalize([$createdData])[0];
|
||
Response::output($createdData);
|
||
}
|
||
|
||
return Response::reject(0x0405);
|
||
}
|
||
|
||
public function list_get()
|
||
{
|
||
$userInfo = Request::parse()->authData['userData'];
|
||
$list = $this->repositoryModel->listJoined($userInfo['u_key']);
|
||
$list = $this->repositoryModel->normalize($list);
|
||
|
||
foreach ($list as &$item) {
|
||
$item['role'] = $this->repositoryModel->getMemberRole($item['id'], $userInfo['u_key']);
|
||
$item['members'] = $this->repositoryModel->getMembers($item['id']);
|
||
}
|
||
|
||
Response::output($list);
|
||
}
|
||
|
||
public function config_get()
|
||
{
|
||
$userInfo = Request::parse()->authData['userData'];
|
||
$rKey = Request::parse()->query['rKey'];
|
||
$uKey = $userInfo['u_key'];
|
||
|
||
if (!$uKey || !$rKey) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$rKey,
|
||
$uKey,
|
||
UserAccessController::UAC_REPO_READ
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
$config = [];
|
||
$config['repository'] = $this->repositoryModel->get($rKey);
|
||
$config['repository'] = $this->repositoryModel->normalize([$config['repository']])[0];
|
||
|
||
$config['group'] = $this->groupModel->get($config['repository']['group']['id']);
|
||
$config['group'] = $this->groupModel->normalize([$config['group']])[0];
|
||
|
||
$config['members'] = $this->repositoryModel->getMembers($rKey);
|
||
|
||
$config['branches'] = $this->repositoryModel->getBranchList($rKey, $uKey);
|
||
$config['branches'] = $this->repositoryModel->normalizeBranches($config['branches']);
|
||
|
||
$config['tags'] = $this->repositoryModel->getTagList($rKey, $uKey);
|
||
$config['tags'] = $this->repositoryModel->normalizeTags($config['tags']);
|
||
|
||
$countObjects = $this->repositoryModel->getObjectsCount($rKey, $uKey);
|
||
|
||
$config['count'] = [
|
||
'commit' => (int) $this->repositoryModel->getCommitCount($rKey, $uKey, $config['repository']['defaultBranch'] ?: ($config['branches'] ? $config['branches'][0]['name'] : '')),
|
||
'branch' => count($config['branches']),
|
||
'tag' => count($config['tags']),
|
||
'file' => ((int) $countObjects['size'] + (int) $countObjects['size-pack'] + (int) $countObjects['size-garbage']) * 1024,
|
||
'mergeRequest' => $this->repositoryModel->countMergeRequests($rKey),
|
||
];
|
||
|
||
Response::output($config);
|
||
}
|
||
|
||
public function activities_get()
|
||
{
|
||
$userInfo = Request::parse()->authData['userData'];
|
||
$rKey = Request::parse()->query['repository'];
|
||
$category = Request::parse()->query['category'];
|
||
$keyword = Request::parse()->query['keyword'];
|
||
$uKey = $userInfo['u_key'];
|
||
|
||
$page = Request::parse()->query['page'];
|
||
$pagesize = Request::parse()->query['pagesize'];
|
||
|
||
$mrKey = Request::parse()->query['mergeRequest'];
|
||
|
||
if (!$rKey || ($category && !in_array($category, [ACTIVITY_CATEGORY_COMMIT, ACTIVITY_CATEGORY_MERGE_REQUEST, ACTIVITY_CATEGORY_MEMBER]))) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$rKey,
|
||
$uKey,
|
||
UserAccessController::UAC_REPO_READ
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
if ($mrKey) {
|
||
$activities = $this->repositoryModel->listMergeRequestActivities($rKey, $mrKey);
|
||
} else {
|
||
$activities = $this->repositoryModel->listActivities($rKey, $category, $keyword, $page, $pagesize);
|
||
}
|
||
$activities = $this->repositoryModel->normalizeActivities($activities);
|
||
|
||
Response::output($activities);
|
||
}
|
||
|
||
public function uploadAvatar_post()
|
||
{
|
||
$userInfo = Request::parse()->authData['userData'];
|
||
$data = Request::parse()->parsed;
|
||
$tmpName = $_FILES['avatar']['tmp_name'];
|
||
$uKey = $userInfo['u_key'];
|
||
|
||
if (!$data['repository'] || !$tmpName) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
// check reposiroty permission
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$data['repository'],
|
||
$userInfo['u_key'],
|
||
UserAccessController::UAC_REPO_CHANGE_INFO
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
$key = UUID::getKey();
|
||
$storage = Storage::factory('avatar');
|
||
$path = $storage->getPathByFileName($key);
|
||
$storage->moveUploadFile($tmpName, $path);
|
||
|
||
$this->repositoryModel->update($data['repository'], ['r_avatar' => $key]);
|
||
$repositoryInfo = $this->repositoryModel->get($data['repository']);
|
||
|
||
$this->service->newEvent('REPO_UPDATE_AVATAR', [
|
||
'rKey' => $repositoryInfo['r_key'],
|
||
'gKey' => $repositoryInfo['g_key'],
|
||
'from' => $repositoryInfo['r_avatar'],
|
||
'to' => $key
|
||
], $uKey);
|
||
|
||
Response::output([]);
|
||
}
|
||
|
||
public function update_post()
|
||
{
|
||
$userInfo = Request::parse()->authData['userData'];
|
||
$data = Request::parse()->parsed;
|
||
$uKey = $userInfo['u_key'];
|
||
|
||
if (!$data['repository'] || !$data['displayName']) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
// check reposiroty permission
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$data['repository'],
|
||
$userInfo['u_key'],
|
||
UserAccessController::UAC_REPO_CHANGE_INFO
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
// check display name duplicate
|
||
$repositoryInfo = $this->repositoryModel->get($data['repository']);
|
||
if ($repositoryInfo['r_display_name'] !== $data['displayName']) {
|
||
$result = $this->repositoryModel->searchByDisplayName($data['displayName'], $repositoryInfo['g_key']);
|
||
if ($result) {
|
||
Response::reject(0x0402);
|
||
}
|
||
}
|
||
|
||
$this->repositoryModel->update($data['repository'], [
|
||
'r_display_name' => $data['displayName'],
|
||
'r_description' => $data['description']
|
||
]);
|
||
|
||
if ($repositoryInfo['r_display_name'] !== $data['displayName']) {
|
||
$this->service->newEvent('REPO_UPDATE_NAME', [
|
||
'rKey' => $repositoryInfo['r_key'],
|
||
'gKey' => $repositoryInfo['g_key'],
|
||
'from' => $repositoryInfo['r_display_name'],
|
||
'to' => $data['displayName']
|
||
], $uKey);
|
||
}
|
||
|
||
if ($repositoryInfo['r_description'] !== $data['description']) {
|
||
$this->service->newEvent('REPO_UPDATE_DESCRIPTION', [
|
||
'rKey' => $repositoryInfo['r_key'],
|
||
'gKey' => $repositoryInfo['g_key']
|
||
], $uKey);
|
||
}
|
||
|
||
Response::output([]);
|
||
}
|
||
|
||
public function updateName_post()
|
||
{
|
||
$userInfo = Request::parse()->authData['userData'];
|
||
$data = Request::parse()->parsed;
|
||
|
||
// check input
|
||
if (!$data['repository'] || !$data['name']) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
// check group permission
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$data['repository'],
|
||
$userInfo['u_key'],
|
||
UserAccessController::UAC_REPO_CHANGE_URL
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
// check duplicate
|
||
$repositoryInfo = $this->repositoryModel->get($data['repository']);
|
||
$result = $this->repositoryModel->searchByName($data['name'], $repositoryInfo['g_key']);
|
||
if ($result) {
|
||
Response::reject(0x0401);
|
||
}
|
||
|
||
$this->repositoryModel->update($data['repository'], [
|
||
'r_name' => $data['name']
|
||
]);
|
||
|
||
$groupInfo = $this->groupModel->get($repositoryInfo['g_key']);
|
||
|
||
$this->service->newEvent('REPO_CHANGE_URL', [
|
||
'rKey' => $repositoryInfo['r_key'],
|
||
'gKey' => $repositoryInfo['g_key'],
|
||
'from' => $groupInfo['g_name'] . '/' . $repositoryInfo['r_name'],
|
||
'to' => $groupInfo['g_name'] . '/' . $data['name']
|
||
], $userInfo['u_key']);
|
||
|
||
Response::output([]);
|
||
}
|
||
|
||
public function addMember_post()
|
||
{
|
||
$userInfo = Request::parse()->authData['userData'];
|
||
$data = Request::parse()->parsed;
|
||
$uKey = $userInfo['u_key'];
|
||
|
||
if (!$data['repository'] || !$data['email']) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
// check reposiroty permission
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$data['repository'],
|
||
$userInfo['u_key'],
|
||
UserAccessController::UAC_REPO_CHANGE_MEMBER
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
// check user data
|
||
$memberInfo = $this->userModel->getInfoByEmail($data['email']);
|
||
if (!$memberInfo) {
|
||
Response::reject(0x0407);
|
||
}
|
||
|
||
// check user already in repository
|
||
$repositoryInfo = $this->repositoryModel->get($data['repository']);
|
||
|
||
// can not add creator
|
||
if ($repositoryInfo['u_key'] === $memberInfo['u_key']) {
|
||
Response::reject(0x0408);
|
||
}
|
||
|
||
$result = $this->repositoryModel->addMember($memberInfo['u_key'], $data['repository']);
|
||
if (!$result) {
|
||
Response::reject(0x0405);
|
||
}
|
||
|
||
$this->service->newEvent('REPO_ADD_MEMBER', [
|
||
'rKey' => $repositoryInfo['r_key'],
|
||
'gKey' => $repositoryInfo['g_key'],
|
||
'uid' => $memberInfo['u_key'],
|
||
'name' => $memberInfo['u_name'],
|
||
'email' => $memberInfo['u_email']
|
||
], $uKey);
|
||
|
||
Response::output([]);
|
||
}
|
||
|
||
public function changeMemberRole_post()
|
||
{
|
||
$userInfo = Request::parse()->authData['userData'];
|
||
$data = Request::parse()->parsed;
|
||
$uKey = $userInfo['u_key'];
|
||
|
||
if (!$data['repository'] || !$data['userID'] || !in_array($data['roleID'], [
|
||
UserAccessController::ROLE_GUEST,
|
||
UserAccessController::ROLE_REPORTER,
|
||
UserAccessController::ROLE_DEVELOPER,
|
||
UserAccessController::ROLE_MAINTAINER,
|
||
UserAccessController::ROLE_OWNER
|
||
])) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
// check reposiroty permission
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$data['repository'],
|
||
$userInfo['u_key'],
|
||
UserAccessController::UAC_REPO_CHANGE_MEMBER
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
// check user data
|
||
$memberInfo = $this->userModel->get($data['userID']);
|
||
if (!$memberInfo) {
|
||
Response::reject(0x0407);
|
||
}
|
||
|
||
$repositoryInfo = $this->repositoryModel->get($data['repository']);
|
||
// no permision to change creator role
|
||
if ($repositoryInfo['u_key'] === $memberInfo['u_key']) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
$result = $this->repositoryModel->setMemberRole($data['userID'], $data['repository'], $data['roleID']);
|
||
if (!$result) {
|
||
Response::reject(0x0405);
|
||
}
|
||
|
||
$this->service->newEvent('REPO_CHANGE_MEMBER_ROLE', [
|
||
'rKey' => $repositoryInfo['r_key'],
|
||
'gKey' => $repositoryInfo['g_key'],
|
||
'uid' => $memberInfo['u_key'],
|
||
'name' => $memberInfo['u_name'],
|
||
'email' => $memberInfo['u_email'],
|
||
'to' => (int) $data['roleID']
|
||
], $uKey);
|
||
|
||
Response::output([]);
|
||
}
|
||
|
||
public function changeOwner_post()
|
||
{
|
||
$userInfo = Request::parse()->authData['userData'];
|
||
$data = Request::parse()->parsed;
|
||
$uKey = $userInfo['u_key'];
|
||
|
||
if (!$data['repository'] || !$data['userID']) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
// check reposiroty permission
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$data['repository'],
|
||
$userInfo['u_key'],
|
||
UserAccessController::UAC_REPO_CHANGE_OWNER
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
// check user data
|
||
$memberInfo = $this->userModel->get($data['userID']);
|
||
if (!$memberInfo) {
|
||
Response::reject(0x0407);
|
||
}
|
||
|
||
$repositoryInfo = $this->repositoryModel->get($data['repository']);
|
||
// no permision to change creator role
|
||
if ($repositoryInfo['u_key'] === $memberInfo['u_key']) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
// set old owner as repository menber
|
||
$result = $this->repositoryModel->setMemberRole(
|
||
$repositoryInfo['u_key'],
|
||
$data['repository'],
|
||
UserAccessController::ROLE_OWNER
|
||
);
|
||
if (!$result) {
|
||
Response::reject(0x0405);
|
||
}
|
||
|
||
// set new owner as owner
|
||
$this->repositoryModel->update($data['repository'], [
|
||
'u_key' => $data['userID']
|
||
]);
|
||
// remove new owner repository ownship
|
||
$this->repositoryModel->removeMember($data['userID'], $data['repository']);
|
||
|
||
$this->service->newEvent('REPO_CHANGE_OWNER', [
|
||
'rKey' => $repositoryInfo['r_key'],
|
||
'gKey' => $repositoryInfo['g_key'],
|
||
'uid' => $memberInfo['u_key'],
|
||
'name' => $memberInfo['u_name'],
|
||
'email' => $memberInfo['u_email']
|
||
], $uKey);
|
||
|
||
Response::output([]);
|
||
}
|
||
|
||
public function removeMember_post()
|
||
{
|
||
$userInfo = Request::parse()->authData['userData'];
|
||
$data = Request::parse()->parsed;
|
||
$uKey = $userInfo['u_key'];
|
||
|
||
if (!$data['repository'] || !$data['userID']) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
// check reposiroty permission
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$data['repository'],
|
||
$userInfo['u_key'],
|
||
UserAccessController::UAC_REPO_CHANGE_MEMBER
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
// check user data
|
||
$memberInfo = $this->userModel->get($data['userID']);
|
||
if (!$memberInfo) {
|
||
Response::reject(0x0407);
|
||
}
|
||
|
||
$repositoryInfo = $this->repositoryModel->get($data['repository']);
|
||
// no permision to remove creator
|
||
if ($repositoryInfo['u_key'] === $memberInfo['u_key']) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
$result = $this->repositoryModel->removeMember($data['userID'], $data['repository']);
|
||
if (!$result) {
|
||
Response::reject(0x0405);
|
||
}
|
||
|
||
$this->service->newEvent('REPO_REMOVE_MEMBER', [
|
||
'rKey' => $repositoryInfo['r_key'],
|
||
'gKey' => $repositoryInfo['g_key'],
|
||
'uid' => $memberInfo['u_key'],
|
||
'name' => $memberInfo['u_name'],
|
||
'email' => $memberInfo['u_email']
|
||
], $uKey);
|
||
|
||
Response::output([]);
|
||
}
|
||
|
||
public function deleteRepository_post()
|
||
{
|
||
$userInfo = Request::parse()->authData['userData'];
|
||
$data = Request::parse()->parsed;
|
||
$uKey = $userInfo['u_key'];
|
||
|
||
if (!$data['repository']) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
// check reposiroty permission
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$data['repository'],
|
||
$userInfo['u_key'],
|
||
UserAccessController::UAC_REPO_REMOVE
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
$repositoryInfo = $this->repositoryModel->get($data['repository']);
|
||
$groupInfo = $this->groupModel->get($repositoryInfo['g_key']);
|
||
|
||
$result = $this->repositoryModel->removeRepository($data['repository']);
|
||
if (!$result) {
|
||
Response::reject(0x0405);
|
||
}
|
||
|
||
$this->service->newEvent('REPO_REMOVE', [
|
||
'rKey' => $repositoryInfo['r_key'],
|
||
'gKey' => $repositoryInfo['g_key'],
|
||
'name' => $groupInfo['g_display_name'] . '/' . $repositoryInfo['r_display_name']
|
||
], $uKey);
|
||
|
||
Response::output([]);
|
||
}
|
||
|
||
public function defaultBranch_post()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$requestData = Request::parse()->parsed;
|
||
$rKey = $requestData['repository'];
|
||
$old = $requestData['old'] ?: '';
|
||
$branch = $requestData['branch'];
|
||
|
||
if (!$branch || $old === $branch) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$rKey,
|
||
$uKey,
|
||
UserAccessController::UAC_REPO_DEFAULT_BRANCH_CHANGE
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
if (!$this->repositoryModel->update($rKey, ['r_default_branch_name' => $branch])) {
|
||
Response::reject(0x0405);
|
||
}
|
||
|
||
$repository = $this->repositoryModel->get($rKey);
|
||
$this->service->newEvent('DEFAULT_BRANCH_CHANGE', [
|
||
'gKey' => $repository['g_key'],
|
||
'rKey' => $rKey,
|
||
'from' => $old,
|
||
'to' => $branch
|
||
], $uKey);
|
||
|
||
Response::output([]);
|
||
}
|
||
|
||
public function protectedBranchRules_get()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$requestData = Request::parse()->query;
|
||
$rKey = $requestData['repository'];
|
||
|
||
if (!$rKey) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$rKey,
|
||
$uKey,
|
||
UserAccessController::UAC_REPO_READ
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
$rules = $this->repositoryModel->listProtectedBranchRules($rKey);
|
||
if ($rules === FALSE) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
$rules = $this->repositoryModel->normalizeProtectedBranchRules($rules);
|
||
Response::output($rules);
|
||
}
|
||
|
||
public function createProtectedBranchRule_post()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$requestData = Request::parse()->parsed;
|
||
$rKey = $requestData['repository'];
|
||
$rule = $requestData['rule'];
|
||
$rolePush = (int) $requestData['rolePush'];
|
||
$roleMerge = (int) $requestData['roleMerge'];
|
||
|
||
if (!$rKey || !$rule || !$rolePush || !$roleMerge) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!in_array($rolePush, [
|
||
UserAccessController::ROLE_NO_BODY,
|
||
UserAccessController::ROLE_OWNER,
|
||
UserAccessController::ROLE_MAINTAINER,
|
||
UserAccessController::ROLE_DEVELOPER
|
||
]) || !in_array($roleMerge, [
|
||
UserAccessController::ROLE_NO_BODY,
|
||
UserAccessController::ROLE_OWNER,
|
||
UserAccessController::ROLE_MAINTAINER
|
||
])) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if ($this->repositoryModel->getProtectedBranchRule($rKey, $rule)) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$rKey,
|
||
$uKey,
|
||
UserAccessController::UAC_REPO_PROTECTED_BRANCH_RULE_CREATE
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
if (!$this->repositoryModel->createProtectedBranchRule($rKey, $rule, $rolePush, $roleMerge)) {
|
||
Response::reject(0x0405);
|
||
}
|
||
|
||
$repository = $this->repositoryModel->get($rKey);
|
||
$this->service->newEvent('PROTECTED_BRANCH_RULE_CREATE', [
|
||
'gKey' => $repository['g_key'],
|
||
'rKey' => $rKey,
|
||
'name' => $rule
|
||
], $uKey);
|
||
|
||
Response::output([]);
|
||
}
|
||
|
||
public function updateProtectedBranchRule_post()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$requestData = Request::parse()->parsed;
|
||
$rKey = $requestData['repository'];
|
||
$pbrKey = $requestData['id'];
|
||
$rule = $requestData['rule'];
|
||
$rolePush = (int) $requestData['rolePush'];
|
||
$roleMerge = (int) $requestData['roleMerge'];
|
||
|
||
if (!$rKey || !$pbrKey || !$rule || !$rolePush || !$roleMerge) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!in_array($rolePush, [
|
||
UserAccessController::ROLE_NO_BODY,
|
||
UserAccessController::ROLE_OWNER,
|
||
UserAccessController::ROLE_MAINTAINER,
|
||
UserAccessController::ROLE_DEVELOPER
|
||
]) || !in_array($roleMerge, [
|
||
UserAccessController::ROLE_NO_BODY,
|
||
UserAccessController::ROLE_OWNER,
|
||
UserAccessController::ROLE_MAINTAINER
|
||
])) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
$sameRule = $this->repositoryModel->getProtectedBranchRule($rKey, $rule);
|
||
if ($sameRule && $sameRule['pbr_key'] !== $pbrKey) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$rKey,
|
||
$uKey,
|
||
UserAccessController::UAC_REPO_PROTECTED_BRANCH_RULE_CREATE
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
$updateData = [
|
||
'pbr_rule' => $rule,
|
||
'pbr_push_min_role_id' => $rolePush,
|
||
'pbr_merge_min_role_id' => $roleMerge,
|
||
];
|
||
|
||
if (!$this->repositoryModel->updateProtectedBranchRule($pbrKey, $updateData)) {
|
||
Response::reject(0x0405);
|
||
}
|
||
|
||
$repository = $this->repositoryModel->get($rKey);
|
||
$this->service->newEvent('PROTECTED_BRANCH_RULE_CHANGE', [
|
||
'gKey' => $repository['g_key'],
|
||
'rKey' => $rKey,
|
||
'name' => $rule
|
||
], $uKey);
|
||
|
||
Response::output([]);
|
||
}
|
||
|
||
public function deleteProtectedBranchRule_post()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$requestData = Request::parse()->parsed;
|
||
$rKey = $requestData['repository'];
|
||
$pbrKey = $requestData['id'];
|
||
$rule = $requestData['rule'];
|
||
|
||
if (!$rKey || !$rule || !$pbrKey) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$rKey,
|
||
$uKey,
|
||
UserAccessController::UAC_REPO_PROTECTED_BRANCH_RULE_REOMVE
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
$updateData = [
|
||
'pbr_status' => COMMON_STATUS_DELETE,
|
||
'pbr_deleted' => date('Y-m-d H:i:s')
|
||
];
|
||
|
||
if (!$this->repositoryModel->updateProtectedBranchRule($pbrKey, $updateData)) {
|
||
Response::reject(0x0405);
|
||
}
|
||
|
||
$repository = $this->repositoryModel->get($rKey);
|
||
$this->service->newEvent('PROTECTED_BRANCH_RULE_REMOVE', [
|
||
'gKey' => $repository['g_key'],
|
||
'rKey' => $rKey,
|
||
'name' => $rule
|
||
], $uKey);
|
||
|
||
Response::output([]);
|
||
}
|
||
|
||
public function commitList_get()
|
||
{
|
||
$userInfo = Request::parse()->authData['userData'];
|
||
$requestData = Request::parse()->query;
|
||
$uKey = $userInfo['u_key'];
|
||
$rKey = $requestData['repository'];
|
||
$path = trim($requestData['path'], '/') ?: '';
|
||
|
||
if (!$rKey || !$uKey) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$rKey,
|
||
$uKey,
|
||
UserAccessController::UAC_REPO_READ
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
$page = $requestData['page'];
|
||
$pagesize = $requestData['pagesize'];
|
||
$keyword = $requestData['keyword'];
|
||
$revision = $requestData['revision'];
|
||
|
||
$commitList = $this->repositoryModel->getCommits($rKey, $uKey, $revision, $path, $keyword, $page, $pagesize);
|
||
$commitList = $this->repositoryModel->normalizeCommits($commitList);
|
||
Response::output($commitList);
|
||
}
|
||
|
||
public function commitDetail_get()
|
||
{
|
||
$userInfo = Request::parse()->authData['userData'];
|
||
$requestData = Request::parse()->query;
|
||
if (!$requestData['repository']) {
|
||
return Response::reject(0x0200);
|
||
}
|
||
$uKey = $userInfo['u_key'];
|
||
$rKey = $requestData['repository'];
|
||
$commitSHA = $requestData['commitSHA'];
|
||
$result = $this->repositoryModel->getCommitDetail($rKey, $uKey, $commitSHA);
|
||
$result = $this->repositoryModel->normalizeCommitDetail($result);
|
||
Response::output($result);
|
||
}
|
||
|
||
public function fileChanges_get()
|
||
{
|
||
$requestData = Request::parse()->query;
|
||
$userInfo = Request::parse()->authData['userData'];
|
||
$uKey = $userInfo['u_key'];
|
||
$rKey = $requestData['repository'];
|
||
$original = $requestData['original'];
|
||
$modified = $requestData['modified'];
|
||
|
||
$versionCompare = $requestData['versionCompare'];
|
||
|
||
$mrKey = $requestData['mergeRequest'];
|
||
$targetRKey = $requestData['targetRepository'];
|
||
|
||
$original = $original ? $original : '0000000000000000000000000000000000000000';
|
||
|
||
if (!$uKey || !$rKey || !$modified) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!$mrKey) {
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$rKey,
|
||
$uKey,
|
||
UserAccessController::UAC_REPO_READ
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
}
|
||
|
||
if ($targetRKey) {
|
||
if ($versionCompare) {
|
||
$remoteObjects = [$original, $modified];
|
||
} else {
|
||
$remoteObjects = $this->repositoryModel->getMergeRequestLastCommitSha($uKey, $mrKey, $rKey, $original, $targetRKey, $modified);
|
||
if (!$remoteObjects) {
|
||
Response::reject(0x0201);
|
||
}
|
||
}
|
||
|
||
if ($targetRKey === $rKey) {
|
||
$result = $this->repositoryModel->getDiffWithLocal($rKey, $uKey, $remoteObjects[1], $remoteObjects[0]);
|
||
} else {
|
||
$result = $this->repositoryModel->getDiffWithRemote($rKey, $remoteObjects[0], $targetRKey, $remoteObjects[1], $uKey);
|
||
}
|
||
} else {
|
||
$targetRKey = $rKey;
|
||
if (($count = $this->repositoryModel->getDiffWithLocalCount($rKey, $uKey, $original, $modified)) > MAX_DISPLAY_DIFF_FILE) {
|
||
Response::output([
|
||
'large' => true,
|
||
'count' => $count,
|
||
'detail' => ''
|
||
]);
|
||
}
|
||
|
||
$result = $this->repositoryModel->getDiffWithLocal($rKey, $uKey, $original, $modified);
|
||
}
|
||
|
||
$parsedData = Helper::parseDiffString($result);
|
||
foreach ($parsedData as &$item) {
|
||
if ($item['type'] == 'binary') {
|
||
if ($item['original']['name']) {
|
||
$result = $this->repositoryModel->catObject($targetRKey, $uKey, $item['original']['sha']);
|
||
$item['original']['type'] = $result[0];
|
||
if (is_string($result[1])) {
|
||
$item['original']['object'] = Helper::parseObjectToFile($result[1]);
|
||
} else {
|
||
$item['original']['object'] = ['oversize' => TRUE, 'size' => $result[2]];
|
||
}
|
||
}
|
||
if ($item['modified']['name']) {
|
||
$result = $this->repositoryModel->catObject($targetRKey, $uKey, $item['modified']['sha']);
|
||
$item['modified']['type'] = $result[0];
|
||
if (is_string($result[1])) {
|
||
$item['modified']['object'] = Helper::parseObjectToFile($result[1]);
|
||
} else {
|
||
$item['modified']['object'] = ['oversize' => TRUE, 'size' => $result[2]];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
Response::output([
|
||
'count' => count($parsedData),
|
||
'detail' => $parsedData
|
||
]);
|
||
}
|
||
|
||
// 获取含有指定hash值的分支及tag列表
|
||
public function refListContainSHA_get()
|
||
{
|
||
$requestData = Request::parse()->query;
|
||
$userInfo = Request::parse()->authData['userData'];
|
||
$uKey = $userInfo['u_key'];
|
||
$rKey = $requestData['repository'];
|
||
$commitHash = $requestData['hash'];
|
||
|
||
if (!$uKey || !$rKey || !$commitHash) {
|
||
Response::reject(0x0201);
|
||
}
|
||
$commitLog = $this->repositoryModel->getCommitDetail($rKey, $uKey, $commitHash);
|
||
$parent = $commitLog['parent'];
|
||
if (strlen($parent)) {
|
||
$parentArray = explode(" ", $parent);
|
||
}
|
||
// 如果有两个父节点，需要合并tag和branch
|
||
if ($parentArray && count($parentArray) > 1) {
|
||
$parent0Branches = $this->repositoryModel->getBranchListBySHA1($rKey, $uKey, $parentArray[0]);
|
||
$parent1Branches = $this->repositoryModel->getBranchListBySHA1($rKey, $uKey, $parentArray[1]);
|
||
$parent0Tags = $this->repositoryModel->getTagListBySHA1($rKey, $uKey, $parentArray[0]);
|
||
$parent1Tags = $this->repositoryModel->getTagListBySHA1($rKey, $uKey, $parentArray[1]);
|
||
$branches = array_intersect($parent0Branches, $parent1Branches);
|
||
$tags = array_intersect($parent0Tags, $parent1Tags);
|
||
$tags = array_merge($tags);
|
||
$result['branch'] = $branches;
|
||
$result['tag'] = $tags;
|
||
} else {
|
||
$result['branch'] = $this->repositoryModel->getBranchListBySHA1($rKey, $uKey, $commitHash);
|
||
$result['tag'] = $this->repositoryModel->getTagListBySHA1($rKey, $uKey, $commitHash);
|
||
}
|
||
Response::output($result);
|
||
}
|
||
|
||
public function fileContent_get()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$data = Request::parse()->query;
|
||
|
||
$repository = $data['repository'];
|
||
$sha = $data['sha'];
|
||
$path = trim($data['path'], '/');
|
||
|
||
$from = (int) $data['from'];
|
||
$to = (int) $data['to'];
|
||
|
||
if (!$repository || !$sha || !$path) {
|
||
return Response::reject(0x0201);
|
||
}
|
||
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$repository,
|
||
$uKey,
|
||
UserAccessController::UAC_REPO_READ
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
$result = $this->repositoryModel->geFilesByBranchOrSHA1Hash($repository, $uKey, $sha, FALSE, TRUE);
|
||
|
||
if (!$result) {
|
||
Response::reject(0x040E);
|
||
}
|
||
|
||
if ($from || $to) {
|
||
if ($from > 0 && $to > 0 && $to > $from) {
|
||
return Response::output([
|
||
'raw' =>
|
||
implode(
|
||
"\n",
|
||
array_slice(
|
||
explode("\n", $result),
|
||
$from - 1,
|
||
$to - $from
|
||
)
|
||
)
|
||
]);
|
||
} else {
|
||
return Response::reject(0x0201);
|
||
}
|
||
}
|
||
|
||
return Response::output(['raw' => $result]);
|
||
}
|
||
|
||
public function object_get()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$data = Request::parse()->query;
|
||
$rKey = $data['repository'];
|
||
$parent = $data['parent'];
|
||
$path = trim($data['path'], '/');
|
||
$rev = $data['revision'];
|
||
|
||
if (!$rKey || !$parent) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$rKey,
|
||
$uKey,
|
||
UserAccessController::UAC_REPO_READ
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
$result = $this->repositoryModel->catObject($rKey, $uKey, $parent);
|
||
|
||
if ($result[0] === 'blob') {
|
||
if (is_string($result[1])) {
|
||
$result[1] = Helper::parseObjectToFile($result[1]);
|
||
} else {
|
||
$result[1] = ['oversize' => TRUE, 'size' => $result[2]];
|
||
}
|
||
}
|
||
|
||
$output = [];
|
||
$output['type'] = $result[0];
|
||
$output['object'] = $result[1];
|
||
|
||
if ($rev) {
|
||
$output['commit'] = $this->repositoryModel->getLastCommit($rKey, $uKey, $rev, $path);
|
||
$output['path'] = $path;
|
||
if ($output['type'] !== 'blob') {
|
||
$output['object'] = $this->repositoryModel->addLastCommitToObjectList($rKey, $uKey, $rev, $path, $result[1]);
|
||
}
|
||
}
|
||
|
||
// add url attribute for sub module
|
||
if ($output['object'][0]) {
|
||
$gitModuleFlag = FALSE;
|
||
$gitModuleURLMap = [];
|
||
foreach ($output['object'] as $item) {
|
||
if ($item['type'] === 'commit') {
|
||
$gitModuleFlag = TRUE;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if ($gitModuleFlag) {
|
||
$rootdirData = $this->repositoryModel->catObject($rKey, $uKey, $rev);
|
||
$gitModuleData = NULL;
|
||
foreach ($rootdirData[1] as $item) {
|
||
if ($item['name'] === '.gitmodules') {
|
||
$gitModuleData = $item;
|
||
}
|
||
}
|
||
|
||
if ($gitModuleData) {
|
||
$gitModuleFileInfo = $this->repositoryModel->catObject($rKey, $uKey, $gitModuleData['object']);
|
||
$gitModuleFileContent = Helper::parseObjectToFile($gitModuleFileInfo[1]);
|
||
if ($gitModuleFileContent['raw']) {
|
||
$matches = [];
|
||
preg_match_all('/\[.*\]\r?\n\s*path\s*=\s*(.*)\r?\n\s*url\s*=\s*(.*)\r?\n?/m', $gitModuleFileContent['raw'], $matches);
|
||
|
||
foreach ($matches[1] as $submoduleIndex => $submodulePath) {
|
||
$gitModuleURLMap[$submodulePath] = $matches[2][$submoduleIndex];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
foreach ($output['object'] as &$item) {
|
||
if ($item['type'] === 'commit') {
|
||
if ($path) {
|
||
$item['url'] = $gitModuleURLMap[$path . '/' . $item['name']];
|
||
} else {
|
||
$item['url'] = $gitModuleURLMap[$item['name']];
|
||
}
|
||
} else {
|
||
$item['url'] = '';
|
||
}
|
||
}
|
||
}
|
||
|
||
Response::output($output);
|
||
}
|
||
|
||
public function pathStack_get()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$data = Request::parse()->query;
|
||
$rKey = $data['repository'];
|
||
$revision = $data['revision'];
|
||
$path = $data['path'];
|
||
|
||
if (!$rKey || !$revision || !$path) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$rKey,
|
||
$uKey,
|
||
UserAccessController::UAC_REPO_READ
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
$path = trim($path, '/');
|
||
|
||
$pathStack = explode('/', $path);
|
||
|
||
$output = [];
|
||
|
||
$result = $this->repositoryModel->catObject($rKey, $uKey, $revision);
|
||
foreach ($pathStack as $pathIndex => $pathName) {
|
||
if ($result[0] !== 'blob') {
|
||
$matchedObject = array_values(array_filter($result[1], function ($v, $k) use ($pathName) {
|
||
return $v['name'] === $pathName;
|
||
}, ARRAY_FILTER_USE_BOTH));
|
||
|
||
if ($matchedObject[0]) {
|
||
$output[$pathIndex] = $matchedObject[0];
|
||
|
||
if ($matchedObject[0]['type'] !== 'blob') {
|
||
$result = $this->repositoryModel->catObject($rKey, $uKey, $matchedObject[0]['object']);
|
||
} else if ($pathIndex < count($pathStack) - 1) {
|
||
Response::output([]);
|
||
}
|
||
} else {
|
||
Response::output([]);
|
||
}
|
||
}
|
||
}
|
||
|
||
Response::output($output);
|
||
}
|
||
|
||
public function mergeRequests_get()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$data = Request::parse()->query;
|
||
$rKey = $data['repository'];
|
||
$status = (int)$data['status'];
|
||
$keyword = $data['keyword'];
|
||
$sort = $data['sort'];
|
||
$page = $data['page'];
|
||
$pagesize = $data['pagesize'];
|
||
|
||
if (
|
||
!$rKey ||
|
||
!in_array($sort, ['desc', 'asc']) ||
|
||
($status && !in_array($status, [MergeRequestStatus::OPEN, MergeRequestStatus::MERGED, MergeRequestStatus::CLOSED]))
|
||
) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$rKey,
|
||
$uKey,
|
||
UserAccessController::UAC_MR_READ
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
$conditions = [
|
||
'mr_target_r_key' => $rKey,
|
||
'mr_proceed_status' => $status,
|
||
'mr_status' => COMMON_STATUS_NORMAL,
|
||
'~mr_title|mr_description' => $keyword
|
||
];
|
||
|
||
$res = $this->repositoryModel->getMergeRequests($conditions, $sort, $page, $pagesize);
|
||
if ($res === FALSE) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
$res = $this->repositoryModel->normalizeMergeRequests($res);
|
||
|
||
Response::output($res);
|
||
}
|
||
|
||
public function relatedMergeRequests_get()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$data = Request::parse()->query;
|
||
$status = (int)$data['status'];
|
||
$keyword = $data['keyword'];
|
||
$sort = $data['sort'];
|
||
$page = $data['page'];
|
||
$pagesize = $data['pagesize'];
|
||
|
||
if (
|
||
!in_array($sort, ['desc', 'asc']) ||
|
||
($status && !in_array($status, [MergeRequestStatus::OPEN, MergeRequestStatus::MERGED, MergeRequestStatus::CLOSED]))
|
||
) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
$list = $this->repositoryModel->listJoined($uKey);
|
||
$list = $this->repositoryModel->normalize($list);
|
||
foreach (array_keys($list) as $itemKey) {
|
||
$list[$itemKey]['role'] = $this->repositoryModel->getMemberRole($list[$itemKey]['id'], $uKey);
|
||
}
|
||
|
||
$filterRepositoryArr = [];
|
||
$statusCode = [
|
||
0 => 'all',
|
||
1 => 'open',
|
||
2 => 'merged',
|
||
3 => 'closed'
|
||
];
|
||
foreach ($list as $index => $item) {
|
||
if ($item['role'] > 1) {
|
||
$filterRepositoryArr[] = $item['id'];
|
||
}
|
||
}
|
||
|
||
$conditions = [
|
||
'mr_target_r_key' => $filterRepositoryArr,
|
||
'mr_proceed_status' => $status,
|
||
'mr_status' => COMMON_STATUS_NORMAL,
|
||
'~mr_title|mr_description' => $keyword
|
||
];
|
||
|
||
if (count($filterRepositoryArr)) {
|
||
$result = $this->repositoryModel->getMergeRequests($conditions, $sort, $page, $pagesize);
|
||
} else {
|
||
Response::output([
|
||
'relatedRepository' => [],
|
||
'mergeRequests' => []
|
||
]);
|
||
}
|
||
|
||
if ($result === FALSE) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
$result = $this->repositoryModel->normalizeMergeRequests($result);
|
||
$output = [];
|
||
$output['relatedRepository'] = $filterRepositoryArr;
|
||
$output['mergeRequests'] = $result;
|
||
Response::output($output);
|
||
}
|
||
|
||
public function mergeRequestCommits_get()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$data = Request::parse()->query;
|
||
$mrKey = $data['mergeRequest'];
|
||
$sourceRKey = $data['sourceRepository'];
|
||
$sourceBranch = $data['sourceBranch'];
|
||
$targetRKey = $data['targetRepository'];
|
||
$targetBranch = $data['targetBranch'];
|
||
|
||
if (!$sourceRKey || !$sourceBranch || !$targetRKey || !$targetBranch) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
$remoteObjects = $this->repositoryModel->getMergeRequestLastCommitSha($uKey, $mrKey, $sourceRKey, $sourceBranch, $targetRKey, $targetBranch);
|
||
if (!$remoteObjects) {
|
||
Response::reject(0x0201);
|
||
}
|
||
if ($targetRKey === $sourceRKey) {
|
||
$result = $this->repositoryModel->getCommitWithLocal($sourceRKey, $remoteObjects[0], $remoteObjects[1], $uKey);
|
||
} else {
|
||
$result = $this->repositoryModel->getCommitWithRemote($sourceRKey, $remoteObjects[0], $targetRKey, $remoteObjects[1], $uKey);
|
||
}
|
||
$result = $this->repositoryModel->normalizeCommits($result);
|
||
|
||
Response::output($result);
|
||
}
|
||
|
||
public function mergeRequestClose_post()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$data = Request::parse()->parsed;
|
||
$mrKey = $data['mergeRequest'];
|
||
|
||
if (!$mrKey) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
$mergeRequest = $this->repositoryModel->getMergeRequestByKey($mrKey);
|
||
if (!$mergeRequest || $mergeRequest['status'] != MergeRequestStatus::OPEN) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$mergeRequest['targetRepository'],
|
||
$uKey,
|
||
UserAccessController::UAC_MR_CLOSE
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
if (!$this->repositoryModel->mergeRequestClose($uKey, $mrKey, $mergeRequest)) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
$repository = $this->repositoryModel->get($mergeRequest['targetRepository']);
|
||
$sourceRepository = $this->repositoryModel->get($mergeRequest['sourceRepository']);
|
||
$this->service->newEvent('MERGE_REQUEST_CLOSE', [
|
||
'gKey' => $repository['g_key'],
|
||
'rKey' => $mergeRequest['targetRepository'],
|
||
'mrKey' => $mergeRequest['id'],
|
||
'id' => $mergeRequest['number'],
|
||
'sourceGKey' => $sourceRepository['g_key'],
|
||
'sourceRKey' => $mergeRequest['sourceRepository'],
|
||
'sourceBranch' => $mergeRequest['sourceBranch'],
|
||
'targetBranch' => $mergeRequest['targetBranch']
|
||
], $uKey);
|
||
|
||
Response::output([]);
|
||
}
|
||
|
||
public function lastCommitLog_get()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$data = Request::parse()->query;
|
||
$rKey = $data['repository'];
|
||
$ref = $data['ref'];
|
||
$path = trim($data['path'], '/');
|
||
$log = $this->repositoryModel->getLastCommit($rKey, $uKey, $ref, $path);
|
||
Response::output($log);
|
||
}
|
||
|
||
public function branchList_get()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$rKey = Request::parse()->query['repository'];
|
||
|
||
if (!$rKey) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$rKey,
|
||
$uKey,
|
||
UserAccessController::UAC_REPO_READ
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
$result = $this->repositoryModel->getBranches($rKey, $uKey);
|
||
|
||
Response::output($result);
|
||
}
|
||
|
||
public function createBranch_post()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$data = Request::parse()->parsed;
|
||
$rKey = $data['repository'];
|
||
$name = trim($data['name']);
|
||
$origin = trim($data['origin']);
|
||
|
||
if (!$rKey || !$name || !$origin) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!preg_match('/^\w[\w\/\.\-]{0,29}$/', $name)) {
|
||
Response::reject(0x0202);
|
||
}
|
||
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$rKey,
|
||
$uKey,
|
||
UserAccessController::UAC_REPO_BRANCH_CREATE
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
$result = $this->groupModel->checkPreserve($name);
|
||
if ($result) {
|
||
Response::reject(0x0403);
|
||
}
|
||
|
||
$branchList = $this->repositoryModel->getBranchList($rKey, $uKey);
|
||
$tagList = $this->repositoryModel->getTagList($rKey, $uKey);
|
||
if (in_array($name, $branchList) || in_array($name, $tagList)) {
|
||
Response::reject(0x0406);
|
||
}
|
||
|
||
$result = $this->repositoryModel->createBranch($name, $rKey, $origin, $uKey);
|
||
if ($result) {
|
||
Response::reject(0x040C);
|
||
}
|
||
|
||
$repository = $this->repositoryModel->get($rKey);
|
||
$this->service->newEvent('BRANCH_CREATE', [
|
||
'gKey' => $repository['g_key'],
|
||
'rKey' => $rKey,
|
||
'name' => $name
|
||
], $uKey);
|
||
|
||
Response::output([]);
|
||
}
|
||
|
||
public function mergeRequestVersionList_get()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$data = Request::parse()->query;
|
||
$mrKey = trim($data['mergeRequest']);
|
||
|
||
if (!$mrKey) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
$mergeRequest = $this->repositoryModel->getMergeRequestByKey($mrKey);
|
||
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$mergeRequest['targetRepository'],
|
||
$uKey,
|
||
UserAccessController::UAC_MR_READ
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
$versionList = $this->repositoryModel->getMergeRequestVersionList($uKey, $mrKey);
|
||
$baseVersion = $this->repositoryModel->getLastCommit($mergeRequest['targetRepository'], $uKey, $mergeRequest['targetBranch'], '');
|
||
|
||
$baseVersionList = $versionList;
|
||
$baseVersionList[0] = $baseVersion;
|
||
Response::output([
|
||
'mergeVersionList' => $versionList,
|
||
'baseVersion' => $baseVersion['sha'],
|
||
'baseVersionList' => $baseVersionList
|
||
]);
|
||
}
|
||
|
||
public function createMergeRequest_post()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$data = Request::parse()->parsed;
|
||
$sourceRepositoryKey = trim($data['sourceRepository']);
|
||
$targetRepositoryKey = trim($data['targetRepository']);
|
||
$sourceBranch = trim($data['sourceBranch']);
|
||
$targetBranch = trim($data['targetBranch']);
|
||
$title = trim($data['title']);
|
||
$description = trim($data['description']);
|
||
$reviewers = trim($data['reviewers']);
|
||
|
||
if (
|
||
!$sourceRepositoryKey || !$targetRepositoryKey ||
|
||
!$sourceBranch || !$targetBranch
|
||
) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$targetRepositoryKey,
|
||
$uKey,
|
||
UserAccessController::UAC_MR_PUSH
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
if ($this->repositoryModel->isMergeRequestExist($sourceRepositoryKey, $sourceBranch, $targetRepositoryKey, $targetBranch)) {
|
||
Response::reject(0x0406);
|
||
}
|
||
|
||
if ($this->repositoryModel->checkBranchProteced($targetRepositoryKey, $uKey, $targetBranch, TRUE)) {
|
||
Response::reject(0x040F);
|
||
}
|
||
|
||
$remoteObjects = $this->repositoryModel->getMergeRequestLastCommitSha($uKey, '', $sourceRepositoryKey, $sourceBranch, $targetRepositoryKey, $targetBranch);
|
||
if ($sourceRepositoryKey === $targetRepositoryKey) {
|
||
if (!$this->repositoryModel->getCommitWithLocal($sourceRepositoryKey, $remoteObjects[0], $remoteObjects[1], $uKey)) {
|
||
Response::reject(0x040C);
|
||
}
|
||
} else {
|
||
if (!$this->repositoryModel->getCommitWithRemote($sourceRepositoryKey, $remoteObjects[0], $targetRepositoryKey, $remoteObjects[1], $uKey)) {
|
||
Response::reject(0x040C);
|
||
}
|
||
}
|
||
|
||
$sourceCommitHash = $this->repositoryModel->getLastCommit($sourceRepositoryKey, $uKey, $sourceBranch, '')['sha'];
|
||
|
||
$res = $this->repositoryModel->createMergeRequest(
|
||
$uKey,
|
||
$sourceRepositoryKey,
|
||
$sourceBranch,
|
||
$targetRepositoryKey,
|
||
$targetBranch,
|
||
$sourceCommitHash,
|
||
$title,
|
||
$description
|
||
);
|
||
|
||
if (!is_array($res)) {
|
||
Response::reject(0x040C);
|
||
}
|
||
|
||
$repository = $this->repositoryModel->get($targetRepositoryKey);
|
||
$sourceRepository = $this->repositoryModel->get($sourceRepositoryKey);
|
||
$this->service->newEvent('MERGE_REQUEST_CREATE', [
|
||
'gKey' => $repository['g_key'],
|
||
'rKey' => $targetRepositoryKey,
|
||
'mrKey' => $res['mrKey'],
|
||
'id' => $res['mrId'],
|
||
'sourceGKey' => $sourceRepository['g_key'],
|
||
'sourceRKey' => $sourceRepositoryKey,
|
||
'sourceBranch' => $sourceBranch,
|
||
'targetBranch' => $targetBranch,
|
||
'reviewers' => $reviewers
|
||
], $uKey);
|
||
|
||
if ($reviewers) {
|
||
$reviewers = explode(',', $reviewers);
|
||
$repository = $this->repositoryModel->get($targetRepositoryKey);
|
||
|
||
foreach ($reviewers as $reviewer) {
|
||
$mrrKey = $this->repositoryModel->assignReviewer($res['mrKey'], $reviewer);
|
||
|
||
if ($mrrKey) {
|
||
$this->service->newEvent('MERGE_REQUEST_REVIEWER_CREATE', [
|
||
'gKey' => $repository['g_key'],
|
||
'rKey' => $targetRepositoryKey,
|
||
'reviewer' => $reviewer,
|
||
'mrKey' => $res['mrKey'],
|
||
'mrrKey' => $mrrKey,
|
||
'id' => $res['mrId']
|
||
], $uKey);
|
||
}
|
||
}
|
||
}
|
||
|
||
Response::output(['id' => $res['mrId']]);
|
||
}
|
||
|
||
public function mergeRequestReview_post()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$data = Request::parse()->parsed;
|
||
$mrKey = trim($data['id']);
|
||
|
||
if (!$mrKey) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
$mergeRequest = $this->repositoryModel->getMergeRequestByKey($mrKey);
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$mergeRequest['targetRepository'],
|
||
$uKey,
|
||
UserAccessController::UAC_MR_PUSH
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
if (!$this->repositoryModel->mergeRequestReview($mrKey, $uKey)) {
|
||
Response::reject(0x0405);
|
||
}
|
||
|
||
$repository = $this->repositoryModel->get($mergeRequest['targetRepository']);
|
||
$this->service->newEvent('MERGE_REQUEST_REVIEWER_REVIEW', [
|
||
'gKey' => $repository['g_key'],
|
||
'rKey' => $mergeRequest['targetRepository'],
|
||
'reviewer' => $uKey,
|
||
'mrKey' => $mrKey,
|
||
'id' => $mergeRequest['number']
|
||
], $uKey);
|
||
|
||
Response::output([]);
|
||
}
|
||
|
||
public function assignReviewer_post()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$data = Request::parse()->parsed;
|
||
$mrKey = trim($data['id']);
|
||
$reviewer = trim($data['reviewer']);
|
||
|
||
if (!$mrKey || !$reviewer) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
$mergeRequest = $this->repositoryModel->getMergeRequestByKey($mrKey);
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$mergeRequest['targetRepository'],
|
||
$uKey,
|
||
UserAccessController::UAC_MR_MERGE
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
$mrrKey = $this->repositoryModel->assignReviewer($mrKey, $reviewer);
|
||
if (!$mrrKey) {
|
||
Response::reject(0x0405);
|
||
}
|
||
|
||
$repository = $this->repositoryModel->get($mergeRequest['targetRepository']);
|
||
$this->service->newEvent('MERGE_REQUEST_REVIEWER_CREATE', [
|
||
'gKey' => $repository['g_key'],
|
||
'rKey' => $mergeRequest['targetRepository'],
|
||
'reviewer' => $reviewer,
|
||
'mrKey' => $mrKey,
|
||
'mrrKey' => $mrrKey,
|
||
'id' => $mergeRequest['number']
|
||
], $uKey);
|
||
|
||
Response::output([]);
|
||
}
|
||
|
||
public function deleteReviewer_post()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$data = Request::parse()->parsed;
|
||
$mrKey = trim($data['id']);
|
||
$reviewer = trim($data['reviewer']);
|
||
|
||
if (!$mrKey) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
$mergeRequest = $this->repositoryModel->getMergeRequestByKey($mrKey);
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$mergeRequest['targetRepository'],
|
||
$uKey,
|
||
UserAccessController::UAC_MR_MERGE
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
if (!$this->repositoryModel->deleteReviewer($mrKey, $reviewer)) {
|
||
Response::reject(0x0405);
|
||
}
|
||
|
||
$repository = $this->repositoryModel->get($mergeRequest['targetRepository']);
|
||
$this->service->newEvent('MERGE_REQUEST_REVIEWER_DELETE', [
|
||
'gKey' => $repository['g_key'],
|
||
'rKey' => $mergeRequest['targetRepository'],
|
||
'reviewer' => $reviewer,
|
||
'mrKey' => $mrKey,
|
||
'id' => $mergeRequest['number']
|
||
], $uKey);
|
||
|
||
Response::output([]);
|
||
}
|
||
|
||
public function checkMergeType_post()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$data = Request::parse()->parsed;
|
||
$mrKey = trim($data['mergeRequest']);
|
||
if (!$mrKey) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
$mergeRequest = $this->repositoryModel->getMergeRequestByKey($mrKey);
|
||
|
||
if (!$mergeRequest || $mergeRequest['status'] != MergeRequestStatus::OPEN) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
$sourceRepositoryKey = $mergeRequest['sourceRepository'];
|
||
$sourceBranch = $mergeRequest['sourceBranch'];
|
||
$targetRepositoryKey = $mergeRequest['targetRepository'];
|
||
$targetBranch = $mergeRequest['targetBranch'];
|
||
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$targetRepositoryKey,
|
||
$uKey,
|
||
UserAccessController::UAC_MR_MERGE
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
$sourceCommitHash = $this->repositoryModel->getLastCommit($sourceRepositoryKey, $uKey, $sourceBranch, '')['sha'];
|
||
$targetCommitHash = $this->repositoryModel->getLastCommit($targetRepositoryKey, $uKey, $targetBranch, '')['sha'];
|
||
$canBeFastForward = $this->repositoryModel->canBeFastForward($sourceRepositoryKey, $sourceCommitHash, $targetRepositoryKey, $targetCommitHash, $uKey);
|
||
|
||
Response::output([
|
||
'canBeFastForward' => $canBeFastForward
|
||
]);
|
||
}
|
||
|
||
public function mergeBranch_post()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$data = Request::parse()->parsed;
|
||
$mrKey = trim($data['mergeRequest']);
|
||
$message = trim($data['message']);
|
||
if (trim($data['usingSquash']) === 'false') {
|
||
$usingSquash = false;
|
||
} else {
|
||
$usingSquash = true;
|
||
}
|
||
|
||
if (strlen($message) === 0) {
|
||
$message = NULL;
|
||
}
|
||
|
||
if (!$mrKey) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
$mergeRequest = $this->repositoryModel->getMergeRequestByKey($mrKey);
|
||
|
||
if (!$mergeRequest || $mergeRequest['status'] != MergeRequestStatus::OPEN) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
$sourceRepositoryKey = $mergeRequest['sourceRepository'];
|
||
$sourceBranch = $mergeRequest['sourceBranch'];
|
||
$targetRepositoryKey = $mergeRequest['targetRepository'];
|
||
$targetBranch = $mergeRequest['targetBranch'];
|
||
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$targetRepositoryKey,
|
||
$uKey,
|
||
UserAccessController::UAC_MR_MERGE
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
if ($this->repositoryModel->checkBranchProteced($targetRepositoryKey, $uKey, $targetBranch, TRUE)) {
|
||
Response::reject(0x040F);
|
||
}
|
||
|
||
if (!$this->repositoryModel->getReviewStatus($mrKey)) {
|
||
Response::reject(0x0405);
|
||
}
|
||
|
||
$sourceCommitHash = $this->repositoryModel->getLastCommit($sourceRepositoryKey, $uKey, $sourceBranch, '')['sha'];
|
||
$targetCommitHash = $this->repositoryModel->getLastCommit($targetRepositoryKey, $uKey, $targetBranch, '')['sha'];
|
||
$message = $message ? $message : NULL;
|
||
$res = $this->repositoryModel->mergeBranch($sourceRepositoryKey, $sourceBranch, $targetRepositoryKey, $targetBranch, $uKey, $message, $usingSquash);
|
||
$conflictPattern = '/\bconflicts\b/';
|
||
if ($res) {
|
||
if (preg_match($conflictPattern, $res[count($res) - 1])) {
|
||
Response::output(['conflict' => true]);
|
||
} else {
|
||
$this->repositoryModel->mergeRequestMerge($uKey, $mrKey, $sourceCommitHash, $targetCommitHash);
|
||
$repository = $this->repositoryModel->get($targetRepositoryKey);
|
||
$sourceRepository = $this->repositoryModel->get($sourceRepositoryKey);
|
||
$this->service->newEvent('MERGE_REQUEST_MERGE', [
|
||
'gKey' => $repository['g_key'],
|
||
'rKey' => $targetRepositoryKey,
|
||
'mrKey' => $mergeRequest['id'],
|
||
'id' => $mergeRequest['number'],
|
||
'sourceGKey' => $sourceRepository['g_key'],
|
||
'sourceRKey' => $mergeRequest['sourceRepository'],
|
||
'sourceBranch' => $sourceBranch,
|
||
'targetBranch' => $targetBranch
|
||
], $uKey);
|
||
Response::output([]);
|
||
}
|
||
}
|
||
|
||
Response::reject(0x0405);
|
||
}
|
||
|
||
public function blameInfo_get()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$data = Request::parse()->query;
|
||
$rKey = $data['repository'];
|
||
$revision = $data['revision'];
|
||
$filepath = $data['path'];
|
||
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$rKey,
|
||
$uKey,
|
||
UserAccessController::UAC_MR_READ
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
$blameData = $this->repositoryModel->getBlameInfo($rKey, $uKey, $revision, $filepath);
|
||
|
||
Response::output([
|
||
'blame' => $blameData[0],
|
||
'lines' => $blameData[1]
|
||
]);
|
||
}
|
||
|
||
public function mergeRequestDetail_get()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$data = Request::parse()->query;
|
||
$rKey = $data['repository'];
|
||
$mId = $data['mid'];
|
||
|
||
if (!$rKey || !$mId) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!$this->service->requestRepositoryPermission(
|
||
$rKey,
|
||
$uKey,
|
||
UserAccessController::UAC_MR_READ
|
||
)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
$res = $this->repositoryModel->getMergeRequestByIdAndKey($mId, $rKey);
|
||
|
||
$userInfo = $this->userModel->get($res['user']);
|
||
|
||
if ($userInfo) {
|
||
$res['email'] = $userInfo['u_email'];
|
||
}
|
||
|
||
if (count($res)) {
|
||
Response::output($res);
|
||
}
|
||
}
|
||
|
||
public function deleteBranch_post()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$data = Request::parse()->parsed;
|
||
$rKey = $data['repository'];
|
||
$branch = trim($data['branch']);
|
||
|
||
if (!$rKey || !$branch) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!$this->service->requestRepositoryPermission($rKey, $uKey, UserAccessController::UAC_REPO_BRANCH_REMOVE)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
$repository = $this->repositoryModel->get($rKey);
|
||
if ($branch == $repository['r_default_branch_name']) {
|
||
Response::reject(0x0405);
|
||
}
|
||
|
||
$result = $this->repositoryModel->deleteBranch($rKey, $uKey, $branch);
|
||
if (!$result) {
|
||
Response::reject(0x0405);
|
||
}
|
||
|
||
$repository = $this->repositoryModel->get($rKey);
|
||
|
||
$this->service->newEvent('BRANCH_REMOVE', [
|
||
'gKey' => $repository['g_key'],
|
||
'rKey' => $rKey,
|
||
'name' => $branch
|
||
], $uKey);
|
||
|
||
Response::output([]);
|
||
}
|
||
|
||
public function tagList_get()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$rKey = Request::parse()->query['repository'];
|
||
|
||
if (!$rKey) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!$this->service->requestRepositoryPermission($rKey, $uKey, UserAccessController::UAC_REPO_READ)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
$result = $this->repositoryModel->getTags($rKey, $uKey);
|
||
|
||
Response::output($result);
|
||
}
|
||
|
||
public function createTag_post()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$data = Request::parse()->parsed;
|
||
$rKey = $data['repository'];
|
||
$name = trim($data['name']);
|
||
$commitSHA = trim($data['origin']);
|
||
$description = trim($data['description']);
|
||
|
||
if (!$rKey || !$name) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!preg_match('/^\w+(\.\w+)*$/', $name)) {
|
||
Response::reject(0x0202);
|
||
}
|
||
|
||
if (!$this->service->requestRepositoryPermission($rKey, $uKey, UserAccessController::UAC_REPO_TAG_CREATE)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
$result = $this->groupModel->checkPreserve($name);
|
||
if ($result) {
|
||
Response::reject(0x0403);
|
||
}
|
||
|
||
$branchList = $this->repositoryModel->getBranchList($rKey, $uKey);
|
||
$tagList = $this->repositoryModel->getTagList($rKey, $uKey);
|
||
if (in_array($name, $branchList) || in_array($name, $tagList)) {
|
||
Response::reject(0x0406);
|
||
}
|
||
|
||
$result = $this->repositoryModel->createTag($rKey, $uKey, $name, $description, $commitSHA);
|
||
if ($result) {
|
||
Response::reject(0x040C);
|
||
}
|
||
|
||
$repository = $this->repositoryModel->get($rKey);
|
||
$this->service->newEvent('TAG_CREATE', [
|
||
'gKey' => $repository['g_key'],
|
||
'rKey' => $rKey,
|
||
'name' => $name
|
||
], $uKey);
|
||
|
||
Response::output([]);
|
||
}
|
||
|
||
public function deleteTag_post()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$data = Request::parse()->parsed;
|
||
$rKey = $data['repository'];
|
||
$tag = trim($data['tag']);
|
||
|
||
if (!$rKey || !$tag) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!$this->service->requestRepositoryPermission($rKey, $uKey, UserAccessController::UAC_REPO_TAG_REMOVE)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
$result = $this->repositoryModel->deleteTag($rKey, $uKey, $tag);
|
||
if (!$result) {
|
||
Response::reject(0x0405);
|
||
}
|
||
|
||
$repository = $this->repositoryModel->get($rKey);
|
||
|
||
$this->service->newEvent('TAG_REMOVE', [
|
||
'gKey' => $repository['g_key'],
|
||
'rKey' => $rKey,
|
||
'name' => $tag
|
||
], $uKey);
|
||
|
||
Response::output([]);
|
||
}
|
||
|
||
public function targetRepository_get()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$rKey = Request::parse()->query['repository'];
|
||
|
||
if (!$rKey) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
$result = [];
|
||
$targetRepository = [];
|
||
$repository = $this->repositoryModel->get($rKey);
|
||
$group = $this->groupModel->get($repository['g_key']);
|
||
$targetRepository['rKey'] = $rKey;
|
||
$targetRepository['name'] = $group['g_display_name'] . '/' . $repository['r_display_name'];
|
||
$targetRepository['forkFlag'] = false;
|
||
array_push($result, $targetRepository);
|
||
|
||
$targetRepository = [];
|
||
if ($repository['r_fork_r_key']) {
|
||
$forkRepoKey = $repository['r_fork_r_key'];
|
||
$forkRepository = $this->repositoryModel->get($forkRepoKey);
|
||
if (!$forkRepository) {
|
||
Response::output($result);
|
||
} else {
|
||
$group = $this->groupModel->get($forkRepository['g_key']);
|
||
$targetRepository['rKey'] = $forkRepoKey;
|
||
$targetRepository['name'] = $group['g_display_name'] . '/' . $forkRepository['r_display_name'];
|
||
$targetRepository['forkFlag'] = true;
|
||
array_push($result, $targetRepository);
|
||
}
|
||
}
|
||
|
||
Response::output($result);
|
||
}
|
||
|
||
public function getWebhook_post()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$data = Request::parse()->parsed;
|
||
$rKey = $data['repository'];
|
||
$rwKey = $data['rwKey'];
|
||
|
||
if (!$rKey || !$rwKey) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!$this->service->requestRepositoryPermission($rKey, $uKey, UserAccessController::UAC_REPO_READ)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
$webhook = $this->repositoryModel->getWebhook($rwKey);
|
||
$webhook = $this->repositoryModel->normalizeWebhooks($webhook ? [$webhook] : []);
|
||
Response::output($webhook ? $webhook[0] : []);
|
||
}
|
||
|
||
public function webhooks_post()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$rKey = Request::parse()->parsed['repository'];
|
||
|
||
if (!$rKey) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!$this->service->requestRepositoryPermission($rKey, $uKey, UserAccessController::UAC_REPO_READ)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
$webhooks = $this->repositoryModel->getWebhooks($rKey);
|
||
$webhooks = $this->repositoryModel->normalizeWebhooks($webhooks);
|
||
|
||
Response::output($webhooks);
|
||
}
|
||
|
||
public function editWebhook_post()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$data = Request::parse()->parsed;
|
||
$rKey = $data['repository'];
|
||
$rwKey = $data['rwKey'];
|
||
$url = $data['url'];
|
||
$secret = $data['secret'];
|
||
$events = $data['events'];
|
||
$active = (int) $data['active'];
|
||
|
||
if (!$url || !$events || !in_array($active, [1, 2])) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!$this->service->requestRepositoryPermission($rKey, $uKey, UserAccessController::UAC_REPO_WEBHOOK_EDIT)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
$dbData = array(
|
||
'rw_url' => $url,
|
||
'rw_secret' => $secret,
|
||
'rw_events' => $events,
|
||
'rw_active' => $active
|
||
);
|
||
|
||
if ($rwKey) {
|
||
$result = $this->repositoryModel->updateWebhook($rwKey, $dbData);
|
||
$eventType = 'WEBHOOK_UPDATE';
|
||
} else {
|
||
$dbData['u_key'] = $uKey;
|
||
$dbData['r_key'] = $rKey;
|
||
$result = $this->repositoryModel->createWebhook($dbData);
|
||
$eventType = 'WEBHOOK_CREATE';
|
||
}
|
||
|
||
if (!$result) {
|
||
Response::reject(0x0405);
|
||
}
|
||
|
||
$repository = $this->repositoryModel->get($rKey);
|
||
$this->service->newEvent($eventType, [
|
||
'gKey' => $repository['g_key'],
|
||
'rKey' => $rKey,
|
||
'rwKey' => $result
|
||
], $uKey);
|
||
|
||
Response::output([]);
|
||
}
|
||
|
||
public function deleteWebhook_post()
|
||
{
|
||
$uKey = Request::parse()->authData['userData']['u_key'];
|
||
$data = Request::parse()->parsed;
|
||
$rKey = $data['repository'];
|
||
$rwKey = $data['rwKey'];
|
||
|
||
if (!$rKey || !$rwKey) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
if (!$this->service->requestRepositoryPermission($rKey, $uKey, UserAccessController::UAC_REPO_WEBHOOK_REMOVE)) {
|
||
Response::reject(0x0106);
|
||
}
|
||
|
||
if (!$this->repositoryModel->deleteWebhook($rwKey)) {
|
||
Response::reject(0x0405);
|
||
}
|
||
|
||
// DELETE EVENTS AND LOGS
|
||
$this->repositoryModel->deleteWebhookEventsByRwKey($rwKey);
|
||
$this->repositoryModel->deleteWebhookLogsByRwKey($rwKey);
|
||
|
||
$repository = $this->repositoryModel->get($rKey);
|
||
$this->service->newEvent('WEBHOOK_DELETE', [
|
||
'gKey' => $repository['g_key'],
|
||
'rKey' => $rKey,
|
||
'rwKey' => $rwKey,
|
||
], $uKey);
|
||
|
||
Response::output([]);
|
||
}
|
||
|
||
public function getRepositoryWebhookLogs_post()
|
||
{
|
||
$data = Request::parse()->parsed;
|
||
$rwKey = $data['webhook'];
|
||
|
||
if (!$rwKey) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
$logs = $this->repositoryModel->getRepositoryWebhookLogs($rwKey);
|
||
$logs = $this->repositoryModel->normalizeRepositoryWebhookLogs($logs);
|
||
|
||
Response::output($logs);
|
||
}
|
||
|
||
public function getRepositoryWebhookLogData_post()
|
||
{
|
||
$data = Request::parse()->parsed;
|
||
$id = $data['id'];
|
||
|
||
if (!$id) {
|
||
Response::reject(0x0201);
|
||
}
|
||
|
||
$log = $this->repositoryModel->getRepositoryWebhookLogData($id);
|
||
$log = $this->repositoryModel->normalizeRepositoryWebhookLogData($log);
|
||
|
||
Response::output($log);
|
||
}
|
||
}
|