jmb/scanfile
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

go format

Browse source
This commit is contained in:
Johannes Bülow 2025-07-25 12:43:28 +02:00
parent 4ee3a0be1a
commit cc8246c222
Signed by: jmb
GPG key ID: B56971CF7B8F83A6
18 changed files with 207 additions and 217 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
server/internal/config/config.go
View file

@ -45,16 +45,16 @@ func setDefaults() {
viper.SetDefault("db.debug", false)
// Others
viper.SetDefault("processing.oleurl", "http://localhost:5000")
viper.SetDefault("processing.maxmimesize", "100MB")
viper.SetDefault("processing.yararules", "./storage/rules")
viper.SetDefault("processing.maxmimesize", "100MB")
viper.SetDefault("processing.yararules", "./storage/rules")
viper.SetDefault("processing.yaracompiled", "./storage/output.yarc")
viper.SetDefault("store.path", "./storage/files")
viper.SetDefault("debug", false)
// UI Interface info
viper.SetDefault("ui.name", "Scanfile")
viper.SetDefault("ui.byurl", "https://www.jmbit.de")
viper.SetDefault("ui.byurl", "Johannes Bülow")
viper.SetDefault("ui.source", "https://git.jmbit.de/jmb/scanfile")
// UI Interface info
viper.SetDefault("ui.name", "Scanfile")
viper.SetDefault("ui.byurl", "https://www.jmbit.de")
viper.SetDefault("ui.byurl", "Johannes Bülow")
viper.SetDefault("ui.source", "https://git.jmbit.de/jmb/scanfile")
}
func SaveConfig() error {

23
server/internal/database/file.go
View file

@ -60,23 +60,22 @@ func GetFileMime(fileID pgtype.UUID) (string, error) {
}
func GetFileProperties(fileID pgtype.UUID) (sqlc.FileProperty, error) {
query := sqlc.New(pool)
fileProperties, err := query.GetFileProperties(context.Background(), fileID)
if err != nil {
slog.Error("Error in GetFileProperties", "file-uuid", fileID, "error", err)
}
return fileProperties, err
query := sqlc.New(pool)
fileProperties, err := query.GetFileProperties(context.Background(), fileID)
if err != nil {
slog.Error("Error in GetFileProperties", "file-uuid", fileID, "error", err)
}
return fileProperties, err
}
func GetAllFiles() ([]sqlc.File, error) {
query := sqlc.New(pool)
query := sqlc.New(pool)
//TODO use actual request context to avoid murdering the DB
files, err := query.GetAllFiles(context.Background())
if err != nil {
slog.Error("Error in GetAllProperties", "error", err)
}
return files, err
if err != nil {
slog.Error("Error in GetAllProperties", "error", err)
}
return files, err
}

24
server/internal/database/msoffice.go
View file

@ -15,19 +15,19 @@ func GetMSOfficeResults(fileID string) (sqlc.Msoffice, error) {
slog.Error("Unable to convert string to UUID", "file-uuid", fileID, "error", err)
}
query := sqlc.New(pool)
data, err := query.GetMSOfficeResults(context.Background(), pgUUID)
if err != nil {
slog.Error("Error in GetMsofficeInfo", "file-uuid", fileID, "error", err)
}
return data, err
data, err := query.GetMSOfficeResults(context.Background(), pgUUID)
if err != nil {
slog.Error("Error in GetMsofficeInfo", "file-uuid", fileID, "error", err)
}
return data, err
}
func InsertMSOfficeResults(params sqlc.InsertMSOfficeResultsParams) error {
query := sqlc.New(pool)
slog.Debug("InsertMSOfficeResults", "params", params)
err := query.InsertMSOfficeResults(context.Background(), params)
if err != nil {
slog.Error("Error in InsertMsofficeInfo", "file-uuid", params.FileID.String(), "error", err)
}
return err
query := sqlc.New(pool)
slog.Debug("InsertMSOfficeResults", "params", params)
err := query.InsertMSOfficeResults(context.Background(), params)
if err != nil {
slog.Error("Error in InsertMsofficeInfo", "file-uuid", params.FileID.String(), "error", err)
}
return err
}

10
server/internal/database/processingJob.go
View file

@ -73,9 +73,9 @@ func AddProcessingJobMessage(jobid int64, message string) error {
func ALlProcessingJobs() ([]sqlc.ProcessingJob, error) {
query := sqlc.New(pool)
jobs, err := query.GetAllJobs(context.Background())
if err != nil {
slog.Error("Unable to retrieve processing jobs", "error", err)
}
return jobs, err
jobs, err := query.GetAllJobs(context.Background())
if err != nil {
slog.Error("Unable to retrieve processing jobs", "error", err)
}
return jobs, err
}

24
server/internal/database/yara.go
View file

@ -15,19 +15,19 @@ func GetYaraResults(fileID string) (sqlc.YaraResult, error) {
slog.Error("Unable to convert string to UUID", "file-uuid", fileID, "error", err)
}
query := sqlc.New(pool)
data, err := query.GetYaraResults(context.Background(), pgUUID)
if err != nil {
slog.Error("Error in GetMsofficeInfo", "file-uuid", fileID, "error", err)
}
return data, err
data, err := query.GetYaraResults(context.Background(), pgUUID)
if err != nil {
slog.Error("Error in GetMsofficeInfo", "file-uuid", fileID, "error", err)
}
return data, err
}
func InsertYaraResults(params sqlc.InsertYaraResultsParams) error {
query := sqlc.New(pool)
slog.Debug("InsertYaraResults", "params", params)
_, err := query.InsertYaraResults(context.Background(), params)
if err != nil {
slog.Error("Error in InsertYaraResults", "file-uuid", params.FileID.String(), "error", err)
}
return err
query := sqlc.New(pool)
slog.Debug("InsertYaraResults", "params", params)
_, err := query.InsertYaraResults(context.Background(), params)
if err != nil {
slog.Error("Error in InsertYaraResults", "file-uuid", params.FileID.String(), "error", err)
}
return err
}

66
server/internal/processing/msoffice/msoffice.go
View file

@ -12,45 +12,45 @@ func MSOfficeProcessing(job sqlc.ProcessingJob) error {
database.FailProcessingJob(job.ID, err)
return err
}
olevbaResp, err := OleVBAScan(job.FileID)
olevbaResp, err := OleVBAScan(job.FileID)
if err != nil {
database.FailProcessingJob(job.ID, err)
return err
}
params := sqlc.InsertMSOfficeResultsParams{
FileID: job.FileID,
}
params.ContainerFormat.String = oleidResp.ContainerFormat
params.ContainerFormat.Valid = true
params.Encrypted.Bool = oleidResp.Encrypted
params.Encrypted.Valid = true
params.FileFormat.String = oleidResp.FileFormat
params.FileFormat.Valid = true
params.VbaMacros.String = oleidResp.VBAMacros
params.VbaMacros.Valid = true
params.XlmMacros.String = oleidResp.XLMMacros
params.XlmMacros.Valid = true
params.VbaStomping.Bool = olevbaResp.Stomping
params.VbaStomping.Valid = true
params.NbAutoexec.Int32 = int32(olevbaResp.NbAutoexec)
params.NbAutoexec.Valid = true
params.NbIocs.Int32 = int32(olevbaResp.NbIocs)
params.NbIocs.Valid = true
params.NbMacros.Int32 = int32(olevbaResp.NbMacros)
params.NbIocs.Valid = true
params.NbSuspicious.Int32 = int32(olevbaResp.NbSuspicious)
params.NbSuspicious.Valid = true
params := sqlc.InsertMSOfficeResultsParams{
FileID: job.FileID,
}
params.ContainerFormat.String = oleidResp.ContainerFormat
params.ContainerFormat.Valid = true
params.Encrypted.Bool = oleidResp.Encrypted
params.Encrypted.Valid = true
params.FileFormat.String = oleidResp.FileFormat
params.FileFormat.Valid = true
params.VbaMacros.String = oleidResp.VBAMacros
params.VbaMacros.Valid = true
params.XlmMacros.String = oleidResp.XLMMacros
params.XlmMacros.Valid = true
params.VbaStomping.Bool = olevbaResp.Stomping
params.VbaStomping.Valid = true
params.NbAutoexec.Int32 = int32(olevbaResp.NbAutoexec)
params.NbAutoexec.Valid = true
params.NbIocs.Int32 = int32(olevbaResp.NbIocs)
params.NbIocs.Valid = true
params.NbMacros.Int32 = int32(olevbaResp.NbMacros)
params.NbIocs.Valid = true
params.NbSuspicious.Int32 = int32(olevbaResp.NbSuspicious)
params.NbSuspicious.Valid = true
params.OlevbaResults = olevbaResp.Results
params.Macros = olevbaResp.Macros
if olevbaResp.NbSuspicious > 0 || olevbaResp.NbIocs > 0 || olevbaResp.NbAutoexec > 0 {
params.Verdict.String = "suspicious"
} else {
params.Verdict.String = "inconspicous"
}
params.Verdict.Valid = true
params.OlevbaResults = olevbaResp.Results
params.Macros = olevbaResp.Macros
if olevbaResp.NbSuspicious > 0 || olevbaResp.NbIocs > 0 || olevbaResp.NbAutoexec > 0 {
params.Verdict.String = "suspicious"
} else {
params.Verdict.String = "inconspicous"
}
params.Verdict.Valid = true
err = database.InsertMSOfficeResults(params)
err = database.InsertMSOfficeResults(params)
if err != nil {
database.FailProcessingJob(job.ID, err)
return err

18
server/internal/processing/msoffice/oleid.go
View file

@ -31,24 +31,24 @@ func OleIDScan(fileID pgtype.UUID) (oleidResponse, error) {
slog.Error("Error in OleIDScan parsing URL for ole service", "file-uuid", fileID.String(), "error", err)
}
oleidUrl.Path = "/oleid/analyze"
oleidUrl.RawQuery = fmt.Sprintf("file=%s", fileID.String())
oleidUrl.RawQuery = fmt.Sprintf("file=%s", fileID.String())
oleidResp, err := http.Get(oleidUrl.String())
slog.Debug("OleIDScan request", "file-uuid", fileID.String(), "url", oleidUrl.String(), "status-code", oleidResp.StatusCode)
if err != nil {
slog.Error("Error in OleIDScan getting oleid info from service", "file-uuid", fileID.String(), "error", err)
}
defer oleidResp.Body.Close()
body, err := io.ReadAll(oleidResp.Body)
defer oleidResp.Body.Close()
body, err := io.ReadAll(oleidResp.Body)
if err != nil {
slog.Error("Error in OleIDScan parsing oleid body", "file-uuid", fileID.String(), "error", err)
}
var jsonResponse oleidResponse
var jsonResponse oleidResponse
err = json.Unmarshal(body, &jsonResponse)
if err != nil {
slog.Error("Error in OleIDScan when trying to unmarshal response", "file-uuid", fileID.String(), "error", err)
return jsonResponse, err
}
err = json.Unmarshal(body, &jsonResponse)
if err != nil {
slog.Error("Error in OleIDScan when trying to unmarshal response", "file-uuid", fileID.String(), "error", err)
return jsonResponse, err
}
slog.Debug("OleIDScan", "file-uuid", fileID.String(), "data", body)
return jsonResponse, nil

45
server/internal/processing/msoffice/olevba.go
View file

@ -24,7 +24,6 @@ type olevbaResponse struct {
Stomping bool `json:"stomping"`
}
func OleVBAScan(fileID pgtype.UUID) (olevbaResponse, error) {
slog.Debug("Starting OLEvba scan", "file-uuid", fileID.String())
oleidUrl, err := url.Parse(viper.GetString("processing.oleurl"))
@ -32,40 +31,40 @@ func OleVBAScan(fileID pgtype.UUID) (olevbaResponse, error) {
slog.Error("Error in OleVBAScan parsing URL for ole service", "file-uuid", fileID.String(), "error", err)
}
oleidUrl.Path = "/olevba/analyze"
oleidUrl.RawQuery = fmt.Sprintf("file=%s", fileID.String())
oleidUrl.RawQuery = fmt.Sprintf("file=%s", fileID.String())
oleidResp, err := http.Get(oleidUrl.String())
slog.Debug("OleVBAScan request", "file-uuid", fileID.String(), "url", oleidUrl.String(), "status-code", oleidResp.StatusCode)
if err != nil {
slog.Error("Error in OleVBAScan getting olevba info from service", "file-uuid", fileID.String(), "error", err)
}
defer oleidResp.Body.Close()
body, err := io.ReadAll(oleidResp.Body)
defer oleidResp.Body.Close()
body, err := io.ReadAll(oleidResp.Body)
if err != nil {
slog.Error("Error in OleVBAScan parsing olevba body", "file-uuid", fileID.String(), "error", err)
}
var jsonResp olevbaResponse
var jsonResp olevbaResponse
err = json.Unmarshal(body, &jsonResp)
if err != nil {
slog.Error("Error in OleVBAScan when trying to unmarshal response", "file-uuid", fileID.String(), "error", err)
return jsonResp, err
}
err = json.Unmarshal(body, &jsonResp)
if err != nil {
slog.Error("Error in OleVBAScan when trying to unmarshal response", "file-uuid", fileID.String(), "error", err)
return jsonResp, err
}
for i, result := range jsonResp.Results {
if result[0] == "Hex String" {
var hexParts []string
for _, b := range []byte(result[1]) {
hexParts = append(hexParts, fmt.Sprintf("0x%X", b))
}
result[1] = strings.Join(hexParts, " ")
}
slog.Debug("OleVBAScan Result", "0", result[0], "1", result[1], "2", result[2], "i", i)
}
for i, result := range jsonResp.Results {
if result[0] == "Hex String" {
var hexParts []string
for _, b := range []byte(result[1]) {
hexParts = append(hexParts, fmt.Sprintf("0x%X", b))
}
result[1] = strings.Join(hexParts, " ")
}
slog.Debug("OleVBAScan Result", "0", result[0], "1", result[1], "2", result[2], "i", i)
}
for i, macro := range jsonResp.Macros {
slog.Debug("OleVBAScan Macro", "0", macro[0], "1", macro[1], "2", macro[2], "3", macro[3], "i", i)
}
for i, macro := range jsonResp.Macros {
slog.Debug("OleVBAScan Macro", "0", macro[0], "1", macro[1], "2", macro[2], "3", macro[3], "i", i)
}
slog.Debug("OleVBAScan", "file-uuid", fileID.String(), "data", jsonResp)
return jsonResp, nil

19
server/internal/processing/msoffice/olevba_test.go
View file

@ -10,17 +10,16 @@ import (
"github.com/spf13/viper"
)
func TestOleVba(t *testing.T) {
slog.SetDefault(slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelDebug})))
viper.Set("processing.oleurl", "http://localhost:5000")
var fileid pgtype.UUID
fileid.Scan("cf645d68-fc5b-4cba-8940-4ccce437e354")
t.Log(fileid)
resp, err := msoffice.OleVBAScan(fileid)
if err != nil {
t.FailNow()
}
t.Log(resp)
viper.Set("processing.oleurl", "http://localhost:5000")
var fileid pgtype.UUID
fileid.Scan("cf645d68-fc5b-4cba-8940-4ccce437e354")
t.Log(fileid)
resp, err := msoffice.OleVBAScan(fileid)
if err != nil {
t.FailNow()
}
t.Log(resp)
}

2
server/internal/processing/processing.go
View file

@ -18,7 +18,7 @@ var startup time.Time
func Setup(wg *sync.WaitGroup) {
startup = time.Now()
go yara.InitYara()
go yara.InitYara()
}
// Submit() starts the analysis process for a file.

24
server/internal/processing/yara/wrap.go
View file

@ -10,18 +10,18 @@ import (
)
func compileSourcesFromFiles() error {
root, err := filepath.Abs(viper.GetString("processing.yararules"))
if err != nil {
slog.Error("Error getting absolute path for processing.yararules", "error", err)
return err
}
root, err := filepath.Abs(viper.GetString("processing.yararules"))
if err != nil {
slog.Error("Error getting absolute path for processing.yararules", "error", err)
return err
}
outputPath, err := filepath.Abs(viper.GetString("processing.yaracompiled"))
if err != nil {
slog.Error("Error getting absolute path for processing.yaracompiled", "error", err)
return err
slog.Error("Error getting absolute path for processing.yaracompiled", "error", err)
return err
}
cmd := exec.Command("/usr/local/bin/yr", "compile","--path-as-namespace", "--relaxed-re-syntax", "--output", outputPath, root)
cmd := exec.Command("/usr/local/bin/yr", "compile", "--path-as-namespace", "--relaxed-re-syntax", "--output", outputPath, root)
slog.Debug("Yara compile command", "cmd", cmd.String())
result, err := cmd.Output()
if err != nil {
@ -30,7 +30,7 @@ func compileSourcesFromFiles() error {
} else {
slog.Info("Compiled yara rules", "result", string(result))
}
return nil
}
@ -38,15 +38,15 @@ func scanFile(fileName string) ([]string, error) {
var matched []string
outputPath, err := filepath.Abs(viper.GetString("processing.yaracompiled"))
if err != nil {
slog.Error("Error getting absolute path for processing.yaracompiled", "error", err)
return matched, err
slog.Error("Error getting absolute path for processing.yaracompiled", "error", err)
return matched, err
}
fullPath, err := store.AbsPath(fileName)
if err != nil {
slog.Error("Error in Yara Scan", "file-uuid", fileName, "error", err)
return matched, err
}
cmd := exec.Command("/usr/local/bin/yr", "scan", "--output-format ndjson", "--print-namespace","--compiled-rules", outputPath, fullPath)
cmd := exec.Command("/usr/local/bin/yr", "scan", "--output-format ndjson", "--print-namespace", "--compiled-rules", outputPath, fullPath)
slog.Debug("Yara scan command", "cmd", cmd.String())
result, err := cmd.Output()
if err != nil {

21
server/internal/processing/yara/yara.go
View file

@ -5,28 +5,27 @@ import (
"git.jmbit.de/jmb/scanfile/server/internal/sqlc"
)
func InitYara() error{
func InitYara() error {
return compileSourcesFromFiles()
}
func YaraProcessing(job sqlc.ProcessingJob) error {
database.StartProcessingJob(job.ID)
results, err := scanFile(job.FileID.String())
if err != nil {
database.FailProcessingJob(job.ID, err)
results, err := scanFile(job.FileID.String())
if err != nil {
database.FailProcessingJob(job.ID, err)
return err
}
}
params := sqlc.InsertYaraResultsParams{
FileID: job.FileID,
FileID: job.FileID,
Matched: results,
}
err = database.InsertYaraResults(params)
if err != nil {
database.FailProcessingJob(job.ID, err)
if err != nil {
database.FailProcessingJob(job.ID, err)
return err
}
}
return nil
return nil
}

2
server/internal/server/routes.go
View file

@ -12,7 +12,7 @@ func RegisterRoutes() *http.ServeMux {
// Web interface
mux.HandleFunc("/", web.IndexWebHandler)
mux.HandleFunc("/about", web.AboutWebHandler)
mux.HandleFunc("/admin", web.AdminWebHandler)
mux.HandleFunc("/admin", web.AdminWebHandler)
mux.HandleFunc("/files/{uuid}", web.FileViewWebHandler)
mux.HandleFunc("/files/{uuid}/msoffice", web.FileViewMSOWebHandler)
mux.HandleFunc("/files/{uuid}/download", web.FileViewDownloadWebHandler)

15
server/internal/store/filetype.go
View file

@ -10,28 +10,27 @@ import (
// Returns the MIME type of a file
func GetFileType(fileId string) (string, error) {
start := time.Now()
start := time.Now()
path, err := AbsPath(fileId)
if err != nil {
return "application/octet-stream", nil
}
mimetype.SetLimit(uint32(viper.GetSizeInBytes("processing.maxmimesize")))
mimetype.SetLimit(uint32(viper.GetSizeInBytes("processing.maxmimesize")))
mtype, err := mimetype.DetectFile(path)
if err != nil {
slog.Error("Storage not accessible", "error", err, "file-uuid", fileId, "mimetype", mtype.String())
return "application/octet-stream", err
}
slog.Debug("store.GetFileType", "file-uuid", fileId, "mimetype", mtype.String(), "extension", mtype.Extension(), "duration", time.Now().Sub(start).String())
return mtype.String(), nil
slog.Debug("store.GetFileType", "file-uuid", fileId, "mimetype", mtype.String(), "extension", mtype.Extension(), "duration", time.Now().Sub(start).String())
return mtype.String(), nil
}
// Returns the MimeType for a []byte
// Only pass the necessary data!
func GetBytesFileType(data []byte) (string) {
mimetype.SetLimit(uint32(viper.GetSizeInBytes("processing.maxmimesize")))
mtype := mimetype.Detect(data)
func GetBytesFileType(data []byte) string {
mimetype.SetLimit(uint32(viper.GetSizeInBytes("processing.maxmimesize")))
mtype := mimetype.Detect(data)
slog.Debug("GetBytesFileType", "file-mime", mtype.String())
return mtype.String()
}

77
server/internal/store/filetype_test.go
View file

@ -9,54 +9,53 @@ import (
)
type testFile struct {
Name string
MimeType string
Name string
MimeType string
}
var testFiles = []testFile{
{
Name: "zip.zip",
MimeType: "application/zip",
},
{
Name: "zip.7z",
MimeType: "application/x-7z-compressed",
},
{
Name: "test.txt",
MimeType: "text/plain; charset=utf-8",
},
{
Name: "macro-example.xlsm",
MimeType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
},
{
Name: "zip.zip",
MimeType: "application/zip",
},
{
Name: "zip.7z",
MimeType: "application/x-7z-compressed",
},
{
Name: "test.txt",
MimeType: "text/plain; charset=utf-8",
},
{
Name: "macro-example.xlsm",
MimeType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
},
}
func setconf() error {
absPath, err := filepath.Abs("../../../tests/files")
if err != nil {
return err
}
viper.Set("store.path", absPath)
return nil
absPath, err := filepath.Abs("../../../tests/files")
if err != nil {
return err
}
viper.Set("store.path", absPath)
return nil
}
func TestFileType(t *testing.T) {
err := setconf()
if err != nil {
t.Fatal(err)
}
err := setconf()
if err != nil {
t.Fatal(err)
}
for i, file := range testFiles {
mimeType, err := store.GetFileType(file.Name)
if err != nil {
t.Error(err)
}
t.Logf("[%d/%d] File %s Expected: %s, Result: %s", i+1, len(testFiles), file.Name, file.MimeType, mimeType)
if mimeType != file.MimeType {
t.Fail()
}
}
for i, file := range testFiles {
mimeType, err := store.GetFileType(file.Name)
if err != nil {
t.Error(err)
}
t.Logf("[%d/%d] File %s Expected: %s, Result: %s", i+1, len(testFiles), file.Name, file.MimeType, mimeType)
if mimeType != file.MimeType {
t.Fail()
}
}
}

2
server/internal/store/store.go
View file

@ -39,7 +39,7 @@ func SaveFile(fileName string, fileBytes []byte) (string, error) {
if err != nil {
slog.Error("could not write file content,", "error", err, "file-uuid", fileName)
return "", err
}
}
slog.Debug("File successfully written to disk", "size", i, "file-uuid", fileName)
return fileName, nil

6
server/web/admin.go
View file

@ -7,10 +7,8 @@ import (
"git.jmbit.de/jmb/scanfile/server/internal/database"
)
func AdminWebHandler(w http.ResponseWriter, r *http.Request) {
jobs, err := database.ALlProcessingJobs()
jobs, err := database.ALlProcessingJobs()
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
@ -23,5 +21,3 @@ func AdminWebHandler(w http.ResponseWriter, r *http.Request) {
return
}
}

32
server/web/fileView.go
View file

@ -13,13 +13,13 @@ func FileViewWebHandler(w http.ResponseWriter, r *http.Request) {
if err != nil {
slog.Error("Error getting File in FileViewWebHandler", "error", err, "file-uuid", r.PathValue("uuid"))
if err.Error() == "no rows in result set" {
http.Error(w, err.Error(), http.StatusNotFound)
http.Error(w, err.Error(), http.StatusNotFound)
} else {
http.Error(w, err.Error(), http.StatusBadRequest)
http.Error(w, err.Error(), http.StatusBadRequest)
}
return
}
fileProperties, err := database.GetFileProperties(file.ID)
fileProperties, err := database.GetFileProperties(file.ID)
if err != nil {
slog.Error("Error getting FileProperties in FileViewWebHandler", "error", err, "file-uuid", r.PathValue("uuid"))
http.Error(w, err.Error(), http.StatusInternalServerError)
@ -35,14 +35,14 @@ func FileViewWebHandler(w http.ResponseWriter, r *http.Request) {
}
func FileViewMSOWebHandler(w http.ResponseWriter, r *http.Request) {
data, err := database.GetMSOfficeResults(r.PathValue("uuid"))
data, err := database.GetMSOfficeResults(r.PathValue("uuid"))
if err != nil {
slog.Error("Error getting Data in FileViewMSOWebHandler", "error", err, "file-uuid", r.PathValue("uuid"))
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
component := FileViewMsoffice(data)
err = component.Render(r.Context(), w)
component := FileViewMsoffice(data)
err = component.Render(r.Context(), w)
if err != nil {
slog.Error("Error rendering in FileViewMSOWebHandler", "error", err)
http.Error(w, err.Error(), http.StatusBadRequest)
@ -51,19 +51,19 @@ func FileViewMSOWebHandler(w http.ResponseWriter, r *http.Request) {
}
func FileViewDeleteWebHandler(w http.ResponseWriter, r *http.Request) {
fileID := r.PathValue("uuid")
fileID := r.PathValue("uuid")
err := database.DeleteFileByID(fileID)
if err != nil {
slog.Error("Error deleting File in FileViewDeleteHandler", "error", err, "file-uuid", fileID)
if err != nil {
slog.Error("Error deleting File in FileViewDeleteHandler", "error", err, "file-uuid", fileID)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
err = store.DeleteFile(fileID)
if err != nil {
slog.Error("Error deleting File in FileViewDeleteHandler", "error", err, "file-uuid", fileID)
}
err = store.DeleteFile(fileID)
if err != nil {
slog.Error("Error deleting File in FileViewDeleteHandler", "error", err, "file-uuid", fileID)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
}
w.Header().Set("HX-Redirect", "/")
}
@ -82,7 +82,7 @@ func FileViewDownloadWebHandler(w http.ResponseWriter, r *http.Request) {
return
}
w.Header().Set("Content-Disposition", "attachment; filename="+file.Name)
w.Header().Set("Content-Type", file.Mimetype)
w.Header().Set("Content-Disposition", "attachment; filename="+file.Name)
w.Header().Set("Content-Type", file.Mimetype)
http.ServeFile(w, r, filePath)
}