414 lines
12 KiB
Go
414 lines
12 KiB
Go
package cli
|
|
|
|
import (
|
|
"bufio"
|
|
"fmt"
|
|
"os"
|
|
"strconv"
|
|
"strings"
|
|
"gitea.armuli.eu/museum-digital/museum-digital-webdav-uploader/src/configloader"
|
|
"gitea.armuli.eu/museum-digital/museum-digital-webdav-uploader/src/uploadsrcdir"
|
|
"gitea.armuli.eu/museum-digital/museum-digital-webdav-uploader/src/webdavupload"
|
|
)
|
|
|
|
// Interal wrapper around opening a new bufio.Reader and getting an input
|
|
// from it. As errors here likely really are something fundamentally wrong
|
|
// about the system, panic if there is one.
|
|
func getConsoleInput() string {
|
|
|
|
reader := bufio.NewReader(os.Stdin)
|
|
output, err := reader.ReadString('\n')
|
|
|
|
if err != nil {
|
|
fmt.Println("Failed to get console input!")
|
|
panic(err)
|
|
}
|
|
|
|
return strings.Trim(output, "\n\r")
|
|
|
|
}
|
|
|
|
// Prompts the user to enter a valid instance url until they do.
|
|
func requestInstanceLink() string {
|
|
|
|
fmt.Println("\nPlease enter URL of the instance of museum-digital you work in.")
|
|
fmt.Println("This should be a regional instance (e.g. hessen.museum-digital.de), not an aggregated one like nat.museum-digital.de.")
|
|
|
|
input := getConsoleInput()
|
|
|
|
output, validationErr := configloader.ValidateInstanceLink(input)
|
|
if validationErr != nil {
|
|
fmt.Println("This is not a valid instance of museum-digital / musdb. Please try again.")
|
|
fmt.Print("----\nThe specific error is:\n")
|
|
fmt.Println(validationErr)
|
|
fmt.Print("----\n\n")
|
|
return requestInstanceLink()
|
|
}
|
|
|
|
return output
|
|
|
|
}
|
|
|
|
// Prompts the user to enter a valid institution ID within the
|
|
// specified instance until they do.
|
|
func requestInstitutionId(instanceLink string) int {
|
|
|
|
fmt.Println("\nPlease enter ID of your institution.")
|
|
fmt.Println("You can find the ID of the institution ID in musdb. On the institution/museum editing page, you will find it as a large number below the orange bar \"museum\".")
|
|
|
|
input := getConsoleInput()
|
|
i, err := strconv.Atoi(input)
|
|
if err != nil {
|
|
fmt.Println("You did not enter a number. Please try again.")
|
|
return requestInstitutionId(instanceLink)
|
|
}
|
|
|
|
output, validationErr := configloader.ValidateInstitutionId(i, instanceLink)
|
|
if validationErr != nil {
|
|
fmt.Println("This is not a valid institution ID. Please try again.")
|
|
fmt.Print("----\nThe specific error is:\n")
|
|
fmt.Println(validationErr)
|
|
fmt.Print("----\n\n")
|
|
return requestInstitutionId(instanceLink)
|
|
}
|
|
|
|
return output
|
|
|
|
}
|
|
|
|
// Prompts the user to enter their username.
|
|
func requestUsername() string {
|
|
|
|
fmt.Println("\nPlease enter your user name in musdb (the name you use to log in with).")
|
|
|
|
input := getConsoleInput()
|
|
|
|
if input == "" {
|
|
fmt.Println("You may not enter an empty user name. Please try again.")
|
|
return requestUsername()
|
|
}
|
|
|
|
return input
|
|
|
|
}
|
|
|
|
// Prompts the user to enter a valid mail address until they do.
|
|
func requestMail() string {
|
|
|
|
fmt.Println("\nPlease enter the email you set for your musdb account.")
|
|
fmt.Println("Note that the spelling needs to be exactly the same as it is entered in musdb (e.g. in terms of capitalization).")
|
|
|
|
input := getConsoleInput()
|
|
|
|
output, validationErr := configloader.ValidateMail(input)
|
|
if validationErr != nil {
|
|
fmt.Println("This is not a valid mail address. Please try again.")
|
|
fmt.Print("----\nThe specific error is:\n")
|
|
fmt.Println(validationErr)
|
|
fmt.Print("----\n\n")
|
|
return requestMail()
|
|
}
|
|
|
|
return output
|
|
|
|
}
|
|
|
|
// Prompts the user to enter the webdav auth token.
|
|
func requestWebDavAuthToken() string {
|
|
|
|
fmt.Println("\nPlease enter your WebDAV authentication token.")
|
|
fmt.Println("You can generate a WebDAV authentication token on your account settings page in the tab \"WebDAV\".")
|
|
|
|
input := getConsoleInput()
|
|
|
|
if input == "" {
|
|
fmt.Println("You may not enter an empty WebDAV authentication token. Please try again.")
|
|
return requestWebDavAuthToken()
|
|
}
|
|
|
|
return input
|
|
|
|
}
|
|
|
|
// Prompts the user to enter a valid parser name until they do.
|
|
func requestParser() string {
|
|
|
|
fmt.Println("\nPlease enter the parser with which you want to run imports.")
|
|
fmt.Println("Parsers correspond with the input format. Available parsers are:")
|
|
|
|
fmt.Println("")
|
|
for _, parser := range(configloader.ListParsers()) {
|
|
fmt.Println("- " + parser.Title)
|
|
}
|
|
fmt.Println("")
|
|
|
|
input := getConsoleInput()
|
|
|
|
output, validationErr := configloader.ValidateParser(input)
|
|
if validationErr != nil {
|
|
fmt.Println("This is not a valid parser name. Please enter one from the list. Please try again.")
|
|
fmt.Print("----\nThe specific error is:\n")
|
|
fmt.Println(validationErr)
|
|
fmt.Print("----\n\n")
|
|
return requestParser()
|
|
}
|
|
|
|
return output
|
|
|
|
}
|
|
|
|
// Prompts the user to enter a valid folder for uploads.
|
|
func requestUploadFolder() string {
|
|
|
|
fmt.Println("\nPlease enter the full filepath of a directory in which the program should look for files to upload.")
|
|
fmt.Println("Note that the folder needs to exist.")
|
|
|
|
input := getConsoleInput()
|
|
|
|
output, validationErr := configloader.ValidateUploadDir(input)
|
|
if validationErr != nil {
|
|
fmt.Println("This is not a valid metadata folder. Please try again.")
|
|
fmt.Print("----\nThe specific error is:\n")
|
|
fmt.Println(validationErr)
|
|
fmt.Print("----\n\n")
|
|
return requestUploadFolder()
|
|
}
|
|
|
|
return output
|
|
|
|
}
|
|
|
|
// Prompts the user to say, whether they want to immediately publish the uploaded objects once imported.
|
|
func requestPublishOnImport() bool {
|
|
|
|
fmt.Println("\nDo you want to immediately publish your objects, once they have been imported? If so, enter 'y', else, enter 'n'")
|
|
|
|
input := getConsoleInput()
|
|
|
|
if input == "y" {
|
|
return true
|
|
} else if input == "n" {
|
|
return false
|
|
} else {
|
|
fmt.Println("You did not enter either y or n, please try again.")
|
|
return requestPublishOnImport()
|
|
}
|
|
|
|
}
|
|
|
|
// Wrapper around configloader.StoreConfigToFile that prints the error message
|
|
// if storing failed.
|
|
func storeConfigToFile(config configloader.MDWebDavUploaderConfig) {
|
|
|
|
err := configloader.StoreConfigToFile(config, "")
|
|
if err != nil {
|
|
fmt.Println("\nFailed to store config")
|
|
fmt.Println("Reason:")
|
|
fmt.Println(err)
|
|
panic("")
|
|
}
|
|
|
|
}
|
|
|
|
// Queries the user for each of the relevant values for setup.
|
|
func RunManualSetup() {
|
|
|
|
fmt.Println("Welcome to the setup of the museum-digital auto uploader")
|
|
fmt.Println("This is the fully manual version of the setup, hence you will be asked for each value")
|
|
|
|
config := configloader.MDWebDavUploaderConfig{}
|
|
|
|
config.InstanceLink = requestInstanceLink()
|
|
config.Username = requestUsername()
|
|
config.InstitutionId = requestInstitutionId(config.InstanceLink)
|
|
config.Mail = requestMail()
|
|
config.WebDavAuthToken = requestWebDavAuthToken()
|
|
config.Parser = requestParser()
|
|
config.UploadDir = requestUploadFolder()
|
|
config.PublishOnImport = requestPublishOnImport()
|
|
|
|
storeConfigToFile(config)
|
|
|
|
fmt.Println("Great! Your configuration has been stored. If you need to set further parser-specific settings, use --set-additional-setting. Else, use --upload.")
|
|
|
|
}
|
|
|
|
// Wrapper around configloader.LoadFromFile() that prints errors.
|
|
func loadConfigFromFile() configloader.MDWebDavUploaderConfig {
|
|
|
|
config, requiresSetup, err := configloader.LoadFromFile("")
|
|
|
|
// Re-run manual setup and then load anew.
|
|
if requiresSetup == true {
|
|
|
|
fmt.Println("Your config is incomplete. Please run the setup command before proceeding.")
|
|
RunManualSetup()
|
|
config, _, rerunerr := configloader.LoadFromFile("")
|
|
if rerunerr != nil {
|
|
fmt.Println("Another error occured in loading your configuration:")
|
|
fmt.Println(rerunerr)
|
|
panic("")
|
|
}
|
|
return config
|
|
|
|
} else if err != nil {
|
|
fmt.Println("Another error occured in loading your configuration:")
|
|
fmt.Println(err)
|
|
panic("")
|
|
}
|
|
|
|
return config
|
|
|
|
}
|
|
|
|
// Prints the current configuration.
|
|
func ShowCurrentConfig() {
|
|
|
|
config := loadConfigFromFile()
|
|
fmt.Println(config)
|
|
|
|
}
|
|
|
|
func SetAdditionalSetting() {
|
|
|
|
config := loadConfigFromFile()
|
|
|
|
// Welcome msg
|
|
fmt.Println("You are trying to set an additional setting. For this, you will need to enter 1) which setting you want to manipulate and 2) what you want to set it to.")
|
|
fmt.Println("-----\n")
|
|
|
|
// Print parser-specific settings
|
|
fmt.Println("Your currently configured parser is: " + config.Parser)
|
|
fmt.Println("You can learn more about the available settings for this parser in the parser documentation. Printing it now.")
|
|
|
|
for _, p := range(configloader.ListParsers()) {
|
|
if p.Title == config.Parser {
|
|
fmt.Println(p.Comment)
|
|
}
|
|
}
|
|
|
|
fmt.Println("\n-----\n")
|
|
|
|
// Get values
|
|
fmt.Println("Now, please enter which setting you would like to manipulate.")
|
|
settingKey := getConsoleInput()
|
|
|
|
fmt.Println("What would you like to set the setting to?")
|
|
settingValue := getConsoleInput()
|
|
|
|
if config.Settings == nil {
|
|
config.Settings = make(map[string]string)
|
|
}
|
|
config.Settings[settingKey] = settingValue
|
|
|
|
storeConfigToFile(config)
|
|
|
|
}
|
|
|
|
// Receives a list of files and an error. If the error exists, that is printed.
|
|
// Otherwise, the listed files of a directory are listed.
|
|
func printFolderContents(files []os.FileInfo, err error) {
|
|
|
|
if err != nil {
|
|
fmt.Println("Failed to list top level folder contents")
|
|
return
|
|
}
|
|
|
|
if len(files) == 0 {
|
|
fmt.Print("There are no files to print here.\n")
|
|
}
|
|
|
|
for _, f := range(files) {
|
|
fmt.Println(f.Name())
|
|
}
|
|
|
|
}
|
|
|
|
// Prints the top level folder contents of the WebDAV remote
|
|
func ListRemoteToplevel() {
|
|
|
|
config := loadConfigFromFile()
|
|
files, err := webdavupload.ListTopLevelContents(config)
|
|
printFolderContents(files, err)
|
|
|
|
}
|
|
|
|
// Prints the current contents of the remote metadata directory.
|
|
func ListRemoteMetadataDir() {
|
|
|
|
config := loadConfigFromFile()
|
|
files, err := webdavupload.ListMetadataDir(config)
|
|
printFolderContents(files, err)
|
|
|
|
}
|
|
|
|
// Prints the current contents of the remote media directory.
|
|
func ListRemoteMediaDir() {
|
|
|
|
config := loadConfigFromFile()
|
|
files, err := webdavupload.ListMediaDir(config)
|
|
printFolderContents(files, err)
|
|
|
|
}
|
|
|
|
// Prints the current contents of the local metadata directory.
|
|
func ListLocalMetadata() {
|
|
|
|
fmt.Println("Printing uploadable metadata files")
|
|
config := loadConfigFromFile()
|
|
files := uploadsrcdir.ListUploadableMetadata(config)
|
|
printFolderContents(files, nil)
|
|
|
|
}
|
|
|
|
// Prints the current contents of the local media directory.
|
|
func ListLocalMedia() {
|
|
|
|
fmt.Println("Printing uploadable media files")
|
|
config := loadConfigFromFile()
|
|
files := uploadsrcdir.ListUploadableMedia(config)
|
|
printFolderContents(files, nil)
|
|
|
|
}
|
|
|
|
// Integration: Uploads, if there is uploadable data and no import currently
|
|
// scheduled.
|
|
func HandleUpload() {
|
|
|
|
config := loadConfigFromFile()
|
|
uploadableMetadata, uploadableMedia := uploadsrcdir.GetUploadableFiles(config)
|
|
|
|
// If there are no files to upload, do nothing
|
|
if len(uploadableMetadata) == 0 && len(uploadableMedia) == 0 {
|
|
fmt.Println("No uploadable files identified.")
|
|
return
|
|
}
|
|
|
|
// TODO: Check, that the import files are not too new
|
|
|
|
// Open WebDAV client
|
|
c := webdavupload.GetWebdavClient(config)
|
|
|
|
// Check that the remote is not currently occupied.
|
|
if webdavupload.CheckRemoteIsFree(c) == false {
|
|
fmt.Println("The remote is currently occupied (very recent files, or an import config is currently waiting to be processed, are present).")
|
|
return
|
|
}
|
|
|
|
// Upload the files
|
|
if len(uploadableMetadata) > 0 {
|
|
webdavupload.UploadMetadataFiles(c, os.Stdout, uploadableMetadata)
|
|
webdavupload.BatchUnlink(os.Stdout, uploadableMetadata)
|
|
}
|
|
if len(uploadableMedia) > 0 {
|
|
webdavupload.UploadMediaFiles(c, os.Stdout, uploadableMedia)
|
|
webdavupload.BatchUnlink(os.Stdout, uploadableMedia)
|
|
}
|
|
|
|
// Generate the import config.
|
|
fmt.Println("Generating and uploading import configuration")
|
|
webdavupload.SetImportConfigToTheRemote(c, config)
|
|
fmt.Println("DONE")
|
|
|
|
}
|