All database models have create and get functions.
This commit is contained in:
parent
20106b1f3f
commit
739a2f74eb
4 changed files with 328 additions and 39 deletions
|
|
@ -28,10 +28,13 @@ func main() {
|
|||
app.GET("/get/user/authorized", api.GetIsUserAuthorized)
|
||||
app.GET("/get/group", api.GetDatabaseGroup)
|
||||
app.GET("/get/groups", api.GetDatabaseGroups)
|
||||
app.GET("/get/all/groups", api.GetAllDatabaseGroups)
|
||||
app.GET("/get/function", api.GetDatabaseFunction)
|
||||
app.GET("/get/functions", api.GetDatabaseFunctions)
|
||||
app.GET("/get/all/functions", api.GetAllDatabaseFunctions)
|
||||
app.GET("/get/function-tag", api.GetDatabaseFunctionTag)
|
||||
app.GET("/get/function-tags", api.GetDatabaseFunctionTags)
|
||||
app.GET("/get/all/function-tags", api.GetAllDatabaseFunctionTags)
|
||||
// Delete
|
||||
app.Run(":31337")
|
||||
}
|
||||
|
|
|
|||
|
|
@ -267,7 +267,15 @@ func GetDatabaseGroup(context *gin.Context) {
|
|||
}
|
||||
|
||||
func GetDatabaseGroups(context *gin.Context) {
|
||||
groups := databasecommands.GetDatabaseGroups(GlobalDatabase)
|
||||
groupNames := context.QueryArray("groups")
|
||||
groups := databasecommands.GetDatabaseGroups(GlobalDatabase, groupNames)
|
||||
context.JSON(http.StatusOK, gin.H{
|
||||
"groups": groups,
|
||||
})
|
||||
}
|
||||
|
||||
func GetAllDatabaseGroups(context *gin.Context) {
|
||||
groups := databasecommands.GetAllDatabaseGroups(GlobalDatabase)
|
||||
context.JSON(http.StatusOK, gin.H{
|
||||
"groups": groups,
|
||||
})
|
||||
|
|
@ -286,7 +294,15 @@ func GetDatabaseFunction(context *gin.Context) {
|
|||
}
|
||||
|
||||
func GetDatabaseFunctions(context *gin.Context) {
|
||||
functions := databasecommands.GetDatabaseFunctions(GlobalDatabase)
|
||||
functionNames := context.QueryArray("functions")
|
||||
functions := databasecommands.GetDatabaseFunctions(GlobalDatabase, functionNames)
|
||||
context.JSON(http.StatusOK, gin.H{
|
||||
"functions": functions,
|
||||
})
|
||||
}
|
||||
|
||||
func GetAllDatabaseFunctions(context *gin.Context) {
|
||||
functions := databasecommands.GetAllDatabaseFunctions(GlobalDatabase)
|
||||
context.JSON(http.StatusOK, gin.H{
|
||||
"functions": functions,
|
||||
})
|
||||
|
|
@ -305,7 +321,15 @@ func GetDatabaseFunctionTag(context *gin.Context) {
|
|||
}
|
||||
|
||||
func GetDatabaseFunctionTags(context *gin.Context) {
|
||||
functionTags := databasecommands.GetDatabaseFunctionTags(GlobalDatabase)
|
||||
functionTagNames := context.QueryArray("functiontags")
|
||||
functionTags := databasecommands.GetDatabaseFunctionTags(GlobalDatabase, functionTagNames)
|
||||
context.JSON(http.StatusOK, gin.H{
|
||||
"function_tags": functionTags,
|
||||
})
|
||||
}
|
||||
|
||||
func GetAllDatabaseFunctionTags(context *gin.Context) {
|
||||
functionTags := databasecommands.GetAllDatabaseFunctionTags(GlobalDatabase)
|
||||
context.JSON(http.StatusOK, gin.H{
|
||||
"function_tags": functionTags,
|
||||
})
|
||||
|
|
|
|||
|
|
@ -196,14 +196,26 @@ func GetDatabasePerson(db *gorm.DB, inputPerson string) databasemodels.Person {
|
|||
if result.Error != nil {
|
||||
return databasemodels.Person{}
|
||||
}
|
||||
db.Model(&outputPerson).Association("Groups").Find(&outputPerson.Groups)
|
||||
return outputPerson
|
||||
}
|
||||
|
||||
func GetDatabasePersons(db *gorm.DB) []databasemodels.Person {
|
||||
func GetDatabasePersons(db *gorm.DB, inputPersons []string) []databasemodels.Person {
|
||||
var outputPersons []databasemodels.Person
|
||||
db.Find(&outputPersons)
|
||||
for _, inputPerson := range inputPersons {
|
||||
outputPersons = append(outputPersons, GetDatabasePerson(db, inputPerson))
|
||||
}
|
||||
return outputPersons
|
||||
}
|
||||
|
||||
func GetAllDatabasePersons(db *gorm.DB) []databasemodels.Person {
|
||||
var outputPersons []databasemodels.Person
|
||||
result := db.Find(&outputPersons)
|
||||
if result.Error != nil {
|
||||
log.Println(result.Error)
|
||||
}
|
||||
for index, outputPerson := range outputPersons {
|
||||
db.Model(&outputPerson).Association("Groups").Find(&outputPersons[index].Groups)
|
||||
outputPersons[index] = GetDatabasePerson(db, outputPerson.Name)
|
||||
}
|
||||
return outputPersons
|
||||
}
|
||||
|
|
@ -217,18 +229,24 @@ func GetDatabaseGroup(db *gorm.DB, inputGroup string) databasemodels.Group {
|
|||
return outputGroup
|
||||
}
|
||||
|
||||
func GetDatabaseGroups(db *gorm.DB) []string {
|
||||
func GetDatabaseGroups(db *gorm.DB, inputGroups []string) []databasemodels.Group {
|
||||
var outputGroups []databasemodels.Group
|
||||
for _, inputGroup := range inputGroups {
|
||||
outputGroups = append(outputGroups, GetDatabaseGroup(db, inputGroup))
|
||||
}
|
||||
return outputGroups
|
||||
}
|
||||
|
||||
func GetAllDatabaseGroups(db *gorm.DB) []databasemodels.Group {
|
||||
var outputGroups []databasemodels.Group
|
||||
var outputGroupsList []string
|
||||
result := db.Find(&outputGroups)
|
||||
if result.Error != nil {
|
||||
return outputGroupsList
|
||||
} else {
|
||||
for _, group := range outputGroups {
|
||||
outputGroupsList = append(outputGroupsList, group.Name)
|
||||
}
|
||||
return outputGroupsList
|
||||
log.Println(result.Error)
|
||||
}
|
||||
for index, outputGroup := range outputGroups {
|
||||
outputGroups[index] = GetDatabaseGroup(db, outputGroup.Name)
|
||||
}
|
||||
return outputGroups
|
||||
}
|
||||
|
||||
func GetDatabaseCharacter(db *gorm.DB, inputCharacter string) databasemodels.Character {
|
||||
|
|
@ -237,17 +255,29 @@ func GetDatabaseCharacter(db *gorm.DB, inputCharacter string) databasemodels.Cha
|
|||
if result.Error != nil {
|
||||
return databasemodels.Character{}
|
||||
}
|
||||
db.Model(&outputCharacter).Association("Owners").Find(&outputCharacter.Owners)
|
||||
db.Model(&outputCharacter).Association("Roles").Find(&outputCharacter.Roles)
|
||||
db.Model(&outputCharacter).Association("FunctionSets").Find(&outputCharacter.FunctionSets)
|
||||
db.Model(&outputCharacter).Association("Inventory").Find(&outputCharacter.Inventory)
|
||||
return outputCharacter
|
||||
}
|
||||
|
||||
func GetDatabaseCharacters(db *gorm.DB) []databasemodels.Character {
|
||||
func GetDatabaseCharacters(db *gorm.DB, inputCharacters []string) []databasemodels.Character {
|
||||
var outputCharacters []databasemodels.Character
|
||||
db.Find(&outputCharacters)
|
||||
for _, inputCharacter := range inputCharacters {
|
||||
outputCharacters = append(outputCharacters, GetDatabaseCharacter(db, inputCharacter))
|
||||
}
|
||||
return outputCharacters
|
||||
}
|
||||
|
||||
func GetAllDatabaseCharacters(db *gorm.DB) []databasemodels.Character {
|
||||
var outputCharacters []databasemodels.Character
|
||||
result := db.Find(&outputCharacters)
|
||||
if result.Error != nil {
|
||||
log.Println(result.Error)
|
||||
}
|
||||
for index, outputCharacter := range outputCharacters {
|
||||
db.Model(&outputCharacter).Association("Owners").Find(&outputCharacters[index].Owners)
|
||||
db.Model(&outputCharacter).Association("Roles").Find(&outputCharacters[index].Roles)
|
||||
db.Model(&outputCharacter).Association("FunctionSets").Find(&outputCharacters[index].FunctionSets)
|
||||
db.Model(&outputCharacter).Association("Inventory").Find(&outputCharacters[index].Inventory)
|
||||
outputCharacters[index] = GetDatabaseCharacter(db, outputCharacter.Name)
|
||||
}
|
||||
return outputCharacters
|
||||
}
|
||||
|
|
@ -258,15 +288,28 @@ func GetDatabaseRole(db *gorm.DB, inputRole string) databasemodels.Role {
|
|||
if result.Error != nil {
|
||||
return databasemodels.Role{}
|
||||
}
|
||||
db.Model(&outputRole).Association("Tiers").Find(&outputRole.Tiers)
|
||||
db.Model(&outputRole).Association("Visibility").Find(&outputRole.Visibility)
|
||||
return outputRole
|
||||
}
|
||||
|
||||
func GetDatabaseRoles(db *gorm.DB) []databasemodels.Role {
|
||||
var outputRoles []databasemodels.Role
|
||||
db.Find(&outputRoles)
|
||||
for _, outputRole := range outputRoles {
|
||||
outputRoles = append(outputRoles, GetDatabaseRole(db, outputRole.Name))
|
||||
}
|
||||
return outputRoles
|
||||
}
|
||||
|
||||
func GetAllDatabaseRoles(db *gorm.DB) []databasemodels.Role {
|
||||
var outputRoles []databasemodels.Role
|
||||
result := db.Find(&outputRoles)
|
||||
if result.Error != nil {
|
||||
log.Println(result.Error)
|
||||
}
|
||||
for index, outputRole := range outputRoles {
|
||||
db.Model(&outputRole).Association("Tiers").Find(&outputRoles[index].Tiers)
|
||||
db.Model(&outputRole).Association("Visibility").Find(&outputRoles[index].Visibility)
|
||||
outputRoles[index] = GetDatabaseRole(db, outputRole.Name)
|
||||
}
|
||||
return outputRoles
|
||||
}
|
||||
|
|
@ -277,33 +320,88 @@ func GetDatabaseTier(db *gorm.DB, inputTier int) databasemodels.Tier {
|
|||
if result.Error != nil {
|
||||
return databasemodels.Tier{}
|
||||
}
|
||||
db.Model(&outputTier).Association("FunctionSets").Find(&outputTier.FunctionSets)
|
||||
return outputTier
|
||||
}
|
||||
|
||||
func GetDatabaseTiers(db *gorm.DB) []databasemodels.Tier {
|
||||
func GetDatabaseTiers(db *gorm.DB, inputTiers []int) []databasemodels.Tier {
|
||||
var outputTiers []databasemodels.Tier
|
||||
db.Find(&outputTiers)
|
||||
for index, outputTier := range outputTiers {
|
||||
db.Model(&outputTier).Association("FunctionSets").Find(&outputTiers[index].FunctionSets)
|
||||
for _, inputTier := range inputTiers {
|
||||
outputTiers = append(outputTiers, GetDatabaseTier(db, inputTier))
|
||||
}
|
||||
return outputTiers
|
||||
}
|
||||
|
||||
func GetAllDatabaseTiers(db *gorm.DB) []databasemodels.Tier {
|
||||
var outputTiers []databasemodels.Tier
|
||||
result := db.Find(&outputTiers)
|
||||
if result.Error != nil {
|
||||
log.Println(result.Error)
|
||||
}
|
||||
for index, outputTier := range outputTiers {
|
||||
outputTiers[index] = GetDatabaseTier(db, int(outputTier.ID))
|
||||
}
|
||||
return outputTiers
|
||||
}
|
||||
|
||||
func GetDatabaseFunctionSet(db *gorm.DB, inputFunctionSet int) databasemodels.FunctionSet {
|
||||
var outputFunctionSet databasemodels.FunctionSet
|
||||
result := db.Model(&databasemodels.FunctionSet{}).Where("id = ?", inputFunctionSet).Take(&outputFunctionSet)
|
||||
if result.Error != nil {
|
||||
return databasemodels.FunctionSet{}
|
||||
}
|
||||
db.Model(&outputFunctionSet).Association("Functions").Find(&outputFunctionSet.Functions)
|
||||
return outputFunctionSet
|
||||
}
|
||||
|
||||
func GetDatabaseFunctionSets(db *gorm.DB, inputFunctionSets []int) []databasemodels.FunctionSet {
|
||||
var outputFunctionSets []databasemodels.FunctionSet
|
||||
db.Find(&outputFunctionSets)
|
||||
for _, inputFunctionSet := range inputFunctionSets {
|
||||
outputFunctionSets = append(outputFunctionSets, GetDatabaseFunctionSet(db, inputFunctionSet))
|
||||
}
|
||||
return outputFunctionSets
|
||||
}
|
||||
|
||||
func GetAllDatabaseFunctionSets(db *gorm.DB) []databasemodels.FunctionSet {
|
||||
var outputFunctionSets []databasemodels.FunctionSet
|
||||
result := db.Find(&outputFunctionSets)
|
||||
if result.Error != nil {
|
||||
log.Println(result.Error)
|
||||
}
|
||||
for index, outputFunctionSet := range outputFunctionSets {
|
||||
outputFunctionSets[index] = GetDatabaseFunctionSet(db, int(outputFunctionSet.ID))
|
||||
}
|
||||
return outputFunctionSets
|
||||
}
|
||||
|
||||
func GetDatabaseFunction(db *gorm.DB, inputFunction string) databasemodels.Function {
|
||||
var outputFunction databasemodels.Function
|
||||
result := db.Model(&databasemodels.Function{}).Where("name = ?", inputFunction).Take(&outputFunction)
|
||||
if result.Error != nil {
|
||||
return databasemodels.Function{}
|
||||
}
|
||||
db.Model(&outputFunction).Association("Tags").Find(&outputFunction.Tags)
|
||||
db.Model(&outputFunction).Association("Requirements").Find(&outputFunction.Requirements)
|
||||
return outputFunction
|
||||
}
|
||||
|
||||
func GetDatabaseFunctions(db *gorm.DB) []databasemodels.Function {
|
||||
func GetDatabaseFunctions(db *gorm.DB, inputFunctions []string) []databasemodels.Function {
|
||||
var outputFunctions []databasemodels.Function
|
||||
db.Find(&outputFunctions)
|
||||
for _, inputFunction := range inputFunctions {
|
||||
outputFunctions = append(outputFunctions, GetDatabaseFunction(db, inputFunction))
|
||||
}
|
||||
return outputFunctions
|
||||
}
|
||||
|
||||
func GetAllDatabaseFunctions(db *gorm.DB) []databasemodels.Function {
|
||||
var outputFunctions []databasemodels.Function
|
||||
result := db.Find(&outputFunctions)
|
||||
if result.Error != nil {
|
||||
log.Println(result.Error)
|
||||
}
|
||||
for index, outputFunction := range outputFunctions {
|
||||
db.Model(&outputFunction).Association("Tags").Find(&outputFunctions[index].Tags)
|
||||
db.Model(&outputFunction).Association("Requirements").Find(&outputFunctions[index].Requirements)
|
||||
outputFunctions[index] = GetDatabaseFunction(db, outputFunction.Name)
|
||||
}
|
||||
return outputFunctions
|
||||
}
|
||||
|
|
@ -317,18 +415,182 @@ func GetDatabaseFunctionTag(db *gorm.DB, inputFunctionTag string) databasemodels
|
|||
return outputFunctionTag
|
||||
}
|
||||
|
||||
func GetDatabaseFunctionTags(db *gorm.DB) []string {
|
||||
func GetDatabaseFunctionTags(db *gorm.DB, inputFunctionTags []string) []databasemodels.FunctionTag {
|
||||
var outputFunctionTags []databasemodels.FunctionTag
|
||||
for _, inputFunctionTag := range inputFunctionTags {
|
||||
outputFunctionTags = append(outputFunctionTags, GetDatabaseFunctionTag(db, inputFunctionTag))
|
||||
}
|
||||
return outputFunctionTags
|
||||
}
|
||||
|
||||
func GetAllDatabaseFunctionTags(db *gorm.DB) []databasemodels.FunctionTag {
|
||||
var outputFunctionTags []databasemodels.FunctionTag
|
||||
var outputFunctionTagsList []string
|
||||
result := db.Find(&outputFunctionTags)
|
||||
if result.Error != nil {
|
||||
return outputFunctionTagsList
|
||||
} else {
|
||||
for _, functionTag := range outputFunctionTags {
|
||||
outputFunctionTagsList = append(outputFunctionTagsList, functionTag.Name)
|
||||
}
|
||||
return outputFunctionTagsList
|
||||
log.Println(result.Error)
|
||||
}
|
||||
for index, outputFunctionTag := range outputFunctionTags {
|
||||
outputFunctionTags[index] = GetDatabaseFunctionTag(db, outputFunctionTag.Name)
|
||||
}
|
||||
return outputFunctionTags
|
||||
}
|
||||
|
||||
func GetDatabaseInventorySlot(db *gorm.DB, inputInventorySlot int) databasemodels.InventorySlot {
|
||||
var outputInventorySlot databasemodels.InventorySlot
|
||||
result := db.Model(&databasemodels.InventorySlot{}).Where("id = ?", inputInventorySlot).Take(&outputInventorySlot)
|
||||
if result.Error != nil {
|
||||
return databasemodels.InventorySlot{}
|
||||
}
|
||||
db.Model(&outputInventorySlot).Association("Item").Find(&outputInventorySlot.Item)
|
||||
return outputInventorySlot
|
||||
}
|
||||
|
||||
func GetDatabaseInventorySlots(db *gorm.DB, inputInventorySlots []int) []databasemodels.InventorySlot {
|
||||
var outputInventorySlots []databasemodels.InventorySlot
|
||||
for _, inputInventorySlot := range inputInventorySlots {
|
||||
outputInventorySlots = append(outputInventorySlots, GetDatabaseInventorySlot(db, inputInventorySlot))
|
||||
}
|
||||
return outputInventorySlots
|
||||
}
|
||||
|
||||
func GetAllDatabaseInventorySlots(db *gorm.DB) []databasemodels.InventorySlot {
|
||||
var outputInventorySlots []databasemodels.InventorySlot
|
||||
result := db.Find(&outputInventorySlots)
|
||||
if result.Error != nil {
|
||||
log.Println(result.Error)
|
||||
}
|
||||
for index, outputInventorySlot := range outputInventorySlots {
|
||||
outputInventorySlots[index] = GetDatabaseInventorySlot(db, int(outputInventorySlot.ID))
|
||||
}
|
||||
return outputInventorySlots
|
||||
}
|
||||
|
||||
func GetDatabaseItem(db *gorm.DB, inputItem string) databasemodels.Item {
|
||||
var outputItem databasemodels.Item
|
||||
result := db.Model(&databasemodels.Item{}).Where("name = ?", inputItem).Take(&outputItem)
|
||||
if result.Error != nil {
|
||||
return databasemodels.Item{}
|
||||
}
|
||||
db.Model(&outputItem).Association("Functions").Find(&outputItem.Functions)
|
||||
db.Model(&outputItem).Association("Tags").Find(&outputItem.Tags)
|
||||
db.Model(&outputItem).Association("Customizations").Find(&outputItem.Customizations)
|
||||
db.Model(&outputItem).Association("Visibility").Find(&outputItem.Visibility)
|
||||
return outputItem
|
||||
}
|
||||
|
||||
func GetDatabaseItems(db *gorm.DB, inputItems []string) []databasemodels.Item {
|
||||
var outputItems []databasemodels.Item
|
||||
for _, inputItem := range inputItems {
|
||||
outputItems = append(outputItems, GetDatabaseItem(db, inputItem))
|
||||
}
|
||||
return outputItems
|
||||
}
|
||||
|
||||
func GetAllDatabaseItems(db *gorm.DB) []databasemodels.Item {
|
||||
var outputItems []databasemodels.Item
|
||||
result := db.Find(&outputItems)
|
||||
if result.Error != nil {
|
||||
log.Println(result.Error)
|
||||
}
|
||||
for index, outputItem := range outputItems {
|
||||
outputItems[index] = GetDatabaseItem(db, outputItem.Name)
|
||||
}
|
||||
return outputItems
|
||||
}
|
||||
|
||||
func GetDatabaseItemTag(db *gorm.DB, inputItemTag string) databasemodels.ItemTag {
|
||||
var outputItemTag databasemodels.ItemTag
|
||||
result := db.Model(&databasemodels.ItemTag{}).Where("name = ?", outputItemTag).Take(&outputItemTag)
|
||||
if result.Error != nil {
|
||||
return databasemodels.ItemTag{}
|
||||
}
|
||||
return outputItemTag
|
||||
}
|
||||
|
||||
func GetDatabaseItemTags(db *gorm.DB, inputItemTags []string) []databasemodels.ItemTag {
|
||||
var outputItemTags []databasemodels.ItemTag
|
||||
for _, inputItemTag := range inputItemTags {
|
||||
outputItemTags = append(outputItemTags, GetDatabaseItemTag(db, inputItemTag))
|
||||
}
|
||||
return outputItemTags
|
||||
}
|
||||
|
||||
func GetAllDatabaseItemTags(db *gorm.DB) []databasemodels.ItemTag {
|
||||
var outputItemTags []databasemodels.ItemTag
|
||||
result := db.Find(&outputItemTags)
|
||||
if result.Error != nil {
|
||||
log.Println(result.Error)
|
||||
}
|
||||
for index, outputItemTag := range outputItemTags {
|
||||
outputItemTags[index] = GetDatabaseItemTag(db, outputItemTag.Name)
|
||||
}
|
||||
return outputItemTags
|
||||
}
|
||||
|
||||
func GetDatabaseCustomization(db *gorm.DB, inputCustomization string) databasemodels.Customization {
|
||||
var outputCustomization databasemodels.Customization
|
||||
result := db.Model(&databasemodels.Customization{}).Where("name = ?", inputCustomization).Take(&outputCustomization)
|
||||
if result.Error != nil {
|
||||
return databasemodels.Customization{}
|
||||
}
|
||||
db.Model(&outputCustomization).Association("Functions").Find(&outputCustomization.Functions)
|
||||
db.Model(&outputCustomization).Association("Tags").Find(&outputCustomization.Tags)
|
||||
db.Model(&outputCustomization).Association("Visibility").Find(&outputCustomization.Visibility)
|
||||
return outputCustomization
|
||||
}
|
||||
|
||||
func GetDatabaseCustomizations(db *gorm.DB, inputCustomizations []string) []databasemodels.Customization {
|
||||
var outputCustomizations []databasemodels.Customization
|
||||
for _, inputCustomization := range inputCustomizations {
|
||||
outputCustomizations = append(outputCustomizations, GetDatabaseCustomization(db, inputCustomization))
|
||||
}
|
||||
return outputCustomizations
|
||||
}
|
||||
|
||||
func GetAllDatabaseCustomizations(db *gorm.DB) []databasemodels.Customization {
|
||||
var outputCustomizations []databasemodels.Customization
|
||||
result := db.Find(&outputCustomizations)
|
||||
if result.Error != nil {
|
||||
log.Println(result.Error)
|
||||
}
|
||||
for index, outputCustomization := range outputCustomizations {
|
||||
outputCustomizations[index] = GetDatabaseCustomization(db, outputCustomization.Name)
|
||||
}
|
||||
return outputCustomizations
|
||||
}
|
||||
|
||||
func GetDatabaseSchematic(db *gorm.DB, inputSchematic int) databasemodels.Schematic {
|
||||
var outputSchematic databasemodels.Schematic
|
||||
result := db.Model(&databasemodels.Schematic{}).Where("id = ?", inputSchematic).Take(&outputSchematic)
|
||||
if result.Error != nil {
|
||||
return databasemodels.Schematic{}
|
||||
}
|
||||
db.Model(&outputSchematic).Association("Material").Find(&outputSchematic.Material)
|
||||
db.Model(&outputSchematic).Association("Tools").Find(&outputSchematic.Tools)
|
||||
db.Model(&outputSchematic).Association("Requirements").Find(&outputSchematic.Requirements)
|
||||
db.Model(&outputSchematic).Association("Result").Find(&outputSchematic.Result)
|
||||
db.Model(&outputSchematic).Association("Visibility").Find(&outputSchematic.Visibility)
|
||||
return outputSchematic
|
||||
}
|
||||
|
||||
func GetDatabaseSchematics(db *gorm.DB, inputSchematics []int) []databasemodels.Schematic {
|
||||
var outputSchematics []databasemodels.Schematic
|
||||
for _, inputSchematic := range inputSchematics {
|
||||
outputSchematics = append(outputSchematics, GetDatabaseSchematic(db, inputSchematic))
|
||||
}
|
||||
return outputSchematics
|
||||
}
|
||||
|
||||
func GetAllDatabaseSchematics(db *gorm.DB) []databasemodels.Schematic {
|
||||
var outputSchematics []databasemodels.Schematic
|
||||
result := db.Find(&outputSchematics)
|
||||
if result.Error != nil {
|
||||
log.Println(result.Error)
|
||||
}
|
||||
for index, outputSchematic := range outputSchematics {
|
||||
outputSchematics[index] = GetDatabaseSchematic(db, int(outputSchematic.ID))
|
||||
}
|
||||
return outputSchematics
|
||||
}
|
||||
|
||||
// Update Functions
|
||||
|
|
|
|||
|
|
@ -91,7 +91,7 @@ type ItemTag struct {
|
|||
|
||||
type Customization struct {
|
||||
gorm.Model
|
||||
Name string `json:"name"`
|
||||
Name string `gorm:"primaryKey uniqueIndex" json:"name"`
|
||||
Functions []Function `gorm:"many2many:customization_function_associations" json:"functions"`
|
||||
FlavorText string `json:"flavor_text"`
|
||||
RulesDescription string `json:"rules_description"`
|
||||
|
|
|
|||
Loading…
Reference in a new issue