2024-01-04 13:08:32 -07:00
|
|
|
package packagemanager
|
2024-01-04 09:49:03 -07:00
|
|
|
|
|
|
|
// This package is responsible for searching various sources for the availability of the requested package
|
|
|
|
|
|
|
|
import (
|
|
|
|
"encoding/json"
|
2024-01-04 11:04:38 -07:00
|
|
|
"io/ioutil"
|
2024-01-04 09:49:03 -07:00
|
|
|
"fmt"
|
2024-01-04 11:04:38 -07:00
|
|
|
"os/user"
|
|
|
|
"os/exec"
|
|
|
|
"path/filepath"
|
|
|
|
"strings"
|
|
|
|
"net/http"
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
"pixelridgesoftworks.com/AllPac/pkg/logger"
|
2024-01-04 09:49:03 -07:00
|
|
|
)
|
|
|
|
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
// uninstalls the provided packages
|
2024-01-04 11:04:38 -07:00
|
|
|
func UninstallPackages(packageNames []string) error {
|
|
|
|
pkgList, err := readPackageList()
|
|
|
|
if err != nil {
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
logger.Errorf("An error has occured:", err)
|
2024-01-04 11:04:38 -07:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, packageName := range packageNames {
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
pkgInfo, exists := pkgList[packageName]
|
2024-01-04 11:04:38 -07:00
|
|
|
if !exists {
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
logger.Warnf("Package %s not found in installed packages list\n", packageNames)
|
2024-01-04 11:04:38 -07:00
|
|
|
fmt.Printf("Package %s not found in installed packages list\n", packageName)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
switch pkgInfo.Source {
|
2024-01-04 11:04:38 -07:00
|
|
|
case "pacman":
|
2024-01-04 13:08:32 -07:00
|
|
|
err = UninstallPacmanPackage(packageName)
|
2024-01-04 11:04:38 -07:00
|
|
|
case "snap":
|
2024-01-04 13:08:32 -07:00
|
|
|
err = UninstallSnapPackage(packageName)
|
2024-01-04 11:04:38 -07:00
|
|
|
case "flatpak":
|
2024-01-04 13:08:32 -07:00
|
|
|
err = UninstallFlatpakPackage(packageName)
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
case "aur":
|
|
|
|
err = UninstallAURPackage(packageName)
|
2024-01-04 11:04:38 -07:00
|
|
|
default:
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
logger.Warnf("Unknown source for package %s\n", packageNames)
|
2024-01-04 11:04:38 -07:00
|
|
|
fmt.Printf("Unknown source for package %s\n", packageName)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
if err != nil {
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
logger.Warnf("Error uninstalling package %s: %v\n", packageName, err)
|
2024-01-04 11:04:38 -07:00
|
|
|
fmt.Printf("Error uninstalling package %s: %v\n", packageName, err)
|
|
|
|
} else {
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
logger.Infof("Successfully uninstalled package %s\n", packageName)
|
2024-01-04 11:04:38 -07:00
|
|
|
fmt.Printf("Successfully uninstalled package %s\n", packageName)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
// reads the package list from the pkg.list file
|
2024-01-04 11:04:38 -07:00
|
|
|
func readPackageList() (PackageList, error) {
|
|
|
|
usr, err := user.Current()
|
|
|
|
if err != nil {
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
logger.Errorf("error getting current user: %v", err)
|
2024-01-04 11:04:38 -07:00
|
|
|
return nil, fmt.Errorf("error getting current user: %v", err)
|
|
|
|
}
|
|
|
|
pkgListPath := filepath.Join(usr.HomeDir, ".allpac", "pkg.list")
|
|
|
|
|
|
|
|
file, err := ioutil.ReadFile(pkgListPath)
|
|
|
|
if err != nil {
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
logger.Errorf("error reading package list file: %v", err)
|
2024-01-04 11:04:38 -07:00
|
|
|
return nil, fmt.Errorf("error reading package list file: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
var pkgList PackageList
|
|
|
|
err = json.Unmarshal(file, &pkgList)
|
|
|
|
if err != nil {
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
logger.Errorf("error decoding package list: %v", err)
|
2024-01-04 11:04:38 -07:00
|
|
|
return nil, fmt.Errorf("error decoding package list: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
return pkgList, nil
|
|
|
|
}
|
|
|
|
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
// represents the structure of the response from AUR RPC
|
2024-01-04 09:49:03 -07:00
|
|
|
type AURResponse struct {
|
|
|
|
Version int `json:"version"`
|
|
|
|
Type string `json:"type"`
|
|
|
|
ResultCount int `json:"resultcount"`
|
|
|
|
Results []AURPackage `json:"results"`
|
|
|
|
}
|
|
|
|
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
// represents a package in the AUR
|
2024-01-04 09:49:03 -07:00
|
|
|
type AURPackage struct {
|
|
|
|
ID int `json:"ID"`
|
|
|
|
Name string `json:"Name"`
|
|
|
|
Version string `json:"Version"`
|
|
|
|
Description string `json:"Description"`
|
|
|
|
URL string `json:"URL"`
|
|
|
|
// Add other fields as needed
|
|
|
|
}
|
|
|
|
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
// searches for a package in the Pacman repositories
|
2024-01-04 09:49:03 -07:00
|
|
|
func SearchPacman(packageName string) ([]string, error) {
|
|
|
|
cmd := exec.Command("pacman", "-Ss", packageName)
|
|
|
|
output, err := cmd.CombinedOutput()
|
2024-01-04 20:12:26 -07:00
|
|
|
|
|
|
|
// Check if the error is due to no results found
|
|
|
|
if err != nil && len(output) == 0 {
|
|
|
|
return nil, nil // No results is not an error in this context
|
|
|
|
} else if err != nil {
|
|
|
|
// Other errors are still treated as errors
|
|
|
|
logger.Errorf("Error searching Pacman: %v", err)
|
2024-01-04 09:49:03 -07:00
|
|
|
return nil, fmt.Errorf("error searching Pacman: %v", err)
|
|
|
|
}
|
2024-01-04 20:12:26 -07:00
|
|
|
|
2024-01-04 09:49:03 -07:00
|
|
|
return parsePacmanOutput(string(output)), nil
|
|
|
|
}
|
|
|
|
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
// searches for a package in the Snap store
|
2024-01-04 09:49:03 -07:00
|
|
|
func SearchSnap(packageName string) ([]string, error) {
|
|
|
|
cmd := exec.Command("snap", "find", packageName)
|
|
|
|
output, err := cmd.CombinedOutput()
|
|
|
|
if err != nil {
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
logger.Errorf("error searching Snap: %v", err)
|
2024-01-04 09:49:03 -07:00
|
|
|
return nil, fmt.Errorf("error searching Snap: %v", err)
|
|
|
|
}
|
|
|
|
return strings.Split(string(output), "\n"), nil
|
|
|
|
}
|
|
|
|
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
// searches for a package in Flatpak repositories
|
2024-01-04 09:49:03 -07:00
|
|
|
func SearchFlatpak(packageName string) ([]string, error) {
|
|
|
|
cmd := exec.Command("flatpak", "search", packageName)
|
|
|
|
output, err := cmd.CombinedOutput()
|
|
|
|
if err != nil {
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
logger.Errorf("error searching Flatpak: %v", err)
|
2024-01-04 09:49:03 -07:00
|
|
|
return nil, fmt.Errorf("error searching Flatpak: %v", err)
|
|
|
|
}
|
|
|
|
return strings.Split(string(output), "\n"), nil
|
|
|
|
}
|
|
|
|
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
// searches the AUR for the given term
|
2024-01-04 09:49:03 -07:00
|
|
|
func SearchAUR(searchTerm string) ([]AURPackage, error) {
|
|
|
|
url := fmt.Sprintf("https://aur.archlinux.org/rpc/?v=5&type=search&arg=%s", searchTerm)
|
|
|
|
resp, err := http.Get(url)
|
|
|
|
if err != nil {
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
logger.Errorf("error making request to AUR: %v", err)
|
2024-01-04 09:49:03 -07:00
|
|
|
return nil, fmt.Errorf("error making request to AUR: %v", err)
|
|
|
|
}
|
|
|
|
defer resp.Body.Close()
|
|
|
|
|
|
|
|
var aurResponse AURResponse
|
|
|
|
if err := json.NewDecoder(resp.Body).Decode(&aurResponse); err != nil {
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
logger.Errorf("error decoding AUR response: %v", err)
|
2024-01-04 09:49:03 -07:00
|
|
|
return nil, fmt.Errorf("error decoding AUR response: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
return aurResponse.Results, nil
|
|
|
|
}
|
|
|
|
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
// parses the output from Pacman search command
|
2024-01-04 09:49:03 -07:00
|
|
|
func parsePacmanOutput(output string) []string {
|
|
|
|
sections := strings.Split(output, "\n\n")
|
|
|
|
|
|
|
|
var packages []string
|
|
|
|
for _, section := range sections {
|
|
|
|
lines := strings.Split(section, "\n")
|
|
|
|
|
|
|
|
// The first line should contain the package name and version
|
|
|
|
if len(lines) > 0 {
|
|
|
|
packageNameLine := lines[0]
|
|
|
|
|
|
|
|
// Check if the package is installed
|
|
|
|
if strings.Contains(packageNameLine, "[installed]") {
|
|
|
|
packageNameLine += " (Installed)"
|
|
|
|
}
|
|
|
|
|
|
|
|
packages = append(packages, packageNameLine)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return packages
|
|
|
|
}
|
2024-01-04 13:08:32 -07:00
|
|
|
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
// returns the version of a package in the Pacman repositories
|
2024-01-04 13:08:32 -07:00
|
|
|
func GetPacmanPackageVersion(packageName string) (string, error) {
|
|
|
|
searchResults, err := SearchPacman(packageName)
|
|
|
|
if err != nil {
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
logger.Errorf("An error has occured:", err)
|
2024-01-04 13:08:32 -07:00
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, result := range searchResults {
|
|
|
|
if strings.Contains(result, packageName) {
|
|
|
|
return extractVersionFromPacmanResult(result), nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
logger.Errorf("package %s not found in Pacman", packageName)
|
2024-01-04 13:08:32 -07:00
|
|
|
return "", fmt.Errorf("package %s not found in Pacman", packageName)
|
|
|
|
}
|
|
|
|
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
// extracts the version from a Pacman search result string
|
2024-01-04 13:08:32 -07:00
|
|
|
func extractVersionFromPacmanResult(result string) string {
|
|
|
|
// Assuming the result is in the format "packageName version description"
|
|
|
|
parts := strings.Fields(result)
|
|
|
|
if len(parts) >= 2 {
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
return parts[1]
|
2024-01-04 13:08:32 -07:00
|
|
|
}
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
// fetches package information from the AUR
|
2024-01-04 13:08:32 -07:00
|
|
|
func fetchAURPackageInfo(packageName string) (*AURPackageInfo, error) {
|
|
|
|
url := fmt.Sprintf("https://aur.archlinux.org/rpc/?v=5&type=info&arg[]=%s", packageName)
|
|
|
|
resp, err := http.Get(url)
|
|
|
|
if err != nil {
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
logger.Errorf("An error has occured:", err)
|
2024-01-04 13:08:32 -07:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
defer resp.Body.Close()
|
|
|
|
|
|
|
|
var result struct {
|
|
|
|
Results []AURPackageInfo `json:"results"`
|
|
|
|
}
|
|
|
|
if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
logger.Errorf("An error has occured:", err)
|
2024-01-04 13:08:32 -07:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(result.Results) == 0 {
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
logger.Errorf("package %s not found in AUR", packageName)
|
2024-01-04 13:08:32 -07:00
|
|
|
return nil, fmt.Errorf("package %s not found in AUR", packageName)
|
|
|
|
}
|
|
|
|
|
|
|
|
return &result.Results[0], nil
|
|
|
|
}
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
|
|
|
|
// returns the version of a package in the Snap store
|
|
|
|
func GetSnapPackageVersion(packageName string) (string, error) {
|
|
|
|
cmd := exec.Command("snap", "info", packageName)
|
|
|
|
output, err := cmd.CombinedOutput()
|
|
|
|
if err != nil {
|
|
|
|
logger.Errorf("error getting Snap package info: %v", err)
|
|
|
|
return "", fmt.Errorf("error getting Snap package info: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
return parseSnapInfoOutput(string(output)), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// parses the output from the Snap info command to extract the version
|
|
|
|
func parseSnapInfoOutput(output string) string {
|
|
|
|
lines := strings.Split(output, "\n")
|
|
|
|
for _, line := range lines {
|
|
|
|
if strings.HasPrefix(line, "installed:") {
|
|
|
|
parts := strings.Fields(line)
|
|
|
|
if len(parts) >= 2 {
|
|
|
|
return strings.TrimSpace(parts[1])
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
// returns the version of a package in Flatpak repositories
|
|
|
|
func GetFlatpakPackageVersion(packageName string) (string, error) {
|
|
|
|
cmd := exec.Command("flatpak", "info", packageName)
|
|
|
|
output, err := cmd.CombinedOutput()
|
|
|
|
if err != nil {
|
|
|
|
logger.Errorf("error getting Flatpak package info: %v", err)
|
|
|
|
return "", fmt.Errorf("error getting Flatpak package info: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
return parseFlatpakInfoOutput(string(output)), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// parses the output from the Flatpak info command to extract the version
|
|
|
|
func parseFlatpakInfoOutput(output string) string {
|
|
|
|
lines := strings.Split(output, "\n")
|
|
|
|
for _, line := range lines {
|
|
|
|
if strings.HasPrefix(line, "Version:") {
|
|
|
|
parts := strings.Fields(line)
|
|
|
|
if len(parts) >= 2 {
|
|
|
|
return strings.TrimSpace(parts[1])
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
// returns the version of a package in the AUR
|
|
|
|
func GetAURPackageVersion(packageName string) (string, error) {
|
|
|
|
aurInfo, err := fetchAURPackageInfo(packageName)
|
|
|
|
if err != nil {
|
|
|
|
logger.Errorf("An error has occured:", err)
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
return aurInfo.Version, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// represents the search result from a specific source
|
|
|
|
type SourceResult struct {
|
|
|
|
Source string
|
|
|
|
Results []string
|
|
|
|
}
|
|
|
|
|
|
|
|
// represents the search results for a package across different sources
|
|
|
|
type PackageSearchResult struct {
|
|
|
|
PackageName string
|
|
|
|
Results []SourceResult
|
|
|
|
}
|
|
|
|
|
|
|
|
// searches for packages across Pacman, Snap, Flatpak, and AUR
|
|
|
|
func SearchAllSources(packageNames []string) ([]PackageSearchResult, error) {
|
|
|
|
var allPackageResults []PackageSearchResult
|
|
|
|
|
|
|
|
for _, packageName := range packageNames {
|
|
|
|
var packageResults PackageSearchResult
|
|
|
|
packageResults.PackageName = packageName
|
|
|
|
|
|
|
|
// Search in Pacman
|
|
|
|
pacmanResults, err := SearchPacman(packageName)
|
|
|
|
if err == nil {
|
|
|
|
packageResults.Results = append(packageResults.Results, SourceResult{"Pacman", pacmanResults})
|
|
|
|
}
|
|
|
|
|
|
|
|
// Search in Snap
|
|
|
|
snapResults, err := SearchSnap(packageName)
|
|
|
|
if err == nil {
|
|
|
|
packageResults.Results = append(packageResults.Results, SourceResult{"Snap", snapResults})
|
|
|
|
}
|
|
|
|
|
|
|
|
// Search in Flatpak
|
|
|
|
flatpakResults, err := SearchFlatpak(packageName)
|
|
|
|
if err == nil {
|
|
|
|
packageResults.Results = append(packageResults.Results, SourceResult{"Flatpak", flatpakResults})
|
|
|
|
}
|
|
|
|
|
|
|
|
// Search in AUR
|
|
|
|
aurResults, err := SearchAUR(packageName)
|
|
|
|
if err == nil {
|
|
|
|
var aurResultStrings []string
|
|
|
|
for _, result := range aurResults {
|
|
|
|
aurResultStrings = append(aurResultStrings, fmt.Sprintf("%s - %s", result.Name, result.Version))
|
|
|
|
}
|
|
|
|
packageResults.Results = append(packageResults.Results, SourceResult{"AUR", aurResultStrings})
|
|
|
|
}
|
|
|
|
|
|
|
|
allPackageResults = append(allPackageResults, packageResults)
|
|
|
|
}
|
|
|
|
|
|
|
|
return allPackageResults, nil
|
|
|
|
}
|