tsindt/simply_cpq
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

PropertyTypes integriert

Browse Source
This commit is contained in:
tsindt
2026-08-04 22:51:10 +02:00
parent 8697336ba3
commit 19704fa89e
11 changed files with 647 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files
buildtime/client/material-editor/src/api/language/propertyTypes.api.ts
+30
View File
@@ -0,0 +1,30 @@
import ky from 'ky'
import type { PropertyType } from '../../data/propertyType'
export const getPropertyTypes = async (): Promise<PropertyType[]> => {
return ky.get(`http://localhost:8088/propertytypes`).json<PropertyType[]>()
}
export const getPropertyTypeById = async (id: number): Promise<PropertyType> => {
return ky.get(`http://localhost:8088/propertytype/${id}`).json<PropertyType>()
}
export const createPropertyType = async (propertyType: PropertyType): Promise<PropertyType> => {
return ky.post(`http://localhost:8088/propertytype`, { json: propertyType }).json<PropertyType>()
}
export const updatePropertyType = async (propertyType: PropertyType): Promise<PropertyType> => {
return ky.put(`http://localhost:8088/propertytype`, { json: propertyType }).json<PropertyType>()
}
export const deletePropertyType = async (id: number): Promise<void> => {
return ky.delete(`http://localhost:8088/propertytype/${id}`).json<void>()
}
export const getPropertyTypesByPropertyGroupId = async (propertyGroupId: number): Promise<PropertyType[]> => {
return ky.get(`http://localhost:8088/propertytypes/${propertyGroupId}`).json<PropertyType[]>()
}
export const getAllPropertyTypes = async (): Promise<PropertyType[]> => {
return ky.get(`http://localhost:8088/propertytypes`).json<PropertyType[]>()
}
buildtime/client/material-editor/src/components/PropertyTypesTableView.tsx
+108
View File
@@ -0,0 +1,108 @@
import * as React from 'react';
import type { propertyGroup } from '../data/propertyGroup';
import type { PropertyType } from '../data/propertyType';
import Paper from '@mui/material/Paper';
import DeleteIcon from '@mui/icons-material/Delete';
import AddIcon from '@mui/icons-material/Add';
import Tooltip from '@mui/material/Tooltip';
import FileDownloadIcon from '@mui/icons-material/FileDownload';
import { Typography } from '@mui/material';
import { DataGrid, Toolbar, ToolbarButton} from '@mui/x-data-grid';
import { ExportCsv } from '@mui/x-data-grid';
import { getPropertyGroupById } from '../api/language/propertyGroup.api';
import { updatePropertyType } from '../api/language/propertyTypes.api';
import { getPropertyTypesByPropertyGroupId } from '../api/language/propertyTypes.api';
const PropertyTypesTableView = ({ selectedRow }: { selectedRow: number }) => {
const [propertyTypes, setPropertyTypes] = React.useState<PropertyType[]>([]);
const [propertyGroup, setPropertyGroup] = React.useState<propertyGroup | null>(null);
React.useEffect(() => {
getPropertyTypesByPropertyGroupId(selectedRow).then(setPropertyTypes);
}, [selectedRow]);
React.useEffect(() => {
getPropertyGroupById(selectedRow).then(setPropertyGroup);
}, [selectedRow]);
function CustomToolbar() {
return (
<Toolbar>
<Typography variant="body1" component="div" sx={{ flexGrow: 1 }}>
Property types for group {propertyGroup?.label}.
</Typography>
<Tooltip title="Download as CSV">
<ExportCsv render={<ToolbarButton />}>
<FileDownloadIcon fontSize="small" />
</ExportCsv>
</Tooltip>
<ToolbarButton onClick={() => console.log('Delete Row clicked')}>
<DeleteIcon fontSize="small" sx={{ ml: 'auto' }} />
</ToolbarButton>
<ToolbarButton onClick={() => console.log('Add Row clicked')}>
<AddIcon fontSize="small" sx={{ ml: 'auto' }} />
</ToolbarButton>
</Toolbar>
)
}
return (
<div>
<Paper sx={{ height: 600, width: '50vw' }}>
<DataGrid
sx={{ border: 1, borderRadius: 2,
boxShadow: 2,
borderColor: 'primary.main',
'& .MuiDataGrid-cell:hover': { color: 'primary.main' },
'& .even-row': { backgroundColor: 'rgba(0, 0, 1, 0.02)' },
'& .odd-row': { backgroundColor: 'rgba(0, 0, 20, 0.04)' },
}}
columnHeaderHeight={36}
rowHeight={25}
rowSpacingType="margin"
initialState={{
sorting: {
sortModel: [{ field: 'id', sort: 'asc' }],
},
}}
rows={propertyTypes}
columns={[
{ field: 'id', headerName: 'ID', width: 100 ,align: 'right', headerAlign: 'right', editable: false},
{ field: 'label', headerName: 'Label', width: 200 , editable: true},
{ field: 'valueTypeId', headerName: 'Value Type Id', width: 100 , editable: true},
{ field: 'propertyGroupId', headerName: 'Property Group Id', width: 100 , editable: true},
{ field: 'valueComplexityId', headerName: 'Value Complexity Id', width: 100 , editable: true},
{ field: 'value', headerName: 'Value', width: 200 , editable: true},
]}
slots={{
toolbar: CustomToolbar,
}}
processRowUpdate={(updatedRow, originalRow) => {
updatePropertyType({
id: updatedRow.id,
valueTypeId: updatedRow.valueTypeId,
propertyGroupId: updatedRow.propertyGroupId,
valueComplexityId: updatedRow.valueComplexityId,
value: updatedRow.value
}
)
return updatedRow;
}}
getRowClassName={(params) =>
params.indexRelativeToCurrentPage % 2 === 0 ? 'even-row' : 'odd-row'
}
showToolbar
/>
</Paper>
</div>
);
};
export default PropertyTypesTableView;
buildtime/client/material-editor/src/data/propertyType.ts
+9
View File
@@ -0,0 +1,9 @@
export type PropertyType = {
id: number;
label: string;
valueTypeId: number;
propertyGroupId: number;
valueComplexityId: number;
value: string;
};
buildtime/client/material-editor/src/pages/PropertyPage.tsx
+2 -2
View File
@@ -1,6 +1,6 @@
import React, { useEffect, useState } from 'react';
import PropertyTypesTableView from '../components/PropertyTypesTableView';
import PropertyGroupsTableView from '../components/PropertyGroupsTableView';
import TranslationsTableView from '../components/TranslationsTableView';
import Box from '@mui/material/Box';
import Typography from '@mui/material/Typography';
import type { propertyGroup } from '../data/propertyGroup';
@@ -28,7 +28,7 @@ const PropertyPage: React.FC = () => {
}}
>
<PropertyGroupsTableView propertyGroups={propertyGroups} setSelectedRow={setSelectedRow} />
<TranslationsTableView selectedRow={selectedRow} />
<PropertyTypesTableView selectedRow={selectedRow} />
</Box>
</Box>
);
buildtime/server/src/scpq-editor-server/controller/propertytypesController.go
+125
View File
@@ -0,0 +1,125 @@
package controller
import (
"encoding/json"
"io"
"log"
"net/http"
"scpq-editor-server/models"
"scpq-editor-server/services"
"strconv"
"github.com/gin-gonic/gin"
)
type PropertytypesController struct {
PropertytypesService *services.PropertytypesService
}
func NewPropertytypesController(PropertytypesService *services.PropertytypesService) *PropertytypesController {
return &PropertytypesController{
PropertytypesService: PropertytypesService,
}
}
func (lc PropertytypesController) CreatePropertytype(ctx *gin.Context) {
body, err := io.ReadAll(ctx.Request.Body)
if err != nil {
log.Println("Error while reading create Translation request body", err)
ctx.AbortWithError(http.StatusInternalServerError, err)
return
}
var propertyType models.PropertyType
err = json.Unmarshal(body, &propertyType)
if err != nil {
log.Println("Error while unmarshaling create PropertyType request body", err)
ctx.AbortWithError(http.StatusInternalServerError, err)
return
}
response, responseErr := lc.PropertytypesService.CreatePropertyType(&propertyType)
if responseErr != nil {
ctx.AbortWithStatusJSON(responseErr.Status, responseErr)
return
}
ctx.JSON(http.StatusOK, response)
}
func (lc PropertytypesController) UpdatePropertytype(ctx *gin.Context) {
body, err := io.ReadAll(ctx.Request.Body)
if err != nil {
log.Println("Error while reading update PropertyType request body", err)
ctx.AbortWithError(http.StatusInternalServerError, err)
return
}
var propertyType models.PropertyType
err = json.Unmarshal(body, &propertyType)
if err != nil {
log.Println("Error while unmarshaling update PropertyType request body", err)
ctx.AbortWithError(http.StatusInternalServerError, err)
return
}
responseErr := lc.PropertytypesService.UpdatePropertyType(&propertyType)
if responseErr != nil {
ctx.AbortWithStatusJSON(responseErr.Status, responseErr)
return
}
ctx.Status(http.StatusNoContent)
}
func (lc PropertytypesController) DeletePropertytype(ctx *gin.Context) {
propertyTypeId := ctx.Param("id")
lId, err := strconv.Atoi(propertyTypeId)
if err != nil {
log.Println("Error propertyTypeId not int", err)
ctx.AbortWithError(http.StatusInternalServerError, err)
return
}
responseErr := lc.PropertytypesService.DeletePropertyType(lId)
if responseErr != nil {
ctx.JSON(responseErr.Status, responseErr)
return
}
ctx.Status(http.StatusNoContent)
}
func (lc PropertytypesController) GetPropertytype(ctx *gin.Context) {
propertyTypeId := ctx.Param("id")
lId, err := strconv.Atoi(propertyTypeId)
if err != nil {
log.Println("Error propertyTypeId not int", err)
ctx.AbortWithError(http.StatusInternalServerError, err)
return
}
response, responseErr := lc.PropertytypesService.GetPropertyType(lId)
if responseErr != nil {
ctx.JSON(responseErr.Status, responseErr)
return
}
ctx.JSON(http.StatusOK, response)
}
func (lc PropertytypesController) GetAllPropertytypes(ctx *gin.Context) {
response, responseErr := lc.PropertytypesService.GetAllPropertyTypes()
if responseErr != nil {
ctx.JSON(responseErr.Status, responseErr)
return
}
ctx.JSON(http.StatusOK, response)
}
func (lc PropertytypesController) GetAllPropertytypesByPropertyGroupId(ctx *gin.Context) {
propertyGroupId := ctx.Param("propertyGroupId")
lId, err := strconv.Atoi(propertyGroupId)
if err != nil {
log.Println("Error propertyGroupId not int", err)
ctx.AbortWithError(http.StatusInternalServerError, err)
return
}
response, responseErr := lc.PropertytypesService.GetAllPropertyTypesByPropertyGroupId(lId)
if responseErr != nil {
ctx.JSON(responseErr.Status, responseErr)
return
}
ctx.JSON(http.StatusOK, response)
}
buildtime/server/src/scpq-editor-server/models/propertytype.go
+10
View File
@@ -0,0 +1,10 @@
package models
type PropertyType struct {
ID int `json:"id"`
Label string `json:"label"`
ValueTypeID int `json:"valueTypeId"`
PropertyGroupID int `json:"propertyGroupId"`
ValueComplexityId string `json:"valueComplexityId"`
Value string `json:"value"`
}
buildtime/server/src/scpq-editor-server/repositories/propertyTypesRepository.go
+292
View File
@@ -0,0 +1,292 @@
package repositories
import (
"database/sql"
"net/http"
"scpq-editor-server/models"
"strconv"
)
type PropertyTypesRepository struct {
dbHandler *sql.DB
}
func NewPropertyTypesRepository(dbHandler *sql.DB) *PropertyTypesRepository {
return &PropertyTypesRepository{
dbHandler: dbHandler,
}
}
func (rr PropertyTypesRepository) CreatePropertyType(PropertyType *models.PropertyType) (*models.PropertyType, *models.ResponseError) {
query := `INSERT INTO property_types(label, value_type_id, property_group_id, value_complexity_id, value) VALUES($1,$2,$3,$4,$5) RETURNING id`
rows, err := rr.dbHandler.Query(query, PropertyType.Label, PropertyType.ValueTypeID, PropertyType.PropertyGroupID, PropertyType.ValueComplexityId, PropertyType.Value)
if err != nil {
return nil, &models.ResponseError{
Message: err.Error(),
Status: http.StatusInternalServerError,
}
}
defer rows.Close()
var idstr string
for rows.Next() {
err := rows.Scan(&idstr)
if err != nil {
return nil, &models.ResponseError{
Message: err.Error(),
Status: http.StatusInternalServerError,
}
}
}
if rows.Err() != nil {
return nil, &models.ResponseError{
Message: err.Error(),
Status: http.StatusInternalServerError,
}
}
PropertyTypeId, err := strconv.Atoi(idstr)
if err != nil {
return nil, &models.ResponseError{
Message: "PropertyType id not int",
Status: http.StatusInternalServerError,
}
}
return &models.PropertyType{
ID: PropertyTypeId,
Label: PropertyType.Label,
ValueTypeID: PropertyType.ValueTypeID,
PropertyGroupID: PropertyType.PropertyGroupID,
ValueComplexityId: PropertyType.ValueComplexityId,
Value: PropertyType.Value,
}, nil
}
func (rr PropertyTypesRepository) UpdatePropertyType(PropertyType *models.PropertyType) *models.ResponseError {
query := `UPDATE property_types SET value_type_id=$1, property_group_id=$2, value_complexity_id=$3, value=$4 WHERE id=$5`
res, err := rr.dbHandler.Exec(query, PropertyType.ValueTypeID, PropertyType.PropertyGroupID, PropertyType.ValueComplexityId, PropertyType.Value, PropertyType.ID)
if err != nil {
return &models.ResponseError{
Message: err.Error(),
Status: http.StatusInternalServerError,
}
}
rowsAffeced, err := res.RowsAffected()
if err != nil {
return &models.ResponseError{
Message: err.Error(),
Status: http.StatusInternalServerError,
}
}
if rowsAffeced == 0 {
return &models.ResponseError{
Message: "No PropertyType found with the given id",
Status: http.StatusNotFound,
}
}
return nil
}
func (rr PropertyTypesRepository) DeletePropertyType(PropertyTypeId int) *models.ResponseError {
query := `DELETE FROM property_types WHERE id=$1`
res, err := rr.dbHandler.Exec(query, PropertyTypeId)
if err != nil {
return &models.ResponseError{
Message: err.Error(),
Status: http.StatusInternalServerError,
}
}
rowsAffeced, err := res.RowsAffected()
if err != nil {
return &models.ResponseError{
Message: err.Error(),
Status: http.StatusInternalServerError,
}
}
if rowsAffeced == 0 {
return &models.ResponseError{
Message: "No PropertyType found with the given id",
Status: http.StatusNotFound,
}
}
return nil
}
func (rr PropertyTypesRepository) GetPropertyType(PropertyTypeId int) (*models.PropertyType, *models.ResponseError) {
query := `SELECT id, label, value_type_id, property_group_id, value_complexity_id, value FROM property_types WHERE id=$1`
rows, err := rr.dbHandler.Query(query, PropertyTypeId)
if err != nil {
return nil, &models.ResponseError{
Message: err.Error(),
Status: http.StatusInternalServerError,
}
}
defer rows.Close()
var idstr, label, value_type_id_str, property_group_id_str, value_complexity_id, value string
for rows.Next() {
err := rows.Scan(&idstr, &label, &value_type_id_str, &property_group_id_str, &value_complexity_id, &value)
if err != nil {
return nil, &models.ResponseError{
Message: err.Error(),
Status: http.StatusInternalServerError,
}
}
}
if rows.Err() != nil {
return nil, &models.ResponseError{
Message: err.Error(),
Status: http.StatusInternalServerError,
}
}
PropertyTypeId, err = strconv.Atoi(idstr)
if err != nil {
return nil, &models.ResponseError{
Message: "PropertyType id not int",
Status: http.StatusInternalServerError,
}
}
PropertyGroupID, err := strconv.Atoi(property_group_id_str)
if err != nil {
return nil, &models.ResponseError{
Message: "PropertyGroup id not int",
Status: http.StatusInternalServerError,
}
}
ValueTypeID, err := strconv.Atoi(value_type_id_str)
if err != nil {
return nil, &models.ResponseError{
Message: "ValueType id not int",
Status: http.StatusInternalServerError,
}
}
return &models.PropertyType{
ID: PropertyTypeId,
Label: label,
ValueTypeID: ValueTypeID,
ValueComplexityId: value_complexity_id,
Value: value,
PropertyGroupID: PropertyGroupID,
}, nil
}
func (rr PropertyTypesRepository) GetAllPropertyTypes() ([]*models.PropertyType, *models.ResponseError) {
query := "SELECT id, label, value_type_id, property_group_id, value_complexity_id, value FROM property_types"
rows, err := rr.dbHandler.Query(query)
if err != nil {
return nil, &models.ResponseError{
Message: err.Error(),
Status: http.StatusInternalServerError,
}
}
defer rows.Close()
PropertyTypes := make([]*models.PropertyType, 0)
var idstr, label, value_type_id_str, property_group_id_str, value_complexity_id, value string
for rows.Next() {
err := rows.Scan(&idstr, &label, &value_type_id_str, &property_group_id_str, &value_complexity_id, &value)
if err != nil {
return nil, &models.ResponseError{
Message: err.Error(),
Status: http.StatusInternalServerError,
}
}
PropertyTypeId, err := strconv.Atoi(idstr)
if err != nil {
return nil, &models.ResponseError{
Message: "PropertyType id not int",
Status: http.StatusInternalServerError,
}
}
PropertyGroupID, err := strconv.Atoi(property_group_id_str)
if err != nil {
return nil, &models.ResponseError{
Message: "PropertyGroup id not int",
Status: http.StatusInternalServerError,
}
}
ValueTypeID, err := strconv.Atoi(value_type_id_str)
if err != nil {
return nil, &models.ResponseError{
Message: "ValueType id not int",
Status: http.StatusInternalServerError,
}
}
PropertyType := &models.PropertyType{
ID: PropertyTypeId,
Label: label,
ValueTypeID: ValueTypeID,
ValueComplexityId: value_complexity_id,
Value: value,
PropertyGroupID: PropertyGroupID,
}
PropertyTypes = append(PropertyTypes, PropertyType)
}
if rows.Err() != nil {
return nil, &models.ResponseError{
Message: err.Error(),
Status: http.StatusInternalServerError,
}
}
return PropertyTypes, nil
}
func (rr PropertyTypesRepository) GetAllPropertyTypesByPropertyGroupId(propertyGroupId int) ([]*models.PropertyType, *models.ResponseError) {
query := "SELECT id, label, value_type_id, property_group_id, value_complexity_id, value FROM property_types WHERE property_group_id=$1"
rows, err := rr.dbHandler.Query(query, propertyGroupId)
if err != nil {
return nil, &models.ResponseError{
Message: err.Error(),
Status: http.StatusInternalServerError,
}
}
defer rows.Close()
PropertyTypes := make([]*models.PropertyType, 0)
var idstr, label, value_type_id_str, property_group_id_str, value_complexity_id, value string
var ValueTypeID int
for rows.Next() {
err := rows.Scan(&idstr, &label, &value_type_id_str, &property_group_id_str, &value_complexity_id, &value)
if err != nil {
return nil, &models.ResponseError{
Message: err.Error(),
Status: http.StatusInternalServerError,
}
}
PropertyTypeId, err := strconv.Atoi(idstr)
if err != nil {
return nil, &models.ResponseError{
Message: "PropertyType id not int",
Status: http.StatusInternalServerError,
}
}
PropertyGroupID, err := strconv.Atoi(property_group_id_str)
if err != nil {
return nil, &models.ResponseError{
Message: "PropertyGroup id not int",
Status: http.StatusInternalServerError,
}
}
PropertyType := &models.PropertyType{
ID: PropertyTypeId,
Label: label,
ValueTypeID: ValueTypeID,
ValueComplexityId: value_complexity_id,
Value: value,
PropertyGroupID: PropertyGroupID,
}
PropertyTypes = append(PropertyTypes, PropertyType)
}
if rows.Err() != nil {
return nil, &models.ResponseError{
Message: err.Error(),
Status: http.StatusInternalServerError,
}
}
return PropertyTypes, nil
}
buildtime/server/src/scpq-editor-server/repositories/translationsRepository copy.go → buildtime/server/src/scpq-editor-server/repositories/translationsRepository.go
View File
buildtime/server/src/scpq-editor-server/server/httpServer.go
+11
View File
@@ -30,10 +30,12 @@ func InitHttpServer(config *viper.Viper, dbHandler *sql.DB) HttpServer {
valuetypesRepository := repositories.NewValuetypesRepository(dbHandler)
valuecomplexitiesRepository := repositories.NewValuecomplexitiesRepository(dbHandler)
translationsRepository := repositories.NewTranslationsRepository(dbHandler)
propertytypesRepository := repositories.NewPropertyTypesRepository(dbHandler)
// service initialisation:
languagesService := services.NewLanguagesService(languagesRepository)
propertygroupsService := services.NewPropertygroupsService(propertygroupsRepository)
propertytypesService := services.NewPropertytypesService(propertytypesRepository)
valuetypesService := services.NewValuetypesService(valuetypesRepository)
valuecomplexitiesService := services.NewValuecomplexitiesService(valuecomplexitiesRepository)
translationsService := services.NewTranslationsService(translationsRepository)
@@ -41,6 +43,7 @@ func InitHttpServer(config *viper.Viper, dbHandler *sql.DB) HttpServer {
// controller initialisation:
languageController := controller.NewLanguagesController(languagesService)
propertygroupsController := controller.NewPropertygroupsController(propertygroupsService)
propertytypesController := controller.NewPropertytypesController(propertytypesService)
valuetypesController := controller.NewValuetypesController(valuetypesService)
valuecomplexitiesController := controller.NewValuecomplexitiesController(valuecomplexitiesService)
translationsController := controller.NewTranslationsController(translationsService)
@@ -72,6 +75,14 @@ func InitHttpServer(config *viper.Viper, dbHandler *sql.DB) HttpServer {
router.GET("/translations", translationsController.GetAllTranslations)
router.GET("/translations/:languageId", translationsController.GetAllTranslationsByLanguageId)
// Property-Type centric routing
router.POST("/propertytype", propertytypesController.CreatePropertytype)
router.PUT("/propertytype", propertytypesController.UpdatePropertytype)
router.DELETE("/propertytype/:id", propertytypesController.DeletePropertytype)
router.GET("/propertytype/:id", propertytypesController.GetPropertytype)
router.GET("/propertytypes", propertytypesController.GetAllPropertytypes)
router.GET("/propertytypes/:propertyGroupId", propertytypesController.GetAllPropertytypesByPropertyGroupId)
// valuetype centric routing
router.GET("/valuetype/:id", valuetypesController.GetValuetype)
router.GET("/valuetypes", valuetypesController.GetAllValuetypes)
buildtime/server/src/scpq-editor-server/services/propertytypesService.go
+59
View File
@@ -0,0 +1,59 @@
package services
import (
"net/http"
"scpq-editor-server/models"
"scpq-editor-server/repositories"
)
type PropertytypesService struct {
propertyTypesRepository *repositories.PropertyTypesRepository
}
func NewPropertytypesService(propertyTypesRepository *repositories.PropertyTypesRepository) *PropertytypesService {
return &PropertytypesService{
propertyTypesRepository: propertyTypesRepository,
}
}
func (ls PropertytypesService) CreatePropertyType(propertyType *models.PropertyType) (*models.PropertyType, *models.ResponseError) {
responseErr := validatePropertyType(propertyType)
if responseErr != nil {
return nil, responseErr
}
return ls.propertyTypesRepository.CreatePropertyType(propertyType)
}
func (ls PropertytypesService) UpdatePropertyType(propertyType *models.PropertyType) *models.ResponseError {
responseErr := validatePropertyType(propertyType)
if responseErr != nil {
return responseErr
}
return ls.propertyTypesRepository.UpdatePropertyType(propertyType)
}
func (ls PropertytypesService) DeletePropertyType(propertyTypeId int) *models.ResponseError {
return ls.propertyTypesRepository.DeletePropertyType(propertyTypeId)
}
func (ls PropertytypesService) GetPropertyType(propertyTypeId int) (*models.PropertyType, *models.ResponseError) {
return ls.propertyTypesRepository.GetPropertyType(propertyTypeId)
}
func (ls PropertytypesService) GetAllPropertyTypes() ([]*models.PropertyType, *models.ResponseError) {
return ls.propertyTypesRepository.GetAllPropertyTypes()
}
func (ls PropertytypesService) GetAllPropertyTypesByPropertyGroupId(propertyGroupId int) ([]*models.PropertyType, *models.ResponseError) {
return ls.propertyTypesRepository.GetAllPropertyTypesByPropertyGroupId(propertyGroupId)
}
func validatePropertyType(propertyType *models.PropertyType) *models.ResponseError {
if propertyType.Value == "" {
return &models.ResponseError{
Message: "Invalid PropertyType value",
Status: http.StatusBadRequest,
}
}
return nil
}
buildtime/server/src/scpq-editor-server/services/translationsService copy.go → buildtime/server/src/scpq-editor-server/services/translationsService.go
View File