pulls.osl

def projectGitHead(object project) string (
    if project.contains("gitHead") and project.gitHead != null (
        return project.gitHead.toStr()
    )
    return ""
)

def projectHasWorkspace(object project) boolean (
    return projectWorkspaceKeys(project).len > 0 and projectGitHead(project) != ""
)

def pullDocument(string targetId, string index) object (
    return pullDocs.findById(targetId ++ ":" ++ index)
)

def pullResponse(object pull) object (
    return {
        id: pull["_id"],
        index: pull.index,
        title: pull.title,
        body: pull.body,
        state: pull.state,
        user: pull.author,
        sourceOwner: pull.sourceOwner,
        sourceProjectId: pull.sourceProjectId,
        sourceTitle: pull.sourceTitle,
        targetProjectId: pull.targetProjectId,
        baseCommit: pull.baseCommit,
        headCommit: pull.headCommit,
        targetHead: pull.targetHead,
        baseBranch: pull.targetBranch,
        headBranch: pull.sourceBranch,
        created: pull.created,
        updated: pull.updated,
        merged: pull.state.toStr() == "merged",
        mergedCommit: pull.mergedCommit
    }
)

def createNativePull(*serve.Context c, object target, object source, string title, string description, string bountyId) object (
    if !projectHasWorkspace(target) or !projectHasWorkspace(source) (
        return {ok: false, status: 400, error: "both projects need MistWarp history before changes can be sent"}
    )
    if projectRole(source, c.getString("username")) != "owner" (
        return {ok: false, status: 403, error: "use a remix you own"}
    )
    if source.remixParent.toStr() != target.id.toStr() (
        return {ok: false, status: 400, error: "the source project is not a direct remix of this project"}
    )
    if title == "" or title.len > 200 (
        return {ok: false, status: 400, error: "invalid title"}
    )
    string baseCommit = ""
    if source.contains("remixBaseCommit") and source.remixBaseCommit != null (
        baseCommit = source.remixBaseCommit.toStr()
    )
    if baseCommit == "" (
        return {ok: false, status: 400, error: "the remix does not record where it started"}
    )
    number sequence = 0
    if target.contains("nativePullSeq") and target.nativePullSeq != null (
        sequence = target.nativePullSeq.toNum()
    )
    sequence = sequence + 1
    target.nativePullSeq = sequence
    saveProject(target)

    string id = target.id.toStr() ++ ":" ++ sequence.toStr()
    string sourceBranch = "main"
    if source.contains("gitBranch") and source.gitBranch != null (
        sourceBranch = source.gitBranch.toStr()
    )
    string targetBranch = "main"
    if target.contains("gitBranch") and target.gitBranch != null (
        targetBranch = target.gitBranch.toStr()
    )
    object pull = {
        _id: id,
        index: sequence,
        title: title,
        body: description.trim(1, 5000),
        state: "open",
        author: c.getString("username"),
        authorId: c.getString("userId"),
        sourceOwner: source.owner,
        sourceOwnerId: source.ownerId,
        sourceProjectId: source.id,
        sourceTitle: source.title,
        sourceBranch: sourceBranch,
        targetProjectId: target.id,
        targetBranch: targetBranch,
        baseCommit: baseCommit,
        headCommit: projectGitHead(source),
        targetHead: projectGitHead(target),
        created: timestamp,
        updated: timestamp,
        mergedCommit: "",
        bountyId: bountyId
    }
    if !putDocument(pullDocs, id, pull) (
        return {ok: false, status: 500, error: "could not store the pull request"}
    )
    addNotification(target.owner.toStr(), c.getString("username"), "contribution", {projectId: target.id, projectTitle: target.title, pull: sequence})
    return {ok: true, pull: pullResponse(pull)}
)

def handleGetCommits(*serve.Context c) (
    auto result = loadProject(c.param("id"))
    if !result.ok or !canViewProject(result.project.assert(object), c) (
        c.notFound("project not found")
        return
    )
    object project = result.project.assert(object)
    object history = projectVersionHistory(project)
    c.json(200, {
        ok: true,
        head: projectGitHead(project),
        branch: history.branch,
        commits: history.commits,
        graph: history.graph,
        virtual: history.virtual
    })
)

def handleListPulls(*serve.Context c) (
    auto result = loadProject(c.param("id"))
    if !result.ok or !canViewProject(result.project.assert(object), c) (
        c.notFound("project not found")
        return
    )
    array stored = pullDocs.where("targetProjectId", db.equal, c.param("id")).sort("created", db.desc).limit(200).all()
    array pulls = []
    for i stored.len (
        pulls.append(pullResponse(stored[i].assert(object)))
    )
    c.json(200, {ok: true, pulls: pulls})
)

def handleCreatePull(*serve.Context c) (
    auto targetResult = loadProject(c.param("id"))
    object body = c.bodyJSON()
    auto sourceResult = loadProject(body.sourceProjectId.toStr())
    if !targetResult.ok or !sourceResult.ok (
        c.notFound("project not found")
        return
    )
    string description = ""
    if body.contains("body") and body.body != null (
        description = body.body.toStr()
    )
    string bountyId = ""
    if body.contains("bountyId") and body.bountyId != null (
        bountyId = body.bountyId.toStr().strip()
    )
    object created = createNativePull(c, targetResult.project.assert(object), sourceResult.project.assert(object), body.title.toStr().strip(), description, bountyId)
    if !created.ok (
        c.json(created.status.toInt(), {ok: false, error: created.error})
        return
    )
    c.json(201, created)
)

def handleGetPull(*serve.Context c) (
    object pull = pullDocument(c.param("id"), c.param("index"))
    if pull.isEmpty() == true (
        c.notFound("pull request not found")
        return
    )
    c.json(200, {ok: true, pull: pullResponse(pull)})
)

def canAccessPullWorkspace(object project, string pullIndex, *serve.Context c) boolean (
    if !c.getBool("authenticated") (
        return false
    )
    array matches = pullDocs.where("index", db.equal, pullIndex.toNum()).limit(20).all()
    for i matches.len (
        object pull = matches[i].assert(object)
        boolean related = pull.sourceProjectId.toStr() == project.id.toStr() or pull.targetProjectId.toStr() == project.id.toStr()
        if related (
            auto targetResult = loadProject(pull.targetProjectId.toStr())
            if targetResult.ok (
                object target = targetResult.project.assert(object)
                string viewer = normalizeUsername(c.getString("username"))
                if canEditProject(target, c) or viewer == normalizeUsername(pull.sourceOwner.toStr()) (
                    return true
                )
            )
        )
    )
    return false
)

def handleGetPullDiff(*serve.Context c) (
    object pull = pullDocument(c.param("id"), c.param("index"))
    if pull.isEmpty() == true (
        c.notFound("pull request not found")
        return
    )
    auto targetResult = loadProject(pull.targetProjectId.toStr())
    auto sourceResult = loadProject(pull.sourceProjectId.toStr())
    if !targetResult.ok or !sourceResult.ok (
        c.notFound("project not found")
        return
    )
    object target = targetResult.project.assert(object)
    object source = sourceResult.project.assert(object)
    if !canAccessPullWorkspace(target, pull.index.toStr(), c) (
        c.forbidden("only the fork owner and project maintainers can inspect this pull request")
        return
    )
    string suffix = "?pull=" ++ pull.index.toStr()
    c.json(200, {
        ok: true,
        pull: pullResponse(pull),
        targetWorkspaceUrl: appURL ++ "/api/projects/" ++ target.id.toStr() ++ "/workspace.mwp" ++ suffix,
        sourceWorkspaceUrl: appURL ++ "/api/projects/" ++ source.id.toStr() ++ "/workspace.mwp" ++ suffix,
        expectedHead: projectGitHead(target)
    })
)

def handleMergePull(*serve.Context c) (
    object pull = pullDocument(c.param("id"), c.param("index"))
    if pull.isEmpty() == true or pull.state.toStr() != "open" (
        c.notFound("open pull request not found")
        return
    )
    auto result = loadProject(c.param("id"))
    if !result.ok or !canEditProject(result.project.assert(object), c) (
        c.forbidden("only the project owner can merge")
        return
    )
    handleGetPullDiff(c)
)

def completeNativePull(object project, string pullIndex, string expectedHead, string username) boolean (
    object pull = pullDocument(project.id.toStr(), pullIndex)
    if pull.isEmpty() == true or pull.state.toStr() != "open" (
        return false
    )
    string role = projectRole(project, username)
    if role != "owner" and role != "maintainer" (
        return false
    )
    if expectedHead == "" or pull.targetHead.toStr() != expectedHead (
        return false
    )
    pull.state = "merged"
    pull.mergedCommit = projectGitHead(project)
    pull.updated = timestamp
    putDocument(pullDocs, pull["_id"].toStr(), pull)

    number acceptedChanges = 0
    if project.contains("acceptedChanges") and project.acceptedChanges != null (
        acceptedChanges = project.acceptedChanges.toNum()
    )
    project.acceptedChanges = acceptedChanges + 1
    array mergedContributors = []
    if project.contains("mergedContributors") and project.mergedContributors != null (
        mergedContributors = project.mergedContributors.assert(array)
    )
    string contributor = pull.sourceOwner.toStr()
    if contributor != "" and !mergedContributors.contains(contributor) (
        mergedContributors.append(contributor)
    )
    project.mergedContributors = mergedContributors
    saveProject(project)
    upsertIndexEntry(project)
    addNotification(pull.sourceOwner.toStr(), project.owner.toStr(), "contribution_merged", {projectId: project.id, projectTitle: project.title, pull: pull.index})
    if pull.contains("bountyId") and pull.bountyId != null and pull.bountyId.toStr() != "" (
        boolean bountyPaid = awardContributionBounty(pull.bountyId.toStr(), project.id.toStr(), pull.sourceOwner.toStr())
        if !bountyPaid (
            log "WARNING: could not award contribution bounty " ++ pull.bountyId.toStr()
        )
    )
    return true
)