/tree/repo - Senary

requests.go

package repo

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"sync"

	"html/template"
	"net/http"
	"os"
	"path"
	"path/filepath"
	"senary/auth"
	"senary/common"
	"slices"
	"strings"

	"github.com/bluekeyes/go-gitdiff/gitdiff"
)

type RequestList struct {
	RequestBase
	Requests []*common.IssueRequest
}

type RequestManager struct {
	config       *common.Config
	repo         string
	ac           *auth.AuthClient
	lock         sync.Mutex
	patchHandler PatchHandler
}

type RequestBase struct {
	User     common.AuthInfo
	Repo     string
	ClientID string
	Warnings []Warning
}

type Warning struct {
	Level   Level
	Message string
}

type RequestElement struct {
	RequestBase
	Request string

	Issue common.IssueRequest
}

type RequestThread struct {
	RequestBase
	Title    string
	ID       string
	Issue    common.IssueRequest
	Elements []template.HTML
}

func NewRequestManager(config *common.Config, repo string, ac *auth.AuthClient) *RequestManager {
	return &RequestManager{config: config, repo: repo, ac: ac, patchHandler: *NewPatchHandler(config, repo)}
}

func (rm *RequestManager) errorHandler(err string, w http.ResponseWriter, r *http.Request) {
	r.AddCookie(&http.Cookie{Name: "error", Value: err})
	rm.Serve(w, r)
}

func (rm *RequestManager) ApplyPatch(w http.ResponseWriter, r *http.Request) {

	authUser := rm.ac.GetAuthInfo(rm.config, r)

	if authUser.IsMaintainer {
		idString := r.PathValue("id")
		patchHash := r.PathValue("patch")
		err := rm.patchHandler.Apply(rm.RequestIssueElement(idString, patchHash))
		if err == nil {
			err := rm.patchHandler.Upstream()
			if err != nil {
				fmt.Printf("could not upstream: %v\n", err)
			}
			err = rm.patchHandler.Rebuild()
			if err != nil {
				fmt.Printf("could not rebuild: %v\n", err)
			}
			http.Redirect(w, r, r.Header.Get("Referer"), 302)
			return
		} else {
			fmt.Printf("could not apply patch: %v\n", err)
		}
	}
	http.Redirect(w, r, "/404", 404)
}

func (rm *RequestManager) ServePatch(w http.ResponseWriter, r *http.Request) {
	idString := r.PathValue("id")
	patchHash := r.PathValue("patch")
	patchfile, err := os.Open(rm.RequestIssueElement(idString, patchHash))
	if err == nil {
		defer patchfile.Close()
		w.Header().Set("Content-Disposition", "attachment; filename="+patchHash+".patch")
		w.Header().Set("Content-Type", "text/x-diff")
		io.Copy(w, patchfile)
		return
	}
	http.Redirect(w, r, "/404", 404)
}

func (rm *RequestManager) Serve(w http.ResponseWriter, r *http.Request) {

	baseResponse := RequestList{RequestBase: RequestBase{Repo: rm.repo, User: rm.ac.GetAuthInfo(rm.config, r), ClientID: rm.config.ClientID}}

	if cookie, _ := r.Cookie("error"); cookie != nil {
		baseResponse.Warnings = append(baseResponse.Warnings, Warning{Level: WARN, Message: cookie.Value})
	}

	if strings.HasSuffix(r.URL.Path, "/new") {
		if value := r.FormValue("type"); value == "issue" {
			rm.config.Templates.ExecuteTemplate(w, "request.new.tpl.html", baseResponse)
			return
		}
		if value := r.FormValue("type"); value == "patch" {
			rm.config.Templates.ExecuteTemplate(w, "request.newpatch.tpl.html", baseResponse)
			return
		}
	}

	// assume this is an issue thread...
	if !strings.HasSuffix(r.URL.Path, "/") {
		http.Redirect(w, r, r.URL.String()+"/", http.StatusMovedPermanently)
	}

	// list all issues
	if strings.HasSuffix(r.URL.Path, "requests/") {
		authuser := rm.ac.GetAuthInfo(rm.config, r)
		rl := baseResponse

		// Get a list of issues in creation order...
		issueList := rm.LoadIssues(rm.RequestLogPath(), func(hash string) (*common.IssueRequest, error) {
			data, err := os.ReadFile(rm.RequestIssuePath(hash))
			if err == nil {
				var issue common.IssueRequest
				err := json.Unmarshal(data, &issue)
				return &issue, err
			}
			return nil, err
		},
			func(ir common.IssueRequest) bool {
				return authuser.IsMaintainer
			},
			func(level Level, warning string) {

			})
		slices.Reverse(issueList)
		rl.Requests = issueList

		err := rm.config.Templates.ExecuteTemplate(w, "request.list.tpl.html", rl)
		if err != nil {
			fmt.Printf("error %v\n", err)
		}
		return
	}

	// otherwise list a single issue...
	authuser := rm.ac.GetAuthInfo(rm.config, r)
	// otherwise...
	rt := RequestThread{RequestBase: baseResponse.RequestBase}
	issuehash := path.Base(r.URL.Path)
	// Get a list of issues in creation order...

	issueList := rm.LoadIssues(rm.RequestIssueLogPath(issuehash), func(hash string) (*common.IssueRequest, error) {
		data, err := os.ReadFile(rm.RequestIssueElement(issuehash, hash))
		if err == nil {
			var issue common.IssueRequest
			err := json.Unmarshal(data, &issue)
			return &issue, err
		}
		return nil, err
	},
		func(ir common.IssueRequest) bool {
			return ir.RequestType == common.RequestInit || authuser.IsMaintainer
		},

		func(level Level, warning string) {

			rt.Warnings = append(rt.Warnings, Warning{Level: level, Message: warning})

		})

	for _, issue := range issueList {

		if issue.RequestType == common.RequestInit {
			rt.Title = issue.Summary
			rt.ID = issue.ID
			rt.Issue = *issue
		}

		var doc bytes.Buffer
		rm.config.Templates.ExecuteTemplate(&doc, "request.element.tpl.html", RequestElement{Issue: *issue, Request: issuehash, RequestBase: rt.RequestBase})
		rt.Elements = append(rt.Elements, template.HTML(doc.String()))
	}

	err := rm.config.Templates.ExecuteTemplate(w, "request.thread.tpl.html", rt)
	if err != nil {
		fmt.Printf("error %v\n", err)
	}
}

type Level int

const (
	WARN = Level(iota)
	INFO
)

func (rm *RequestManager) LoadIssues(logpath string, loadfn func(hash string) (*common.IssueRequest, error), approve func(common.IssueRequest) bool, warningCallback func(Level, string)) []*common.IssueRequest {

	issueMap := make(map[string]*common.IssueRequest)

	common.LogIer(logpath, func(le common.LogEntry) {
		//isFirst := issuehash == le.Hash
		if le.Type == common.LOG_APPROVED {
			issueMap[le.Hash].Approved = true
			issueMap[le.Hash].Moderated = false
		} else if le.Type == common.LOG_DELETED {
			issueMap[le.Hash].Approved = false
			issueMap[le.Hash].Moderated = false
		} else {

			issue, err := loadfn(le.Hash)
			if err == nil {

				issueMap[le.Hash] = issue
				issueMap[le.Hash].Moderated = true
				issueMap[le.Hash].Approved = approve(*issue)

				if issue.PatchRef != "" {
					// NOTE: this currently takes advantage of the fact that patches can only be associated with a top
					// level issue, this is not the ideal long term...
					patchfile, err := os.Open(rm.RequestIssueElement(le.Hash, issue.PatchRef))
					if err == nil {
						files, prelude, err := gitdiff.Parse(patchfile)
						if err == nil {

							header, err := gitdiff.ParsePatchHeader(prelude)
							if err == nil {
								patchSummary := common.PatchInfo{}
								patchSummary.Title = header.Title
								if header.Author != nil {
									patchSummary.Author = header.Author.String()
								}

								var doc bytes.Buffer
								rm.config.Templates.ExecuteTemplate(&doc, "diffstat.tpl.html", files)
								patchSummary.Body = template.HTML(doc.String())
								issue.PatchInfo = patchSummary

								if _, err := rm.patchHandler.CheckApplied(rm.RequestIssueElement(le.Hash, issue.PatchRef)); err == nil {
									warningCallback(INFO, "This Patch Has Been Applied")
								} else {
									if _, err := rm.patchHandler.CheckApply(rm.RequestIssueElement(le.Hash, issue.PatchRef)); err != nil {
										warningCallback(WARN, "This Patch Does Not Apply To The Current Repository")
									} else {
										warningCallback(INFO, "This Patch Can Be Applied To The Current Repository")
										issue.PatchInfo.CanBeApplied = true
									}
								}

							}
						}
					}
				}

			}
		}
	})

	issueList := []*common.IssueRequest{}

	for _, issue := range issueMap {
		if issue.Approved {
			issueList = append(issueList, issue)
		}
	}

	if len(issueList) > 0 {
		if issueList[0].Moderated {
			warningCallback(INFO, "Public Listing of this Request Is Pending Review By A Maintainer")
		}
	}

	slices.SortFunc(issueList, func(a *common.IssueRequest, b *common.IssueRequest) int {
		return a.Created.Compare(b.Created)
	})

	return issueList
}

func (rm *RequestManager) RequestLogPath() string {
	return filepath.Join(rm.config.RequestsDir, rm.repo, "log")
}

func (rm *RequestManager) RequestIssuePath(issuehash string) string {
	return filepath.Join(rm.config.RequestsDir, rm.repo, issuehash, issuehash)
}

func (rm *RequestManager) RequestIssueElement(issuehash string, subhash string) string {
	return filepath.Join(rm.config.RequestsDir, rm.repo, issuehash, subhash)
}

func (rm *RequestManager) RequestIssueLogPath(issuehash string) string {
	return filepath.Join(rm.config.RequestsDir, rm.repo, issuehash, "log")
}

func (rm *RequestManager) handleApprove(w http.ResponseWriter, r *http.Request) {

	if rm.ac.GetAuthInfo(rm.config, r).IsMaintainer {
		id := r.FormValue("requestid")
		eid := r.FormValue("elementid")

		if len(eid) == 0 {
			// approving a top-level
			err := rm.updateLog(rm.RequestLogPath(), id, common.LOG_APPROVED)
			if err != nil {
				http.Error(w, err.Error(), http.StatusBadRequest)
				return
			}

			// approving the top-level sub-level
			err = rm.updateLog(rm.RequestIssueLogPath(id), id, common.LOG_APPROVED)
			if err != nil {
				http.Error(w, err.Error(), http.StatusBadRequest)
				return
			}

		} else {

			// approving a sub-level
			err := rm.updateLog(rm.RequestIssueLogPath(id), eid, common.LOG_APPROVED)
			if err != nil {
				http.Error(w, err.Error(), http.StatusBadRequest)
				return
			}
		}
	}
	http.Redirect(w, r, r.Header.Get("Referer"), 302)
}

func (rm *RequestManager) handleTombstone(w http.ResponseWriter, r *http.Request) {

	if rm.ac.GetAuthInfo(rm.config, r).IsMaintainer {
		id := r.FormValue("requestid")
		eid := r.FormValue("elementid")

		if len(eid) == 0 {
			// approving a top-level
			err := rm.updateLog(rm.RequestLogPath(), id, common.LOG_DELETED)
			if err != nil {
				http.Error(w, err.Error(), http.StatusBadRequest)
				return
			}
		} else {
			// approving a sub-level
			err := rm.updateLog(rm.RequestIssueLogPath(id), eid, common.LOG_DELETED)
			if err != nil {
				http.Error(w, err.Error(), http.StatusBadRequest)
				return
			}
		}
	}
	http.Redirect(w, r, r.Header.Get("Referer"), 302)
}

// thread safe logging (note: currently this means a global lock per repo for threads, this is likely fine for the target of smaller sites)
// as the locks are only used when recording hashes for new files/approvals/deletions
// TODO: in the future, break this down further to a lock per log?
func (rm *RequestManager) updateLog(logpath string, hash string, status common.LogType) error {
	rm.lock.Lock()
	defer rm.lock.Unlock()
	return common.WriteToLog(logpath, hash, status)
}

func (rm *RequestManager) handlePatch(w http.ResponseWriter, r *http.Request) {

	r.ParseMultipartForm(1024 * 1024 * int64(rm.config.MaxPatchSizeMB))
	file, _, err := r.FormFile("patchfile")
	if err != nil {
		rm.errorHandler("Could Not Create Patch Request", w, r)
		return
	}
	defer file.Close()

	id, err := common.RandomIdent(24)
	if err != nil {
		rm.errorHandler("Could Not Create Patch Request", w, r)
		return
	}

	fileBytes, err := io.ReadAll(file)
	if err != nil {
		rm.errorHandler("Could Not Create Patch Request", w, r)
		return
	}

	// TODO check that this is a patch file...
	buf := bytes.NewBuffer(fileBytes)
	_, description, err := gitdiff.Parse(buf)
	if err != nil {
		rm.errorHandler("Could Not Create Patch Request", w, r)
		return
	}
	if _, err := gitdiff.ParsePatchHeader(description); err != nil {
		rm.errorHandler("Could Not Create Patch Request", w, r)
		return
	}

	summary := r.FormValue("summary")
	issueRequest, err := common.NewIssueRequest(summary, description, rm.ac.GetAuthInfo(rm.config, r))
	if err != nil {
		rm.errorHandler("Could Not Create Patch Request", w, r)
		return
	}
	issueRequest.PatchRef = id

	patchRef := filepath.Join(rm.config.RequestsDir, rm.repo, issueRequest.ID, issueRequest.PatchRef)
	os.MkdirAll(filepath.Dir(patchRef), 0755)
	patchFile, _ := os.Create(patchRef)
	defer patchFile.Close()
	// write this byte array to our temporary file
	patchFile.Write(fileBytes)

	rm.SaveIssue(&issueRequest, w, r)

	http.Redirect(w, r, path.Join("/repos", rm.repo, "requests", issueRequest.ID), http.StatusTemporaryRedirect)
}

func (rm *RequestManager) SaveIssue(issueRequest *common.IssueRequest, w http.ResponseWriter, r *http.Request) {
	requestName := filepath.Join(rm.config.RequestsDir, rm.repo, issueRequest.ID, issueRequest.ID)
	os.MkdirAll(filepath.Dir(requestName), 0755)
	err := os.WriteFile(requestName, issueRequest.Serialize(), 0644)
	if err != nil {
		rm.errorHandler(err.Error(), w, r)
		return
	}

	// create the parent entry of the requests log
	err = rm.updateLog(filepath.Join(rm.config.RequestsDir, rm.repo, issueRequest.ID, "log"), issueRequest.ID, common.LOG_CREATED)
	if err != nil {
		rm.errorHandler(err.Error(), w, r)
		return
	}

	// finally write to our main requests log
	err = rm.updateLog(filepath.Join(rm.config.RequestsDir, rm.repo, "log"), issueRequest.ID, common.LOG_CREATED)
	if err != nil {
		rm.errorHandler(err.Error(), w, r)
		return
	}

	if issueRequest.User.IsMaintainer {
		// Auth Approve Maintainer Created Issues
		err = rm.updateLog(filepath.Join(rm.config.RequestsDir, rm.repo, "log"), issueRequest.ID, common.LOG_APPROVED)
		if err != nil {
			rm.errorHandler(err.Error(), w, r)
			return
		}

		// Auto Approve Maintainer Top Level Issue
		err = rm.updateLog(filepath.Join(rm.config.RequestsDir, rm.repo, issueRequest.ID, "log"), issueRequest.ID, common.LOG_APPROVED)
		if err != nil {
			rm.errorHandler(err.Error(), w, r)
			return
		}

	}

}

func (rm *RequestManager) handleNew(w http.ResponseWriter, r *http.Request) {
	if r.Response != nil {
		fmt.Printf("now here....\n")
		rm.Serve(w, r)
		return
	}

	summary := r.FormValue("summary")
	description := r.FormValue("description")
	replyto := r.FormValue("replyto")
	newtype := r.FormValue("type")
	if replyto == "" {

		if newtype == "issue" {
			if len(summary) == 0 || len(summary) > rm.config.MaxCommentLength {
				rm.errorHandler(fmt.Errorf("summary was empty, or too long").Error(), w, r)
				return
			}

			if len(description) == 0 || len(description) > rm.config.MaxCommentLength {
				rm.errorHandler(fmt.Errorf("description was empty, or too long").Error(), w, r)
				return
			}

			issueRequest, err := common.NewIssueRequest(summary, description, rm.ac.GetAuthInfo(rm.config, r))
			if err != nil {
				rm.errorHandler(err.Error(), w, r)
				return
			}

			rm.SaveIssue(&issueRequest, w, r)
			http.Redirect(w, r, path.Join("/repos", rm.repo, "requests", issueRequest.ID), http.StatusTemporaryRedirect)
		} else if newtype == "patch" {
			if len(summary) == 0 {
				rm.Serve(w, r)
				return
			}
			rm.handlePatch(w, r)
		}
	} else {
		// we are replying to an issue....
		if len(description) == 0 || len(description) > rm.config.MaxCommentLength {
			rm.errorHandler(fmt.Errorf("description was empty, or too long").Error(), w, r)
			return
		}
		issueRequest, err := common.NewIssueRequest(summary, description, rm.ac.GetAuthInfo(rm.config, r))
		if err != nil {
			rm.errorHandler(err.Error(), w, r)
			return
		}
		issueRequest.RequestType = common.RequestReply

		requestName := filepath.Join(rm.config.RequestsDir, rm.repo, replyto, issueRequest.ID)
		err = os.WriteFile(requestName, issueRequest.Serialize(), 0644)
		if err != nil {
			rm.errorHandler(err.Error(), w, r)
			return
		}

		// create the parent entry of the requests log
		err = rm.updateLog(rm.RequestIssueLogPath(replyto), issueRequest.ID, common.LOG_CREATED)
		if err != nil {
			rm.errorHandler(err.Error(), w, r)
			return
		}

		if issueRequest.User.IsMaintainer {
			// Auth Approve Maintainer Created Issues
			err = rm.updateLog(rm.RequestIssueLogPath(replyto), issueRequest.ID, common.LOG_APPROVED)
			if err != nil {
				rm.errorHandler(err.Error(), w, r)
				return
			}

		}

		http.Redirect(w, r, path.Join("/repos", rm.repo, "requests", replyto)+"/", http.StatusTemporaryRedirect)
		return
	}
}

func (rm *RequestManager) Submit(w http.ResponseWriter, r *http.Request) {

	if strings.HasSuffix(r.URL.Path, "/approve") {
		rm.handleApprove(w, r)
		return
	}

	if strings.HasSuffix(r.URL.Path, "/tombstone") {
		rm.handleTombstone(w, r)
		return
	}

	if strings.HasSuffix(r.URL.Path, "/new") {
		rm.handleNew(w, r)
		return
	}

	http.Redirect(w, r, "/404", 404)
}