├── config └── config.go ├── models ├── validator.go ├── filter.go ├── account_store.go ├── project.go ├── models.go ├── string.go ├── role_store.go ├── user_store.go ├── project_store.go ├── item_store.go ├── item_type.go ├── item_type_store.go ├── field_store.go ├── user.go ├── item.go ├── account.go └── role.go ├── gen.sh ├── gen ├── restapi │ ├── doc.go │ └── operations │ │ ├── project │ │ ├── get_projects_parameters.go │ │ ├── get_project.go │ │ ├── get_projects.go │ │ ├── create_project.go │ │ ├── delete_project.go │ │ ├── update_project.go │ │ ├── get_project_parameters.go │ │ ├── delete_project_parameters.go │ │ └── create_project_parameters.go │ │ ├── account │ │ ├── signin.go │ │ ├── signup.go │ │ ├── signin_parameters.go │ │ ├── signup_parameters.go │ │ ├── signin_urlbuilder.go │ │ └── signup_urlbuilder.go │ │ ├── item │ │ ├── get_item.go │ │ ├── get_items.go │ │ ├── create_item.go │ │ ├── update_item.go │ │ └── delete_item.go │ │ ├── role │ │ ├── get_role.go │ │ ├── get_roles.go │ │ ├── create_role.go │ │ ├── update_role.go │ │ ├── delete_role.go │ │ └── get_roles_parameters.go │ │ ├── user │ │ ├── get_user.go │ │ ├── get_users.go │ │ ├── create_user.go │ │ ├── update_user.go │ │ ├── delete_user.go │ │ └── get_users_parameters.go │ │ ├── field │ │ ├── get_field.go │ │ ├── get_fields.go │ │ ├── delete_field.go │ │ ├── update_field.go │ │ ├── create_field.go │ │ └── get_project_fields.go │ │ └── item_type │ │ ├── get_item_type.go │ │ ├── get_item_types.go │ │ ├── create_item_type.go │ │ ├── update_item_type.go │ │ ├── delete_item_type.go │ │ ├── duplicate_item_type.go │ │ └── get_item_types_parameters.go └── models │ ├── item_type_included.go │ ├── items_response_meta.go │ ├── field_attributes_validators_length.go │ ├── project_attributes.go │ ├── item_response.go │ ├── role_response.go │ ├── user_response.go │ ├── signin_o_k_body.go │ ├── field_response.go │ ├── project_response.go │ ├── signup_created_body.go │ ├── item_request.go │ ├── role_request.go │ ├── user_request.go │ ├── field_request.go │ ├── project_request.go │ ├── session_relationships.go │ ├── item_type_request.go │ ├── field_relationships.go │ ├── item_type_response.go │ ├── project_relationships.go │ ├── signin_params_body.go │ ├── signup_params_body.go │ ├── session_relationships_user.go │ ├── user_relationships.go │ ├── field_relationships_item_type.go │ ├── item_relationships_last_editor.go │ ├── project_relationships_account.go │ ├── error.go │ ├── user_relationships_role.go │ ├── roles_response.go │ ├── users_response.go │ ├── fields_response.go │ ├── field_attributes_validators_enum.go │ ├── item_relationships_item_type.go │ ├── projects_response.go │ ├── item_type_relationships_ordering_field.go │ ├── item_type_relationships_singleton_item.go │ ├── item_types_response.go │ ├── item_type_attributes.go │ ├── role_attributes.go │ └── item_type_relationships_fields.go ├── .gitignore ├── api └── handlers │ ├── item_get.go │ ├── project_delete.go │ ├── item_create.go │ ├── role_create.go │ ├── user_create.go │ ├── item_delete.go │ ├── project_get.go │ ├── role_get.go │ ├── user_get.go │ ├── project_update.go │ ├── item_update.go │ ├── role_update.go │ ├── user_update.go │ ├── field_get.go │ ├── role_delete.go │ ├── user_delete.go │ ├── field_update.go │ ├── roles_get.go │ ├── users_get.go │ ├── field_delete.go │ ├── project_create.go │ ├── item_type_create.go │ ├── item_type_delete.go │ ├── projects_get.go │ ├── field_create.go │ ├── item_type_duplicate.go │ ├── item_type_get.go │ ├── fields_get.go │ ├── item_type_update.go │ ├── item_types_get.go │ ├── project_fields_get.go │ ├── items_get.go │ ├── signup.go │ ├── signin.go │ └── helpers.go ├── auth └── jwt.go ├── LICENSE.md ├── cmd └── main.go ├── Gopkg.toml └── README.md /config/config.go: -------------------------------------------------------------------------------- 1 | package config 2 | 3 | type Config struct { 4 | Secret string 5 | } 6 | -------------------------------------------------------------------------------- /models/validator.go: -------------------------------------------------------------------------------- 1 | package models 2 | 3 | type Validator interface { 4 | Validate() error 5 | } 6 | -------------------------------------------------------------------------------- /gen.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | mkdir -p gen 4 | swagger generate server -t gen -f ./swagger/swagger.yml --exclude-main -A cms -------------------------------------------------------------------------------- /models/filter.go: -------------------------------------------------------------------------------- 1 | package models 2 | 3 | type FilterOptions struct { 4 | IDs []uint 5 | TargetID uint 6 | Target string 7 | } 8 | -------------------------------------------------------------------------------- /models/account_store.go: -------------------------------------------------------------------------------- 1 | package models 2 | 3 | import "github.com/jinzhu/gorm" 4 | 5 | type AccountDS interface { 6 | Create(*Account) error 7 | Authenticate(*Account) error 8 | } 9 | 10 | func AccountStore(db *gorm.DB) AccountDS { 11 | return &AccountSQL{ 12 | db: db, 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /models/project.go: -------------------------------------------------------------------------------- 1 | package models 2 | 3 | import "github.com/jinzhu/gorm" 4 | 5 | const ( 6 | ProjectTableName = "projects" 7 | ) 8 | 9 | type Project struct { 10 | gorm.Model 11 | AccountID uint 12 | Name string 13 | } 14 | 15 | func (p *Project) Validate() error { 16 | return nil 17 | } 18 | -------------------------------------------------------------------------------- /models/models.go: -------------------------------------------------------------------------------- 1 | package models 2 | 3 | // Models returns one of every model the database must create 4 | func Models() []interface{} { 5 | return []interface{}{ 6 | &String{}, 7 | &Item{}, 8 | &Field{}, 9 | &ItemType{}, 10 | &User{}, 11 | &Role{}, 12 | &Project{}, 13 | &Account{}, 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /models/string.go: -------------------------------------------------------------------------------- 1 | package models 2 | 3 | import "github.com/jinzhu/gorm" 4 | 5 | const ( 6 | StringTableName = "strings" 7 | ) 8 | 9 | type String struct { 10 | gorm.Model 11 | ItemID uint 12 | FieldID uint 13 | 14 | Value string 15 | } 16 | 17 | func (f *String) Validate() error { 18 | return nil 19 | } 20 | -------------------------------------------------------------------------------- /models/role_store.go: -------------------------------------------------------------------------------- 1 | package models 2 | 3 | import "github.com/jinzhu/gorm" 4 | 5 | type RoleDS interface { 6 | Create(*Role) error 7 | Update(*Role) error 8 | Get(*Role) error 9 | GetList(uint) ([]Role, error) 10 | Delete(*Role) error 11 | } 12 | 13 | func RoleStore(db *gorm.DB) RoleDS { 14 | return &RoleSQL{ 15 | db: db, 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /models/user_store.go: -------------------------------------------------------------------------------- 1 | package models 2 | 3 | import "github.com/jinzhu/gorm" 4 | 5 | type UserDS interface { 6 | Create(*User) error 7 | Update(*User) error 8 | Get(*User) error 9 | GetList(uint) ([]User, error) 10 | Delete(*User) error 11 | } 12 | 13 | func UserStore(db *gorm.DB) UserDS { 14 | return &UserSQL{ 15 | db: db, 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /models/project_store.go: -------------------------------------------------------------------------------- 1 | package models 2 | 3 | import "github.com/jinzhu/gorm" 4 | 5 | type ProjectDS interface { 6 | Create(*Project) error 7 | Update(*Project) error 8 | Get(*Project) error 9 | GetList() ([]Project, error) 10 | Delete(*Project) error 11 | } 12 | 13 | func ProjectStore(db *gorm.DB) ProjectDS { 14 | return &ProjectSQL{ 15 | db: db, 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /gen/restapi/doc.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | /* 4 | Package restapi Headless CMS 5 | 6 | Schemes: 7 | http 8 | Host: 127.0.0.1:8080 9 | BasePath: /api 10 | Version: 1.0.0 11 | 12 | Consumes: 13 | - application/json 14 | 15 | Produces: 16 | - application/json 17 | 18 | swagger:meta 19 | */ 20 | package restapi 21 | -------------------------------------------------------------------------------- /models/item_store.go: -------------------------------------------------------------------------------- 1 | package models 2 | 3 | import "github.com/jinzhu/gorm" 4 | 5 | type ItemDS interface { 6 | Create(*Item) error 7 | Update(*Item) error 8 | GetList(projectID uint, filter ItemFilterOptions) (int, []Item, error) 9 | Get(*Item) error 10 | Delete(*Item) error 11 | } 12 | 13 | func ItemStore(db *gorm.DB) ItemDS { 14 | return &ItemSQL{ 15 | db: db, 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /models/item_type.go: -------------------------------------------------------------------------------- 1 | package models 2 | 3 | import "github.com/jinzhu/gorm" 4 | 5 | const ( 6 | ItemTypeTableName = "item_types" 7 | ) 8 | 9 | type ItemType struct { 10 | gorm.Model 11 | ProjectID uint 12 | Name string `gorm:"primary_key"` 13 | ApiKey string `gorm:"primary_key"` 14 | 15 | Fields []Field 16 | } 17 | 18 | func (t ItemType) Validate() error { 19 | return nil 20 | } 21 | -------------------------------------------------------------------------------- /models/item_type_store.go: -------------------------------------------------------------------------------- 1 | package models 2 | 3 | import "github.com/jinzhu/gorm" 4 | 5 | type ItemTypeDS interface { 6 | Create(*ItemType) error 7 | Update(*ItemType) error 8 | GetList(uint) ([]ItemType, error) 9 | Get(*ItemType) error 10 | Duplicate(*ItemType) error 11 | Delete(*ItemType) error 12 | } 13 | 14 | func ItemTypeStore(db *gorm.DB) ItemTypeDS { 15 | return &ItemTypeSQL{ 16 | db: db, 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Binaries for programs and plugins 2 | *.exe 3 | *.dll 4 | *.so 5 | *.dylib 6 | Builds/ 7 | debug 8 | bin/ 9 | 10 | # Test binary, build with `go test -c` 11 | *.test 12 | 13 | # Output of the go coverage tool, specifically when used with LiteIDE 14 | *.out 15 | 16 | # Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736 17 | .glide/ 18 | .vscode/ 19 | .idea/ 20 | vendor/ 21 | glide.lock -------------------------------------------------------------------------------- /models/field_store.go: -------------------------------------------------------------------------------- 1 | package models 2 | 3 | import "github.com/jinzhu/gorm" 4 | 5 | type FieldDS interface { 6 | Create(*Field) error 7 | Update(*Field) error 8 | GetList(itemTypeID uint, projectID uint) ([]Field, error) 9 | GetListForProject(projectID uint, filter FilterOptions) ([]Field, error) 10 | Get(*Field) error 11 | Delete(*Field) error 12 | } 13 | 14 | func FieldStore(db *gorm.DB) FieldDS { 15 | return &FieldSQL{ 16 | db: db, 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /models/user.go: -------------------------------------------------------------------------------- 1 | package models 2 | 3 | import ( 4 | "github.com/jinzhu/gorm" 5 | "github.com/asaskevich/govalidator" 6 | ) 7 | 8 | const ( 9 | UserTableName = "users" 10 | ) 11 | 12 | type User struct { 13 | gorm.Model 14 | ProjectID uint 15 | RoleID uint 16 | Email string `valid:"email,required"` 17 | State string 18 | 19 | Role Role 20 | } 21 | 22 | func (u *User) Validate() error { 23 | if _, err := govalidator.ValidateStruct(u); err != nil { 24 | return err 25 | } 26 | return nil 27 | } 28 | -------------------------------------------------------------------------------- /models/item.go: -------------------------------------------------------------------------------- 1 | package models 2 | 3 | import ( 4 | "github.com/jinzhu/gorm" 5 | ) 6 | 7 | const ( 8 | ItemTableName = "items" 9 | ) 10 | 11 | type Item struct { 12 | gorm.Model 13 | ItemTypeID uint 14 | ProjectID uint 15 | 16 | ItemType ItemType 17 | 18 | Attributes map[string]interface{} `sql:"-"` 19 | } 20 | 21 | func (f *Item) Validate() error { 22 | return nil 23 | } 24 | 25 | // TODO: - replace with `FilterOptions` 26 | 27 | type ItemFilterOptions struct { 28 | IDs []int 29 | ItemTypeID uint 30 | Offset int 31 | Limit int 32 | // TODO: - support this 33 | Query string 34 | } 35 | -------------------------------------------------------------------------------- /api/handlers/item_get.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/item" 8 | ) 9 | 10 | func MakeGetItemHandler(s cms.Service) item.GetItemHandlerFunc { 11 | return func(params item.GetItemParams) middleware.Responder { 12 | req := ItemWithID(StringToUint(params.ID)) 13 | req.ProjectID = StringToUint(params.ProjectID) 14 | 15 | if err := s.GetItem(req); err != nil { 16 | return item.NewGetItemDefault(400).WithPayload(APIError(err)) 17 | } 18 | 19 | res := &apimodels.ItemResponse{ 20 | Data: ItemToSwag(req), 21 | } 22 | 23 | return item.NewGetItemOK().WithPayload(res) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /api/handlers/project_delete.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/project" 8 | ) 9 | 10 | func MakeDeleteProjectHandler(s cms.Service) project.DeleteProjectHandlerFunc { 11 | return func(params project.DeleteProjectParams) middleware.Responder { 12 | req := ProjectWithID(StringToUint(params.ID)) 13 | 14 | if err := s.DeleteProject(req); err != nil { 15 | return project.NewDeleteProjectDefault(400).WithPayload(APIError(err)) 16 | } 17 | 18 | res := &apimodels.ProjectResponse{ 19 | Data: ProjectToSwag(req), 20 | } 21 | 22 | return project.NewDeleteProjectOK().WithPayload(res) 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /api/handlers/item_create.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/item" 8 | ) 9 | 10 | func MakeCreateItemHandler(s cms.Service) item.CreateItemHandlerFunc { 11 | return func(params item.CreateItemParams) middleware.Responder { 12 | req := SwagToItem(params.Body.Data) 13 | req.ProjectID = StringToUint(params.ProjectID) 14 | 15 | if err := s.CreateItem(req); err != nil { 16 | return item.NewCreateItemDefault(400).WithPayload(APIError(err)) 17 | } 18 | 19 | res := &apimodels.ItemResponse{ 20 | Data: ItemToSwag(req), 21 | } 22 | 23 | return item.NewCreateItemCreated().WithPayload(res) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /api/handlers/role_create.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/role" 8 | ) 9 | 10 | func MakeCreateRoleHandler(s cms.Service) role.CreateRoleHandlerFunc { 11 | return func(params role.CreateRoleParams) middleware.Responder { 12 | req := SwagToRole(params.Body.Data) 13 | req.ProjectID = StringToUint(params.ProjectID) 14 | 15 | if err := s.CreateRole(req); err != nil { 16 | return role.NewCreateRoleDefault(400).WithPayload(APIError(err)) 17 | } 18 | 19 | res := &apimodels.RoleResponse{ 20 | Data: RoleToSwag(req), 21 | } 22 | 23 | return role.NewCreateRoleCreated().WithPayload(res) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /api/handlers/user_create.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/user" 8 | ) 9 | 10 | func MakeCreateUserHandler(s cms.Service) user.CreateUserHandlerFunc { 11 | return func(params user.CreateUserParams) middleware.Responder { 12 | req := SwagToUser(params.Body.Data) 13 | req.ProjectID = StringToUint(params.ProjectID) 14 | 15 | if err := s.CreateUser(req); err != nil { 16 | return user.NewCreateUserDefault(400).WithPayload(APIError(err)) 17 | } 18 | 19 | res := &apimodels.UserResponse{ 20 | Data: UserToSwag(req), 21 | } 22 | 23 | return user.NewCreateUserCreated().WithPayload(res) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /api/handlers/item_delete.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/item" 8 | ) 9 | 10 | func MakeDeleteItemHandler(s cms.Service) item.DeleteItemHandlerFunc { 11 | return func(params item.DeleteItemParams) middleware.Responder { 12 | req := ItemWithID(StringToUint(params.ID)) 13 | req.ProjectID = StringToUint(params.ProjectID) 14 | 15 | if err := s.DeleteItem(req); err != nil { 16 | return item.NewDeleteItemDefault(400).WithPayload(APIError(err)) 17 | } 18 | 19 | res := &apimodels.ItemResponse{ 20 | Data: ItemToSwag(req), 21 | } 22 | 23 | return item.NewDeleteItemOK().WithPayload(res) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /api/handlers/project_get.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/project" 8 | ) 9 | 10 | func MakeGetProjectHandler(s cms.Service) project.GetProjectHandlerFunc { 11 | return func(params project.GetProjectParams) middleware.Responder { 12 | req := ProjectWithID(StringToUint(params.ID)) 13 | // TODO: - return only the user's projects 14 | 15 | if err := s.GetProject(req); err != nil { 16 | return project.NewGetProjectDefault(400).WithPayload(APIError(err)) 17 | } 18 | 19 | res := &apimodels.ProjectResponse{ 20 | Data: ProjectToSwag(req), 21 | } 22 | 23 | return project.NewGetProjectOK().WithPayload(res) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /api/handlers/role_get.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/role" 8 | ) 9 | 10 | func MakeGetRoleHandler(s cms.Service) role.GetRoleHandlerFunc { 11 | return func(params role.GetRoleParams) middleware.Responder { 12 | req := RoleWithID(StringToUint(params.ID)) 13 | req.ID = StringToUint(params.ID) 14 | req.ProjectID = StringToUint(params.ProjectID) 15 | 16 | if err := s.GetRole(req); err != nil { 17 | return role.NewGetRoleDefault(400).WithPayload(APIError(err)) 18 | } 19 | 20 | res := &apimodels.RoleResponse{ 21 | Data: RoleToSwag(req), 22 | } 23 | 24 | return role.NewGetRoleOK().WithPayload(res) 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /api/handlers/user_get.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/user" 8 | ) 9 | 10 | func MakeGetUserHandler(s cms.Service) user.GetUserHandlerFunc { 11 | return func(params user.GetUserParams) middleware.Responder { 12 | req := UserWithID(StringToUint(params.ID)) 13 | req.ID = StringToUint(params.ID) 14 | req.ProjectID = StringToUint(params.ProjectID) 15 | 16 | if err := s.GetUser(req); err != nil { 17 | return user.NewGetUserDefault(400).WithPayload(APIError(err)) 18 | } 19 | 20 | res := &apimodels.UserResponse{ 21 | Data: UserToSwag(req), 22 | } 23 | 24 | return user.NewGetUserOK().WithPayload(res) 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /api/handlers/project_update.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/project" 8 | ) 9 | 10 | func MakeUpdateProjectHandler(s cms.Service) project.UpdateProjectHandlerFunc { 11 | return func(params project.UpdateProjectParams) middleware.Responder { 12 | req := SwagToProject(params.Body.Data) 13 | req.ID = StringToUint(params.ID) 14 | 15 | if err := s.UpdateProject(req); err != nil { 16 | return project.NewUpdateProjectDefault(400).WithPayload(APIError(err)) 17 | } 18 | 19 | res := &apimodels.ProjectResponse{ 20 | Data: ProjectToSwag(req), 21 | } 22 | 23 | return project.NewUpdateProjectOK().WithPayload(res) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /api/handlers/item_update.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/item" 8 | ) 9 | 10 | func MakeUpdateItemHandler(s cms.Service) item.UpdateItemHandlerFunc { 11 | return func(params item.UpdateItemParams) middleware.Responder { 12 | req := SwagToItem(params.Body.Data) 13 | req.ID = StringToUint(params.ID) 14 | req.ProjectID = StringToUint(params.ProjectID) 15 | 16 | if err := s.UpdateItem(req); err != nil { 17 | return item.NewUpdateItemDefault(400).WithPayload(APIError(err)) 18 | } 19 | 20 | res := &apimodels.ItemResponse{ 21 | Data: ItemToSwag(req), 22 | } 23 | 24 | return item.NewUpdateItemOK().WithPayload(res) 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /api/handlers/role_update.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/role" 8 | ) 9 | 10 | func MakeUpdateRoleHandler(s cms.Service) role.UpdateRoleHandlerFunc { 11 | return func(params role.UpdateRoleParams) middleware.Responder { 12 | req := SwagToRole(params.Body.Data) 13 | req.ID = StringToUint(params.ID) 14 | req.ProjectID = StringToUint(params.ProjectID) 15 | 16 | if err := s.UpdateRole(req); err != nil { 17 | return role.NewUpdateRoleDefault(400).WithPayload(APIError(err)) 18 | } 19 | 20 | res := &apimodels.RoleResponse{ 21 | Data: RoleToSwag(req), 22 | } 23 | 24 | return role.NewUpdateRoleOK().WithPayload(res) 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /api/handlers/user_update.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/user" 8 | ) 9 | 10 | func MakeUpdateUserHandler(s cms.Service) user.UpdateUserHandlerFunc { 11 | return func(params user.UpdateUserParams) middleware.Responder { 12 | req := SwagToUser(params.Body.Data) 13 | req.ID = StringToUint(params.ID) 14 | req.ProjectID = StringToUint(params.ProjectID) 15 | 16 | if err := s.UpdateUser(req); err != nil { 17 | return user.NewUpdateUserDefault(400).WithPayload(APIError(err)) 18 | } 19 | 20 | res := &apimodels.UserResponse{ 21 | Data: UserToSwag(req), 22 | } 23 | 24 | return user.NewUpdateUserOK().WithPayload(res) 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /api/handlers/field_get.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/field" 8 | ) 9 | 10 | func MakeGetFieldHandler(s cms.Service) field.GetFieldHandlerFunc { 11 | return func(params field.GetFieldParams) middleware.Responder { 12 | req := FieldWithID(StringToUint(params.ID)) 13 | req.ID = StringToUint(params.ID) 14 | req.ProjectID = StringToUint(params.ProjectID) 15 | 16 | if err := s.GetField(req); err != nil { 17 | return field.NewGetFieldDefault(400).WithPayload(APIError(err)) 18 | } 19 | 20 | res := &apimodels.FieldResponse{ 21 | Data: FieldToSwag(req), 22 | } 23 | 24 | return field.NewGetFieldOK().WithPayload(res) 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /api/handlers/role_delete.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/role" 8 | ) 9 | 10 | func MakeDeleteRoleHandler(s cms.Service) role.DeleteRoleHandlerFunc { 11 | return func(params role.DeleteRoleParams) middleware.Responder { 12 | req := RoleWithID(StringToUint(params.ID)) 13 | req.ID = StringToUint(params.ID) 14 | req.ProjectID = StringToUint(params.ProjectID) 15 | 16 | if err := s.DeleteRole(req); err != nil { 17 | return role.NewDeleteRoleDefault(400).WithPayload(APIError(err)) 18 | } 19 | 20 | res := &apimodels.RoleResponse{ 21 | Data: RoleToSwag(req), 22 | } 23 | 24 | return role.NewDeleteRoleOK().WithPayload(res) 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /api/handlers/user_delete.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/user" 8 | ) 9 | 10 | func MakeDeleteUserHandler(s cms.Service) user.DeleteUserHandlerFunc { 11 | return func(params user.DeleteUserParams) middleware.Responder { 12 | req := UserWithID(StringToUint(params.ID)) 13 | req.ID = StringToUint(params.ID) 14 | req.ProjectID = StringToUint(params.ProjectID) 15 | 16 | if err := s.DeleteUser(req); err != nil { 17 | return user.NewDeleteUserDefault(400).WithPayload(APIError(err)) 18 | } 19 | 20 | res := &apimodels.UserResponse{ 21 | Data: UserToSwag(req), 22 | } 23 | 24 | return user.NewDeleteUserOK().WithPayload(res) 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /api/handlers/field_update.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/field" 8 | ) 9 | 10 | func MakeUpdateFieldHandler(s cms.Service) field.UpdateFieldHandlerFunc { 11 | return func(params field.UpdateFieldParams) middleware.Responder { 12 | req := SwagToField(params.Body.Data) 13 | req.ID = StringToUint(params.ID) 14 | req.ProjectID = StringToUint(params.ProjectID) 15 | 16 | if err := s.UpdateField(req); err != nil { 17 | return field.NewUpdateFieldDefault(400).WithPayload(APIError(err)) 18 | } 19 | 20 | res := &apimodels.FieldResponse{ 21 | Data: FieldToSwag(req), 22 | } 23 | 24 | return field.NewUpdateFieldOK().WithPayload(res) 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /api/handlers/roles_get.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/role" 8 | ) 9 | 10 | func MakeGetRolesHandler(s cms.Service) role.GetRolesHandlerFunc { 11 | return func(params role.GetRolesParams) middleware.Responder { 12 | items, err := s.GetRoleList(StringToUint(params.ProjectID)) 13 | if err != nil { 14 | return role.NewGetRolesDefault(400).WithPayload(APIError(err)) 15 | } 16 | 17 | data := make([]*apimodels.Role, 0) 18 | for _, item := range items { 19 | data = append(data, RoleToSwag(&item)) 20 | } 21 | 22 | res := &apimodels.RolesResponse{ 23 | Data: data, 24 | } 25 | 26 | return role.NewGetRolesOK().WithPayload(res) 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /api/handlers/users_get.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/user" 8 | ) 9 | 10 | func MakeGetUsersHandler(s cms.Service) user.GetUsersHandlerFunc { 11 | return func(params user.GetUsersParams) middleware.Responder { 12 | items, err := s.GetUserList(StringToUint(params.ProjectID)) 13 | if err != nil { 14 | return user.NewGetUsersDefault(400).WithPayload(APIError(err)) 15 | } 16 | 17 | data := make([]*apimodels.User, 0) 18 | for _, item := range items { 19 | data = append(data, UserToSwag(&item)) 20 | } 21 | 22 | res := &apimodels.UsersResponse{ 23 | Data: data, 24 | } 25 | 26 | return user.NewGetUsersOK().WithPayload(res) 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /api/handlers/field_delete.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/field" 8 | ) 9 | 10 | func MakeDeleteFieldHandler(s cms.Service) field.DeleteFieldHandlerFunc { 11 | return func(params field.DeleteFieldParams) middleware.Responder { 12 | req := FieldWithID(StringToUint(params.ID)) 13 | req.ID = StringToUint(params.ID) 14 | req.ProjectID = StringToUint(params.ProjectID) 15 | 16 | if err := s.DeleteField(req); err != nil { 17 | return field.NewDeleteFieldDefault(400).WithPayload(APIError(err)) 18 | } 19 | 20 | res := &apimodels.FieldResponse{ 21 | Data: FieldToSwag(req), 22 | } 23 | 24 | return field.NewDeleteFieldOK().WithPayload(res) 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /api/handlers/project_create.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/project" 8 | ) 9 | 10 | func MakeCreateProjectHandler(s cms.Service) project.CreateProjectHandlerFunc { 11 | return func(params project.CreateProjectParams) middleware.Responder { 12 | req := SwagToProject(params.Body.Data) 13 | // TODO: - get account id from token 14 | req.AccountID = 1 15 | 16 | if err := s.CreateProject(req); err != nil { 17 | return project.NewCreateProjectDefault(400).WithPayload(APIError(err)) 18 | } 19 | 20 | res := &apimodels.ProjectResponse{ 21 | Data: ProjectToSwag(req), 22 | } 23 | 24 | return project.NewCreateProjectCreated().WithPayload(res) 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /models/account.go: -------------------------------------------------------------------------------- 1 | package models 2 | 3 | import ( 4 | "github.com/jinzhu/gorm" 5 | "golang.org/x/crypto/bcrypt" 6 | "github.com/asaskevich/govalidator" 7 | ) 8 | 9 | const ( 10 | AccountTableName = "accounts" 11 | ) 12 | 13 | type Account struct { 14 | gorm.Model 15 | Email string `gorm:"unique_index" valid:"email,required"` 16 | Password string `valid:"length(8|32),matches(^[a-zA-Z0-9]+$),required"` 17 | } 18 | 19 | // hashPassword hashes the password for the given user 20 | func hashPassword(password string) (string, error) { 21 | hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost) 22 | if err != nil { 23 | return "", err 24 | } 25 | 26 | return string(hash), nil 27 | } 28 | 29 | func (a *Account) Validate() error { 30 | if _, err := govalidator.ValidateStruct(a); err != nil { 31 | return err 32 | } 33 | return nil 34 | } 35 | -------------------------------------------------------------------------------- /api/handlers/item_type_create.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/item_type" 8 | ) 9 | 10 | func MakeCreateItemTypeHandler(s cms.Service) item_type.CreateItemTypeHandlerFunc { 11 | return func(params item_type.CreateItemTypeParams) middleware.Responder { 12 | req := SwagToItemType(params.Body.Data) 13 | req.ProjectID = StringToUint(params.ProjectID) 14 | 15 | if err := s.CreateItemType(req); err != nil { 16 | return item_type.NewCreateItemTypeDefault(400).WithPayload(APIError(err)) 17 | } 18 | 19 | res := &apimodels.ItemTypeResponse{ 20 | Data: ItemTypeToSwag(req), 21 | } 22 | 23 | return item_type.NewCreateItemTypeCreated().WithPayload(res) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /api/handlers/item_type_delete.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/item_type" 8 | ) 9 | 10 | func MakeDeleteItemTypeHandler(s cms.Service) item_type.DeleteItemTypeHandlerFunc { 11 | return func(params item_type.DeleteItemTypeParams) middleware.Responder { 12 | req := ItemTypeWithID(StringToUint(params.ID)) 13 | req.ProjectID = StringToUint(params.ProjectID) 14 | 15 | if err := s.DeleteItemType(req); err != nil { 16 | return item_type.NewDeleteItemTypeDefault(400).WithPayload(APIError(err)) 17 | } 18 | 19 | res := &apimodels.ItemTypeResponse{ 20 | Data: ItemTypeToSwag(req), 21 | } 22 | 23 | return item_type.NewDeleteItemTypeOK().WithPayload(res) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /api/handlers/projects_get.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/project" 8 | ) 9 | 10 | func MakeGetProjectsHandler(s cms.Service) project.GetProjectsHandlerFunc { 11 | return func(params project.GetProjectsParams) middleware.Responder { 12 | items, err := s.GetProjectList() 13 | if err != nil { 14 | return project.NewGetProjectsDefault(400).WithPayload(APIError(err)) 15 | } 16 | 17 | data := make([]*apimodels.Project, 0) 18 | for _, item := range items { 19 | data = append(data, ProjectToSwag(&item)) 20 | } 21 | 22 | res := &apimodels.ProjectsResponse{ 23 | Data: data, 24 | } 25 | 26 | return project.NewGetProjectsOK().WithPayload(res) 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /api/handlers/field_create.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/field" 8 | ) 9 | 10 | func MakeCreateFieldHandler(s cms.Service) field.CreateFieldHandlerFunc { 11 | return func(params field.CreateFieldParams) middleware.Responder { 12 | req := SwagToField(params.Body.Data) 13 | req.ProjectID = StringToUint(params.ProjectID) 14 | req.ItemTypeID = StringToUint(params.ItemTypeID) 15 | 16 | if err := s.CreateField(req); err != nil { 17 | return field.NewCreateFieldDefault(400).WithPayload(APIError(err)) 18 | } 19 | 20 | res := &apimodels.FieldResponse{ 21 | Data: FieldToSwag(req), 22 | } 23 | 24 | return field.NewCreateFieldCreated().WithPayload(res) 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /api/handlers/item_type_duplicate.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/item_type" 8 | ) 9 | 10 | func MakeDuplicateItemTypeHandler(s cms.Service) item_type.DuplicateItemTypeHandlerFunc { 11 | return func(params item_type.DuplicateItemTypeParams) middleware.Responder { 12 | req := ItemTypeWithID(StringToUint(params.ID)) 13 | req.ProjectID = StringToUint(params.ProjectID) 14 | 15 | if err := s.DuplicateItemType(req); err != nil { 16 | return item_type.NewDuplicateItemTypeDefault(400).WithPayload(APIError(err)) 17 | } 18 | 19 | res := &apimodels.ItemTypeResponse{ 20 | Data: ItemTypeToSwag(req), 21 | } 22 | 23 | return item_type.NewDuplicateItemTypeOK().WithPayload(res) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /api/handlers/item_type_get.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/item_type" 8 | ) 9 | 10 | func MakeGetItemTypeHandler(s cms.Service) item_type.GetItemTypeHandlerFunc { 11 | return func(params item_type.GetItemTypeParams) middleware.Responder { 12 | req := ItemTypeWithID(StringToUint(params.ID)) 13 | req.ProjectID = StringToUint(params.ProjectID) 14 | 15 | if err := s.GetItemType(req); err != nil { 16 | return item_type.NewGetItemTypeDefault(400).WithPayload(APIError(err)) 17 | } 18 | 19 | res := &apimodels.ItemTypeResponse{ 20 | Data: ItemTypeToSwag(req), 21 | Included: ItemTypeIncluded(req), 22 | } 23 | 24 | return item_type.NewGetItemTypeOK().WithPayload(res) 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /auth/jwt.go: -------------------------------------------------------------------------------- 1 | package auth 2 | 3 | import ( 4 | "github.com/auth0/go-jwt-middleware" 5 | "github.com/dgrijalva/jwt-go" 6 | ) 7 | 8 | const ( 9 | AuthParameter = "key" 10 | ) 11 | 12 | // CreateToken creates a token with the given claims 13 | func CreateToken(claims jwt.MapClaims, secret string) (string, error) { 14 | token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims) 15 | 16 | return token.SignedString([]byte(secret)) 17 | } 18 | 19 | func Middleware(secret string) *jwtmiddleware.JWTMiddleware { 20 | jwtMiddleware := jwtmiddleware.New(jwtmiddleware.Options{ 21 | ValidationKeyGetter: func(token *jwt.Token) (interface{}, error) { 22 | return []byte(secret), nil 23 | }, 24 | SigningMethod: jwt.SigningMethodHS256, 25 | Extractor: jwtmiddleware.FromFirst(jwtmiddleware.FromAuthHeader, jwtmiddleware.FromParameter(AuthParameter)), 26 | }) 27 | 28 | return jwtMiddleware 29 | } 30 | -------------------------------------------------------------------------------- /api/handlers/fields_get.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/field" 8 | ) 9 | 10 | func MakeGetFieldsHandler(s cms.Service) field.GetFieldsHandlerFunc { 11 | return func(params field.GetFieldsParams) middleware.Responder { 12 | items, err := s.GetFieldList(StringToUint(params.ItemTypeID), StringToUint(params.ProjectID)) 13 | if err != nil { 14 | return field.NewGetFieldsDefault(400).WithPayload(APIError(err)) 15 | } 16 | 17 | data := make([]*apimodels.Field, 0) 18 | for _, item := range items { 19 | data = append(data, FieldToSwag(&item)) 20 | } 21 | 22 | res := &apimodels.FieldsResponse{ 23 | Data: data, 24 | } 25 | 26 | return field.NewGetFieldsOK().WithPayload(res) 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /api/handlers/item_type_update.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/item_type" 8 | ) 9 | 10 | func MakeUpdateItemTypeHandler(s cms.Service) item_type.UpdateItemTypeHandlerFunc { 11 | return func(params item_type.UpdateItemTypeParams) middleware.Responder { 12 | req := SwagToItemType(params.Body.Data) 13 | req.ID = StringToUint(params.ID) 14 | req.ProjectID = StringToUint(params.ProjectID) 15 | 16 | if err := s.UpdateItemType(req); err != nil { 17 | return item_type.NewUpdateItemTypeDefault(400).WithPayload(APIError(err)) 18 | } 19 | 20 | res := &apimodels.ItemTypeResponse{ 21 | Data: ItemTypeToSwag(req), 22 | } 23 | 24 | return item_type.NewUpdateItemTypeOK().WithPayload(res) 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /api/handlers/item_types_get.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/item_type" 8 | ) 9 | 10 | func MakeGetItemTypesHandler(s cms.Service) item_type.GetItemTypesHandlerFunc { 11 | return func(params item_type.GetItemTypesParams) middleware.Responder { 12 | items, err := s.GetItemTypeList(StringToUint(params.ProjectID)) 13 | if err != nil { 14 | return item_type.NewGetItemTypesDefault(400).WithPayload(APIError(err)) 15 | } 16 | 17 | data := make([]*apimodels.ItemType, 0) 18 | for _, item := range items { 19 | data = append(data, ItemTypeToSwag(&item)) 20 | } 21 | 22 | res := &apimodels.ItemTypesResponse{ 23 | Data: data, 24 | } 25 | 26 | return item_type.NewGetItemTypesOK().WithPayload(res) 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /api/handlers/project_fields_get.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/field" 8 | ) 9 | 10 | func MakeGetProjectFieldsHandler(s cms.Service) field.GetProjectFieldsHandlerFunc { 11 | return func(params field.GetProjectFieldsParams) middleware.Responder { 12 | items, err := s.GetProjectFieldList(StringToUint(params.ProjectID), SwagToFieldFilter(params)) 13 | if err != nil { 14 | return field.NewGetProjectFieldsDefault(400).WithPayload(APIError(err)) 15 | } 16 | 17 | data := make([]*apimodels.Field, 0) 18 | for _, item := range items { 19 | data = append(data, FieldToSwag(&item)) 20 | } 21 | 22 | res := &apimodels.FieldsResponse{ 23 | Data: data, 24 | } 25 | 26 | return field.NewGetProjectFieldsOK().WithPayload(res) 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /api/handlers/items_get.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | apimodels "github.com/Xzya/headless-cms/gen/models" 6 | "github.com/go-openapi/runtime/middleware" 7 | "github.com/Xzya/headless-cms/gen/restapi/operations/item" 8 | ) 9 | 10 | func MakeGetItemsHandler(s cms.Service) item.GetItemsHandlerFunc { 11 | return func(params item.GetItemsParams) middleware.Responder { 12 | count, items, err := s.GetItemList(StringToUint(params.ProjectID), SwagToItemFilter(params)) 13 | if err != nil { 14 | return item.NewGetItemsDefault(400).WithPayload(APIError(err)) 15 | } 16 | 17 | data := make([]*apimodels.Item, 0) 18 | for _, item := range items { 19 | data = append(data, ItemToSwag(&item)) 20 | } 21 | 22 | res := &apimodels.ItemsResponse{ 23 | Data: data, 24 | Meta: &apimodels.ItemsResponseMeta{ 25 | TotalCount: int32(count), 26 | }, 27 | } 28 | 29 | return item.NewGetItemsOK().WithPayload(res) 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /models/role.go: -------------------------------------------------------------------------------- 1 | package models 2 | 3 | import "github.com/jinzhu/gorm" 4 | 5 | const ( 6 | RoleTableName = "roles" 7 | ) 8 | 9 | var ( 10 | DefaultAdminRole = Role{ 11 | Name: "Admin", 12 | CanEditProject: true, 13 | CanEditSchema: true, 14 | CanManageUsers: true, 15 | CanManageAccessTokens: true, 16 | CanPublishContent: true, 17 | } 18 | DefaultEditorRole = Role{ 19 | Name: "Editor", 20 | CanEditProject: false, 21 | CanEditSchema: false, 22 | CanManageUsers: false, 23 | CanManageAccessTokens: false, 24 | CanPublishContent: true, 25 | } 26 | ) 27 | 28 | type Role struct { 29 | gorm.Model 30 | ProjectID uint 31 | Name string 32 | CanEditProject bool 33 | CanEditSchema bool 34 | CanManageUsers bool 35 | CanManageAccessTokens bool 36 | CanPublishContent bool 37 | } 38 | 39 | func (r *Role) Validate() error { 40 | return nil 41 | } 42 | -------------------------------------------------------------------------------- /LICENSE.md: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2018 Mihail Cristian Dumitru 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of 6 | this software and associated documentation files (the "Software"), to deal in 7 | the Software without restriction, including without limitation the rights to 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of 9 | the Software, and to permit persons to whom the Software is furnished to do so, 10 | subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 | -------------------------------------------------------------------------------- /gen/models/item_type_included.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | "strconv" 10 | 11 | strfmt "github.com/go-openapi/strfmt" 12 | 13 | "github.com/go-openapi/errors" 14 | "github.com/go-openapi/swag" 15 | ) 16 | 17 | // ItemTypeIncluded item type included 18 | // swagger:model ItemTypeIncluded 19 | type ItemTypeIncluded []*Field 20 | 21 | // Validate validates this item type included 22 | func (m ItemTypeIncluded) Validate(formats strfmt.Registry) error { 23 | var res []error 24 | 25 | for i := 0; i < len(m); i++ { 26 | 27 | if swag.IsZero(m[i]) { // not required 28 | continue 29 | } 30 | 31 | if m[i] != nil { 32 | 33 | if err := m[i].Validate(formats); err != nil { 34 | if ve, ok := err.(*errors.Validation); ok { 35 | return ve.ValidateName(strconv.Itoa(i)) 36 | } 37 | return err 38 | } 39 | 40 | } 41 | 42 | } 43 | 44 | if len(res) > 0 { 45 | return errors.CompositeValidationError(res...) 46 | } 47 | return nil 48 | } 49 | -------------------------------------------------------------------------------- /api/handlers/signup.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | "github.com/Xzya/headless-cms/models" 6 | apimodels "github.com/Xzya/headless-cms/gen/models" 7 | "github.com/go-openapi/runtime/middleware" 8 | "github.com/Xzya/headless-cms/gen/restapi/operations/account" 9 | ) 10 | 11 | func MakeCreateAccountHandler(s cms.Service) account.SignupHandlerFunc { 12 | return func(params account.SignupParams) middleware.Responder { 13 | acc := &models.Account{ 14 | Email: params.Body.Data.Attributes.Email.String(), 15 | Password: params.Body.Data.Attributes.Password.String(), 16 | } 17 | 18 | token, err := s.CreateAccount(acc) 19 | if err != nil { 20 | return account.NewSignupDefault(400).WithPayload(APIError(err)) 21 | } 22 | 23 | res := &apimodels.SignupCreatedBody{ 24 | Data: &apimodels.Session{ 25 | ID: token, 26 | Type: apimodels.SessionTypeSession, 27 | Relationships: &apimodels.SessionRelationships{ 28 | User: &apimodels.SessionRelationshipsUser{ 29 | Data: AccountToRel(acc), 30 | }, 31 | }, 32 | }, 33 | } 34 | 35 | return account.NewSignupCreated().WithPayload(res) 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /api/handlers/signin.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | "github.com/Xzya/headless-cms" 5 | "github.com/Xzya/headless-cms/models" 6 | apimodels "github.com/Xzya/headless-cms/gen/models" 7 | "github.com/go-openapi/runtime/middleware" 8 | "github.com/Xzya/headless-cms/gen/restapi/operations/account" 9 | ) 10 | 11 | func MakeAuthenticateAccountHandler(s cms.Service) account.SigninHandlerFunc { 12 | return func(params account.SigninParams) middleware.Responder { 13 | acc := &models.Account{ 14 | Email: params.Body.Data.Attributes.Email.String(), 15 | Password: params.Body.Data.Attributes.Password.String(), 16 | } 17 | 18 | token, err := s.AuthenticateAccount(acc) 19 | if err != nil { 20 | return account.NewSigninDefault(400).WithPayload(APIError(err)) 21 | } 22 | 23 | res := &apimodels.SigninOKBody{ 24 | Data: &apimodels.Session{ 25 | ID: token, 26 | Type: apimodels.SessionTypeSession, 27 | Relationships: &apimodels.SessionRelationships{ 28 | User: &apimodels.SessionRelationshipsUser{ 29 | Data: AccountToRel(acc), 30 | }, 31 | }, 32 | }, 33 | } 34 | 35 | return account.NewSigninOK().WithPayload(res) 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /api/handlers/helpers.go: -------------------------------------------------------------------------------- 1 | package handlers 2 | 3 | import ( 4 | apimodels "github.com/Xzya/headless-cms/gen/models" 5 | "google.golang.org/grpc/codes" 6 | "google.golang.org/grpc/status" 7 | "strconv" 8 | "fmt" 9 | "github.com/go-openapi/swag" 10 | ) 11 | 12 | func StringToUint(s string) uint { 13 | n, _ := strconv.ParseUint(s, 10, 64) 14 | return uint(n) 15 | } 16 | 17 | func UintToString(n uint) string { 18 | return fmt.Sprintf("%v", n) 19 | } 20 | 21 | func StringPtrToInt32Ptr(s *string) *int32 { 22 | if n, err := swag.ConvertInt32(swag.StringValue(s)); err == nil { 23 | return &n 24 | } 25 | return nil 26 | } 27 | 28 | func Int32PtrToStringPtr(n *int32) *string { 29 | if n != nil { 30 | return swag.String(fmt.Sprintf("%v", *n)) 31 | } 32 | return nil 33 | } 34 | 35 | func StringValueIfNotEmpty(s *string) *string { 36 | if s != nil { 37 | if len(*s) != 0 { 38 | return s 39 | } 40 | } 41 | return nil 42 | } 43 | 44 | func APIError(err error) *apimodels.Error { 45 | if err != nil { 46 | s, ok := status.FromError(err) 47 | if ok { 48 | return &apimodels.Error{ 49 | Code: int32(s.Code()), 50 | Error: s.Message(), 51 | } 52 | } 53 | } 54 | return &apimodels.Error{ 55 | Code: int32(codes.Unknown), 56 | Error: err.Error(), 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /gen/models/items_response_meta.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | ) 14 | 15 | // ItemsResponseMeta items response meta 16 | // swagger:model ItemsResponseMeta 17 | type ItemsResponseMeta struct { 18 | 19 | // total count 20 | TotalCount int32 `json:"totalCount,omitempty"` 21 | } 22 | 23 | // Validate validates this items response meta 24 | func (m *ItemsResponseMeta) Validate(formats strfmt.Registry) error { 25 | var res []error 26 | 27 | if len(res) > 0 { 28 | return errors.CompositeValidationError(res...) 29 | } 30 | return nil 31 | } 32 | 33 | // MarshalBinary interface implementation 34 | func (m *ItemsResponseMeta) MarshalBinary() ([]byte, error) { 35 | if m == nil { 36 | return nil, nil 37 | } 38 | return swag.WriteJSON(m) 39 | } 40 | 41 | // UnmarshalBinary interface implementation 42 | func (m *ItemsResponseMeta) UnmarshalBinary(b []byte) error { 43 | var res ItemsResponseMeta 44 | if err := swag.ReadJSON(b, &res); err != nil { 45 | return err 46 | } 47 | *m = res 48 | return nil 49 | } 50 | -------------------------------------------------------------------------------- /cmd/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "flag" 5 | "log" 6 | "github.com/Xzya/headless-cms/api" 7 | "github.com/Xzya/headless-cms" 8 | "github.com/Xzya/headless-cms/config" 9 | "fmt" 10 | ) 11 | 12 | var ( 13 | dialect = flag.String("dialect", "postgres", "The database dialect") 14 | databaseHost = flag.String("db-host", "localhost", "The database hostname") 15 | databasePort = flag.String("db-port", "5432", "The database port") 16 | database = flag.String("database", "cms", "The database name") 17 | user = flag.String("user", "test", "The database username") 18 | pass = flag.String("pass", "test", "The database password") 19 | ) 20 | 21 | func main() { 22 | flag.Parse() 23 | 24 | // connect to the database 25 | DB, err := cms.NewDatabase(cms.DatabaseConfig{ 26 | Dialect: *dialect, 27 | Source: fmt.Sprintf( 28 | "host=%s port=%s sslmode=disable dbname=%s user=%s password=%s", 29 | *databaseHost, 30 | *databasePort, 31 | *database, 32 | *user, 33 | *pass, 34 | ), 35 | Debug: true, 36 | }) 37 | defer DB.Close() 38 | if err != nil { 39 | panic(err) 40 | } 41 | 42 | // Business domain. 43 | service := cms.NewService(DB.Debug(), config.Config{ 44 | Secret: "secret", 45 | }) 46 | 47 | if err := api.Start(service); err != nil { 48 | log.Fatalln(err) 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /gen/restapi/operations/project/get_projects_parameters.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package project 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/runtime/middleware" 13 | ) 14 | 15 | // NewGetProjectsParams creates a new GetProjectsParams object 16 | // no default values defined in spec. 17 | func NewGetProjectsParams() GetProjectsParams { 18 | 19 | return GetProjectsParams{} 20 | } 21 | 22 | // GetProjectsParams contains all the bound params for the get projects operation 23 | // typically these are obtained from a http.Request 24 | // 25 | // swagger:parameters getProjects 26 | type GetProjectsParams struct { 27 | 28 | // HTTP Request Object 29 | HTTPRequest *http.Request `json:"-"` 30 | } 31 | 32 | // BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface 33 | // for simple values it will use straight method calls. 34 | // 35 | // To ensure default values, the struct must have been initialized with NewGetProjectsParams() beforehand. 36 | func (o *GetProjectsParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error { 37 | var res []error 38 | 39 | o.HTTPRequest = r 40 | 41 | if len(res) > 0 { 42 | return errors.CompositeValidationError(res...) 43 | } 44 | return nil 45 | } 46 | -------------------------------------------------------------------------------- /gen/models/field_attributes_validators_length.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | ) 14 | 15 | // FieldAttributesValidatorsLength field attributes validators length 16 | // swagger:model fieldAttributesValidatorsLength 17 | type FieldAttributesValidatorsLength struct { 18 | 19 | // eq 20 | Eq *string `json:"eq,omitempty"` 21 | 22 | // max 23 | Max *string `json:"max,omitempty"` 24 | 25 | // min 26 | Min *string `json:"min,omitempty"` 27 | } 28 | 29 | // Validate validates this field attributes validators length 30 | func (m *FieldAttributesValidatorsLength) Validate(formats strfmt.Registry) error { 31 | var res []error 32 | 33 | if len(res) > 0 { 34 | return errors.CompositeValidationError(res...) 35 | } 36 | return nil 37 | } 38 | 39 | // MarshalBinary interface implementation 40 | func (m *FieldAttributesValidatorsLength) MarshalBinary() ([]byte, error) { 41 | if m == nil { 42 | return nil, nil 43 | } 44 | return swag.WriteJSON(m) 45 | } 46 | 47 | // UnmarshalBinary interface implementation 48 | func (m *FieldAttributesValidatorsLength) UnmarshalBinary(b []byte) error { 49 | var res FieldAttributesValidatorsLength 50 | if err := swag.ReadJSON(b, &res); err != nil { 51 | return err 52 | } 53 | *m = res 54 | return nil 55 | } 56 | -------------------------------------------------------------------------------- /Gopkg.toml: -------------------------------------------------------------------------------- 1 | 2 | # Gopkg.toml example 3 | # 4 | # Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md 5 | # for detailed Gopkg.toml documentation. 6 | # 7 | # required = ["github.com/user/thing/cmd/thing"] 8 | # ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"] 9 | # 10 | # [[constraint]] 11 | # name = "github.com/user/project" 12 | # version = "1.0.0" 13 | # 14 | # [[constraint]] 15 | # name = "github.com/user/project2" 16 | # branch = "dev" 17 | # source = "github.com/myfork/project2" 18 | # 19 | # [[override]] 20 | # name = "github.com/x/y" 21 | # version = "2.4.0" 22 | 23 | 24 | [[constraint]] 25 | name = "github.com/jinzhu/gorm" 26 | version = "1.0.0" 27 | 28 | [[constraint]] 29 | name = "github.com/go-kit/kit" 30 | revision = "9ed37433947b357910facd0e38a8ec110fda62c1" 31 | 32 | [[constraint]] 33 | name = "github.com/grpc-ecosystem/grpc-gateway" 34 | version = "1.2.2" 35 | 36 | [[constraint]] 37 | name = "google.golang.org/grpc" 38 | version = "~1.4.2" 39 | 40 | [[constraint]] 41 | name = "github.com/gorilla/mux" 42 | version = "~1.4.0" 43 | 44 | [[constraint]] 45 | name = "github.com/golang/protobuf" 46 | 47 | [[constraint]] 48 | name = "golang.org/x/net" 49 | 50 | [[constraint]] 51 | name = "github.com/gorilla/handlers" 52 | version = "1.2.1" 53 | 54 | [[constraint]] 55 | branch = "master" 56 | name = "github.com/auth0/go-jwt-middleware" 57 | 58 | [[constraint]] 59 | branch = "master" 60 | name = "golang.org/x/crypto" 61 | 62 | [[constraint]] 63 | name = "github.com/asaskevich/govalidator" 64 | version = "7.0.0" 65 | -------------------------------------------------------------------------------- /gen/models/project_attributes.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | "github.com/go-openapi/validate" 14 | ) 15 | 16 | // ProjectAttributes project attributes 17 | // swagger:model projectAttributes 18 | type ProjectAttributes struct { 19 | 20 | // name 21 | // Required: true 22 | Name string `json:"name"` 23 | } 24 | 25 | // Validate validates this project attributes 26 | func (m *ProjectAttributes) Validate(formats strfmt.Registry) error { 27 | var res []error 28 | 29 | if err := m.validateName(formats); err != nil { 30 | // prop 31 | res = append(res, err) 32 | } 33 | 34 | if len(res) > 0 { 35 | return errors.CompositeValidationError(res...) 36 | } 37 | return nil 38 | } 39 | 40 | func (m *ProjectAttributes) validateName(formats strfmt.Registry) error { 41 | 42 | if err := validate.RequiredString("name", "body", string(m.Name)); err != nil { 43 | return err 44 | } 45 | 46 | return nil 47 | } 48 | 49 | // MarshalBinary interface implementation 50 | func (m *ProjectAttributes) MarshalBinary() ([]byte, error) { 51 | if m == nil { 52 | return nil, nil 53 | } 54 | return swag.WriteJSON(m) 55 | } 56 | 57 | // UnmarshalBinary interface implementation 58 | func (m *ProjectAttributes) UnmarshalBinary(b []byte) error { 59 | var res ProjectAttributes 60 | if err := swag.ReadJSON(b, &res); err != nil { 61 | return err 62 | } 63 | *m = res 64 | return nil 65 | } 66 | -------------------------------------------------------------------------------- /gen/models/item_response.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | ) 14 | 15 | // ItemResponse item response 16 | // swagger:model ItemResponse 17 | type ItemResponse struct { 18 | 19 | // data 20 | Data *Item `json:"data,omitempty"` 21 | } 22 | 23 | // Validate validates this item response 24 | func (m *ItemResponse) Validate(formats strfmt.Registry) error { 25 | var res []error 26 | 27 | if err := m.validateData(formats); err != nil { 28 | // prop 29 | res = append(res, err) 30 | } 31 | 32 | if len(res) > 0 { 33 | return errors.CompositeValidationError(res...) 34 | } 35 | return nil 36 | } 37 | 38 | func (m *ItemResponse) validateData(formats strfmt.Registry) error { 39 | 40 | if swag.IsZero(m.Data) { // not required 41 | return nil 42 | } 43 | 44 | if m.Data != nil { 45 | 46 | if err := m.Data.Validate(formats); err != nil { 47 | if ve, ok := err.(*errors.Validation); ok { 48 | return ve.ValidateName("data") 49 | } 50 | return err 51 | } 52 | 53 | } 54 | 55 | return nil 56 | } 57 | 58 | // MarshalBinary interface implementation 59 | func (m *ItemResponse) MarshalBinary() ([]byte, error) { 60 | if m == nil { 61 | return nil, nil 62 | } 63 | return swag.WriteJSON(m) 64 | } 65 | 66 | // UnmarshalBinary interface implementation 67 | func (m *ItemResponse) UnmarshalBinary(b []byte) error { 68 | var res ItemResponse 69 | if err := swag.ReadJSON(b, &res); err != nil { 70 | return err 71 | } 72 | *m = res 73 | return nil 74 | } 75 | -------------------------------------------------------------------------------- /gen/models/role_response.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | ) 14 | 15 | // RoleResponse role response 16 | // swagger:model RoleResponse 17 | type RoleResponse struct { 18 | 19 | // data 20 | Data *Role `json:"data,omitempty"` 21 | } 22 | 23 | // Validate validates this role response 24 | func (m *RoleResponse) Validate(formats strfmt.Registry) error { 25 | var res []error 26 | 27 | if err := m.validateData(formats); err != nil { 28 | // prop 29 | res = append(res, err) 30 | } 31 | 32 | if len(res) > 0 { 33 | return errors.CompositeValidationError(res...) 34 | } 35 | return nil 36 | } 37 | 38 | func (m *RoleResponse) validateData(formats strfmt.Registry) error { 39 | 40 | if swag.IsZero(m.Data) { // not required 41 | return nil 42 | } 43 | 44 | if m.Data != nil { 45 | 46 | if err := m.Data.Validate(formats); err != nil { 47 | if ve, ok := err.(*errors.Validation); ok { 48 | return ve.ValidateName("data") 49 | } 50 | return err 51 | } 52 | 53 | } 54 | 55 | return nil 56 | } 57 | 58 | // MarshalBinary interface implementation 59 | func (m *RoleResponse) MarshalBinary() ([]byte, error) { 60 | if m == nil { 61 | return nil, nil 62 | } 63 | return swag.WriteJSON(m) 64 | } 65 | 66 | // UnmarshalBinary interface implementation 67 | func (m *RoleResponse) UnmarshalBinary(b []byte) error { 68 | var res RoleResponse 69 | if err := swag.ReadJSON(b, &res); err != nil { 70 | return err 71 | } 72 | *m = res 73 | return nil 74 | } 75 | -------------------------------------------------------------------------------- /gen/models/user_response.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | ) 14 | 15 | // UserResponse user response 16 | // swagger:model UserResponse 17 | type UserResponse struct { 18 | 19 | // data 20 | Data *User `json:"data,omitempty"` 21 | } 22 | 23 | // Validate validates this user response 24 | func (m *UserResponse) Validate(formats strfmt.Registry) error { 25 | var res []error 26 | 27 | if err := m.validateData(formats); err != nil { 28 | // prop 29 | res = append(res, err) 30 | } 31 | 32 | if len(res) > 0 { 33 | return errors.CompositeValidationError(res...) 34 | } 35 | return nil 36 | } 37 | 38 | func (m *UserResponse) validateData(formats strfmt.Registry) error { 39 | 40 | if swag.IsZero(m.Data) { // not required 41 | return nil 42 | } 43 | 44 | if m.Data != nil { 45 | 46 | if err := m.Data.Validate(formats); err != nil { 47 | if ve, ok := err.(*errors.Validation); ok { 48 | return ve.ValidateName("data") 49 | } 50 | return err 51 | } 52 | 53 | } 54 | 55 | return nil 56 | } 57 | 58 | // MarshalBinary interface implementation 59 | func (m *UserResponse) MarshalBinary() ([]byte, error) { 60 | if m == nil { 61 | return nil, nil 62 | } 63 | return swag.WriteJSON(m) 64 | } 65 | 66 | // UnmarshalBinary interface implementation 67 | func (m *UserResponse) UnmarshalBinary(b []byte) error { 68 | var res UserResponse 69 | if err := swag.ReadJSON(b, &res); err != nil { 70 | return err 71 | } 72 | *m = res 73 | return nil 74 | } 75 | -------------------------------------------------------------------------------- /gen/restapi/operations/account/signin.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package account 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // SigninHandlerFunc turns a function with the right signature into a signin handler 15 | type SigninHandlerFunc func(SigninParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn SigninHandlerFunc) Handle(params SigninParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // SigninHandler interface for that can handle valid signin params 23 | type SigninHandler interface { 24 | Handle(SigninParams) middleware.Responder 25 | } 26 | 27 | // NewSignin creates a new http.Handler for the signin operation 28 | func NewSignin(ctx *middleware.Context, handler SigninHandler) *Signin { 29 | return &Signin{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*Signin swagger:route POST /signin account signin 33 | 34 | Signin signin API 35 | 36 | */ 37 | type Signin struct { 38 | Context *middleware.Context 39 | Handler SigninHandler 40 | } 41 | 42 | func (o *Signin) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewSigninParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/restapi/operations/account/signup.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package account 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // SignupHandlerFunc turns a function with the right signature into a signup handler 15 | type SignupHandlerFunc func(SignupParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn SignupHandlerFunc) Handle(params SignupParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // SignupHandler interface for that can handle valid signup params 23 | type SignupHandler interface { 24 | Handle(SignupParams) middleware.Responder 25 | } 26 | 27 | // NewSignup creates a new http.Handler for the signup operation 28 | func NewSignup(ctx *middleware.Context, handler SignupHandler) *Signup { 29 | return &Signup{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*Signup swagger:route POST /signup account signup 33 | 34 | Signup signup API 35 | 36 | */ 37 | type Signup struct { 38 | Context *middleware.Context 39 | Handler SignupHandler 40 | } 41 | 42 | func (o *Signup) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewSignupParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/models/signin_o_k_body.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | ) 14 | 15 | // SigninOKBody signin o k body 16 | // swagger:model signinOKBody 17 | type SigninOKBody struct { 18 | 19 | // data 20 | Data *Session `json:"data,omitempty"` 21 | } 22 | 23 | // Validate validates this signin o k body 24 | func (m *SigninOKBody) Validate(formats strfmt.Registry) error { 25 | var res []error 26 | 27 | if err := m.validateData(formats); err != nil { 28 | // prop 29 | res = append(res, err) 30 | } 31 | 32 | if len(res) > 0 { 33 | return errors.CompositeValidationError(res...) 34 | } 35 | return nil 36 | } 37 | 38 | func (m *SigninOKBody) validateData(formats strfmt.Registry) error { 39 | 40 | if swag.IsZero(m.Data) { // not required 41 | return nil 42 | } 43 | 44 | if m.Data != nil { 45 | 46 | if err := m.Data.Validate(formats); err != nil { 47 | if ve, ok := err.(*errors.Validation); ok { 48 | return ve.ValidateName("data") 49 | } 50 | return err 51 | } 52 | 53 | } 54 | 55 | return nil 56 | } 57 | 58 | // MarshalBinary interface implementation 59 | func (m *SigninOKBody) MarshalBinary() ([]byte, error) { 60 | if m == nil { 61 | return nil, nil 62 | } 63 | return swag.WriteJSON(m) 64 | } 65 | 66 | // UnmarshalBinary interface implementation 67 | func (m *SigninOKBody) UnmarshalBinary(b []byte) error { 68 | var res SigninOKBody 69 | if err := swag.ReadJSON(b, &res); err != nil { 70 | return err 71 | } 72 | *m = res 73 | return nil 74 | } 75 | -------------------------------------------------------------------------------- /gen/models/field_response.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | ) 14 | 15 | // FieldResponse field response 16 | // swagger:model FieldResponse 17 | type FieldResponse struct { 18 | 19 | // data 20 | Data *Field `json:"data,omitempty"` 21 | } 22 | 23 | // Validate validates this field response 24 | func (m *FieldResponse) Validate(formats strfmt.Registry) error { 25 | var res []error 26 | 27 | if err := m.validateData(formats); err != nil { 28 | // prop 29 | res = append(res, err) 30 | } 31 | 32 | if len(res) > 0 { 33 | return errors.CompositeValidationError(res...) 34 | } 35 | return nil 36 | } 37 | 38 | func (m *FieldResponse) validateData(formats strfmt.Registry) error { 39 | 40 | if swag.IsZero(m.Data) { // not required 41 | return nil 42 | } 43 | 44 | if m.Data != nil { 45 | 46 | if err := m.Data.Validate(formats); err != nil { 47 | if ve, ok := err.(*errors.Validation); ok { 48 | return ve.ValidateName("data") 49 | } 50 | return err 51 | } 52 | 53 | } 54 | 55 | return nil 56 | } 57 | 58 | // MarshalBinary interface implementation 59 | func (m *FieldResponse) MarshalBinary() ([]byte, error) { 60 | if m == nil { 61 | return nil, nil 62 | } 63 | return swag.WriteJSON(m) 64 | } 65 | 66 | // UnmarshalBinary interface implementation 67 | func (m *FieldResponse) UnmarshalBinary(b []byte) error { 68 | var res FieldResponse 69 | if err := swag.ReadJSON(b, &res); err != nil { 70 | return err 71 | } 72 | *m = res 73 | return nil 74 | } 75 | -------------------------------------------------------------------------------- /gen/models/project_response.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | ) 14 | 15 | // ProjectResponse project response 16 | // swagger:model ProjectResponse 17 | type ProjectResponse struct { 18 | 19 | // data 20 | Data *Project `json:"data,omitempty"` 21 | } 22 | 23 | // Validate validates this project response 24 | func (m *ProjectResponse) Validate(formats strfmt.Registry) error { 25 | var res []error 26 | 27 | if err := m.validateData(formats); err != nil { 28 | // prop 29 | res = append(res, err) 30 | } 31 | 32 | if len(res) > 0 { 33 | return errors.CompositeValidationError(res...) 34 | } 35 | return nil 36 | } 37 | 38 | func (m *ProjectResponse) validateData(formats strfmt.Registry) error { 39 | 40 | if swag.IsZero(m.Data) { // not required 41 | return nil 42 | } 43 | 44 | if m.Data != nil { 45 | 46 | if err := m.Data.Validate(formats); err != nil { 47 | if ve, ok := err.(*errors.Validation); ok { 48 | return ve.ValidateName("data") 49 | } 50 | return err 51 | } 52 | 53 | } 54 | 55 | return nil 56 | } 57 | 58 | // MarshalBinary interface implementation 59 | func (m *ProjectResponse) MarshalBinary() ([]byte, error) { 60 | if m == nil { 61 | return nil, nil 62 | } 63 | return swag.WriteJSON(m) 64 | } 65 | 66 | // UnmarshalBinary interface implementation 67 | func (m *ProjectResponse) UnmarshalBinary(b []byte) error { 68 | var res ProjectResponse 69 | if err := swag.ReadJSON(b, &res); err != nil { 70 | return err 71 | } 72 | *m = res 73 | return nil 74 | } 75 | -------------------------------------------------------------------------------- /gen/restapi/operations/item/get_item.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package item 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // GetItemHandlerFunc turns a function with the right signature into a get item handler 15 | type GetItemHandlerFunc func(GetItemParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn GetItemHandlerFunc) Handle(params GetItemParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // GetItemHandler interface for that can handle valid get item params 23 | type GetItemHandler interface { 24 | Handle(GetItemParams) middleware.Responder 25 | } 26 | 27 | // NewGetItem creates a new http.Handler for the get item operation 28 | func NewGetItem(ctx *middleware.Context, handler GetItemHandler) *GetItem { 29 | return &GetItem{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*GetItem swagger:route GET /projects/{projectId}/items/{id} item getItem 33 | 34 | Get a item 35 | 36 | */ 37 | type GetItem struct { 38 | Context *middleware.Context 39 | Handler GetItemHandler 40 | } 41 | 42 | func (o *GetItem) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewGetItemParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/restapi/operations/role/get_role.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package role 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // GetRoleHandlerFunc turns a function with the right signature into a get role handler 15 | type GetRoleHandlerFunc func(GetRoleParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn GetRoleHandlerFunc) Handle(params GetRoleParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // GetRoleHandler interface for that can handle valid get role params 23 | type GetRoleHandler interface { 24 | Handle(GetRoleParams) middleware.Responder 25 | } 26 | 27 | // NewGetRole creates a new http.Handler for the get role operation 28 | func NewGetRole(ctx *middleware.Context, handler GetRoleHandler) *GetRole { 29 | return &GetRole{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*GetRole swagger:route GET /projects/{projectId}/roles/{id} role getRole 33 | 34 | Get a role 35 | 36 | */ 37 | type GetRole struct { 38 | Context *middleware.Context 39 | Handler GetRoleHandler 40 | } 41 | 42 | func (o *GetRole) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewGetRoleParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/restapi/operations/user/get_user.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package user 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // GetUserHandlerFunc turns a function with the right signature into a get user handler 15 | type GetUserHandlerFunc func(GetUserParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn GetUserHandlerFunc) Handle(params GetUserParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // GetUserHandler interface for that can handle valid get user params 23 | type GetUserHandler interface { 24 | Handle(GetUserParams) middleware.Responder 25 | } 26 | 27 | // NewGetUser creates a new http.Handler for the get user operation 28 | func NewGetUser(ctx *middleware.Context, handler GetUserHandler) *GetUser { 29 | return &GetUser{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*GetUser swagger:route GET /projects/{projectId}/users/{id} user getUser 33 | 34 | Get a user 35 | 36 | */ 37 | type GetUser struct { 38 | Context *middleware.Context 39 | Handler GetUserHandler 40 | } 41 | 42 | func (o *GetUser) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewGetUserParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/models/signup_created_body.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | ) 14 | 15 | // SignupCreatedBody signup created body 16 | // swagger:model signupCreatedBody 17 | type SignupCreatedBody struct { 18 | 19 | // data 20 | Data *Session `json:"data,omitempty"` 21 | } 22 | 23 | // Validate validates this signup created body 24 | func (m *SignupCreatedBody) Validate(formats strfmt.Registry) error { 25 | var res []error 26 | 27 | if err := m.validateData(formats); err != nil { 28 | // prop 29 | res = append(res, err) 30 | } 31 | 32 | if len(res) > 0 { 33 | return errors.CompositeValidationError(res...) 34 | } 35 | return nil 36 | } 37 | 38 | func (m *SignupCreatedBody) validateData(formats strfmt.Registry) error { 39 | 40 | if swag.IsZero(m.Data) { // not required 41 | return nil 42 | } 43 | 44 | if m.Data != nil { 45 | 46 | if err := m.Data.Validate(formats); err != nil { 47 | if ve, ok := err.(*errors.Validation); ok { 48 | return ve.ValidateName("data") 49 | } 50 | return err 51 | } 52 | 53 | } 54 | 55 | return nil 56 | } 57 | 58 | // MarshalBinary interface implementation 59 | func (m *SignupCreatedBody) MarshalBinary() ([]byte, error) { 60 | if m == nil { 61 | return nil, nil 62 | } 63 | return swag.WriteJSON(m) 64 | } 65 | 66 | // UnmarshalBinary interface implementation 67 | func (m *SignupCreatedBody) UnmarshalBinary(b []byte) error { 68 | var res SignupCreatedBody 69 | if err := swag.ReadJSON(b, &res); err != nil { 70 | return err 71 | } 72 | *m = res 73 | return nil 74 | } 75 | -------------------------------------------------------------------------------- /gen/restapi/operations/field/get_field.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package field 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // GetFieldHandlerFunc turns a function with the right signature into a get field handler 15 | type GetFieldHandlerFunc func(GetFieldParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn GetFieldHandlerFunc) Handle(params GetFieldParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // GetFieldHandler interface for that can handle valid get field params 23 | type GetFieldHandler interface { 24 | Handle(GetFieldParams) middleware.Responder 25 | } 26 | 27 | // NewGetField creates a new http.Handler for the get field operation 28 | func NewGetField(ctx *middleware.Context, handler GetFieldHandler) *GetField { 29 | return &GetField{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*GetField swagger:route GET /projects/{projectId}/fields/{id} field getField 33 | 34 | Get a field 35 | 36 | */ 37 | type GetField struct { 38 | Context *middleware.Context 39 | Handler GetFieldHandler 40 | } 41 | 42 | func (o *GetField) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewGetFieldParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/models/item_request.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | "github.com/go-openapi/validate" 14 | ) 15 | 16 | // ItemRequest item request 17 | // swagger:model ItemRequest 18 | type ItemRequest struct { 19 | 20 | // data 21 | // Required: true 22 | Data *Item `json:"data"` 23 | } 24 | 25 | // Validate validates this item request 26 | func (m *ItemRequest) Validate(formats strfmt.Registry) error { 27 | var res []error 28 | 29 | if err := m.validateData(formats); err != nil { 30 | // prop 31 | res = append(res, err) 32 | } 33 | 34 | if len(res) > 0 { 35 | return errors.CompositeValidationError(res...) 36 | } 37 | return nil 38 | } 39 | 40 | func (m *ItemRequest) validateData(formats strfmt.Registry) error { 41 | 42 | if err := validate.Required("data", "body", m.Data); err != nil { 43 | return err 44 | } 45 | 46 | if m.Data != nil { 47 | 48 | if err := m.Data.Validate(formats); err != nil { 49 | if ve, ok := err.(*errors.Validation); ok { 50 | return ve.ValidateName("data") 51 | } 52 | return err 53 | } 54 | 55 | } 56 | 57 | return nil 58 | } 59 | 60 | // MarshalBinary interface implementation 61 | func (m *ItemRequest) MarshalBinary() ([]byte, error) { 62 | if m == nil { 63 | return nil, nil 64 | } 65 | return swag.WriteJSON(m) 66 | } 67 | 68 | // UnmarshalBinary interface implementation 69 | func (m *ItemRequest) UnmarshalBinary(b []byte) error { 70 | var res ItemRequest 71 | if err := swag.ReadJSON(b, &res); err != nil { 72 | return err 73 | } 74 | *m = res 75 | return nil 76 | } 77 | -------------------------------------------------------------------------------- /gen/models/role_request.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | "github.com/go-openapi/validate" 14 | ) 15 | 16 | // RoleRequest role request 17 | // swagger:model RoleRequest 18 | type RoleRequest struct { 19 | 20 | // data 21 | // Required: true 22 | Data *Role `json:"data"` 23 | } 24 | 25 | // Validate validates this role request 26 | func (m *RoleRequest) Validate(formats strfmt.Registry) error { 27 | var res []error 28 | 29 | if err := m.validateData(formats); err != nil { 30 | // prop 31 | res = append(res, err) 32 | } 33 | 34 | if len(res) > 0 { 35 | return errors.CompositeValidationError(res...) 36 | } 37 | return nil 38 | } 39 | 40 | func (m *RoleRequest) validateData(formats strfmt.Registry) error { 41 | 42 | if err := validate.Required("data", "body", m.Data); err != nil { 43 | return err 44 | } 45 | 46 | if m.Data != nil { 47 | 48 | if err := m.Data.Validate(formats); err != nil { 49 | if ve, ok := err.(*errors.Validation); ok { 50 | return ve.ValidateName("data") 51 | } 52 | return err 53 | } 54 | 55 | } 56 | 57 | return nil 58 | } 59 | 60 | // MarshalBinary interface implementation 61 | func (m *RoleRequest) MarshalBinary() ([]byte, error) { 62 | if m == nil { 63 | return nil, nil 64 | } 65 | return swag.WriteJSON(m) 66 | } 67 | 68 | // UnmarshalBinary interface implementation 69 | func (m *RoleRequest) UnmarshalBinary(b []byte) error { 70 | var res RoleRequest 71 | if err := swag.ReadJSON(b, &res); err != nil { 72 | return err 73 | } 74 | *m = res 75 | return nil 76 | } 77 | -------------------------------------------------------------------------------- /gen/models/user_request.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | "github.com/go-openapi/validate" 14 | ) 15 | 16 | // UserRequest user request 17 | // swagger:model UserRequest 18 | type UserRequest struct { 19 | 20 | // data 21 | // Required: true 22 | Data *User `json:"data"` 23 | } 24 | 25 | // Validate validates this user request 26 | func (m *UserRequest) Validate(formats strfmt.Registry) error { 27 | var res []error 28 | 29 | if err := m.validateData(formats); err != nil { 30 | // prop 31 | res = append(res, err) 32 | } 33 | 34 | if len(res) > 0 { 35 | return errors.CompositeValidationError(res...) 36 | } 37 | return nil 38 | } 39 | 40 | func (m *UserRequest) validateData(formats strfmt.Registry) error { 41 | 42 | if err := validate.Required("data", "body", m.Data); err != nil { 43 | return err 44 | } 45 | 46 | if m.Data != nil { 47 | 48 | if err := m.Data.Validate(formats); err != nil { 49 | if ve, ok := err.(*errors.Validation); ok { 50 | return ve.ValidateName("data") 51 | } 52 | return err 53 | } 54 | 55 | } 56 | 57 | return nil 58 | } 59 | 60 | // MarshalBinary interface implementation 61 | func (m *UserRequest) MarshalBinary() ([]byte, error) { 62 | if m == nil { 63 | return nil, nil 64 | } 65 | return swag.WriteJSON(m) 66 | } 67 | 68 | // UnmarshalBinary interface implementation 69 | func (m *UserRequest) UnmarshalBinary(b []byte) error { 70 | var res UserRequest 71 | if err := swag.ReadJSON(b, &res); err != nil { 72 | return err 73 | } 74 | *m = res 75 | return nil 76 | } 77 | -------------------------------------------------------------------------------- /gen/restapi/operations/item/get_items.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package item 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // GetItemsHandlerFunc turns a function with the right signature into a get items handler 15 | type GetItemsHandlerFunc func(GetItemsParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn GetItemsHandlerFunc) Handle(params GetItemsParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // GetItemsHandler interface for that can handle valid get items params 23 | type GetItemsHandler interface { 24 | Handle(GetItemsParams) middleware.Responder 25 | } 26 | 27 | // NewGetItems creates a new http.Handler for the get items operation 28 | func NewGetItems(ctx *middleware.Context, handler GetItemsHandler) *GetItems { 29 | return &GetItems{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*GetItems swagger:route GET /projects/{projectId}/items item getItems 33 | 34 | Get the items of the model 35 | 36 | */ 37 | type GetItems struct { 38 | Context *middleware.Context 39 | Handler GetItemsHandler 40 | } 41 | 42 | func (o *GetItems) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewGetItemsParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/restapi/operations/role/get_roles.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package role 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // GetRolesHandlerFunc turns a function with the right signature into a get roles handler 15 | type GetRolesHandlerFunc func(GetRolesParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn GetRolesHandlerFunc) Handle(params GetRolesParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // GetRolesHandler interface for that can handle valid get roles params 23 | type GetRolesHandler interface { 24 | Handle(GetRolesParams) middleware.Responder 25 | } 26 | 27 | // NewGetRoles creates a new http.Handler for the get roles operation 28 | func NewGetRoles(ctx *middleware.Context, handler GetRolesHandler) *GetRoles { 29 | return &GetRoles{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*GetRoles swagger:route GET /projects/{projectId}/roles role getRoles 33 | 34 | Get the roles of the model 35 | 36 | */ 37 | type GetRoles struct { 38 | Context *middleware.Context 39 | Handler GetRolesHandler 40 | } 41 | 42 | func (o *GetRoles) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewGetRolesParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/restapi/operations/user/get_users.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package user 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // GetUsersHandlerFunc turns a function with the right signature into a get users handler 15 | type GetUsersHandlerFunc func(GetUsersParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn GetUsersHandlerFunc) Handle(params GetUsersParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // GetUsersHandler interface for that can handle valid get users params 23 | type GetUsersHandler interface { 24 | Handle(GetUsersParams) middleware.Responder 25 | } 26 | 27 | // NewGetUsers creates a new http.Handler for the get users operation 28 | func NewGetUsers(ctx *middleware.Context, handler GetUsersHandler) *GetUsers { 29 | return &GetUsers{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*GetUsers swagger:route GET /projects/{projectId}/users user getUsers 33 | 34 | Get the users of the model 35 | 36 | */ 37 | type GetUsers struct { 38 | Context *middleware.Context 39 | Handler GetUsersHandler 40 | } 41 | 42 | func (o *GetUsers) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewGetUsersParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/models/field_request.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | "github.com/go-openapi/validate" 14 | ) 15 | 16 | // FieldRequest field request 17 | // swagger:model FieldRequest 18 | type FieldRequest struct { 19 | 20 | // data 21 | // Required: true 22 | Data *Field `json:"data"` 23 | } 24 | 25 | // Validate validates this field request 26 | func (m *FieldRequest) Validate(formats strfmt.Registry) error { 27 | var res []error 28 | 29 | if err := m.validateData(formats); err != nil { 30 | // prop 31 | res = append(res, err) 32 | } 33 | 34 | if len(res) > 0 { 35 | return errors.CompositeValidationError(res...) 36 | } 37 | return nil 38 | } 39 | 40 | func (m *FieldRequest) validateData(formats strfmt.Registry) error { 41 | 42 | if err := validate.Required("data", "body", m.Data); err != nil { 43 | return err 44 | } 45 | 46 | if m.Data != nil { 47 | 48 | if err := m.Data.Validate(formats); err != nil { 49 | if ve, ok := err.(*errors.Validation); ok { 50 | return ve.ValidateName("data") 51 | } 52 | return err 53 | } 54 | 55 | } 56 | 57 | return nil 58 | } 59 | 60 | // MarshalBinary interface implementation 61 | func (m *FieldRequest) MarshalBinary() ([]byte, error) { 62 | if m == nil { 63 | return nil, nil 64 | } 65 | return swag.WriteJSON(m) 66 | } 67 | 68 | // UnmarshalBinary interface implementation 69 | func (m *FieldRequest) UnmarshalBinary(b []byte) error { 70 | var res FieldRequest 71 | if err := swag.ReadJSON(b, &res); err != nil { 72 | return err 73 | } 74 | *m = res 75 | return nil 76 | } 77 | -------------------------------------------------------------------------------- /gen/restapi/operations/project/get_project.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package project 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // GetProjectHandlerFunc turns a function with the right signature into a get project handler 15 | type GetProjectHandlerFunc func(GetProjectParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn GetProjectHandlerFunc) Handle(params GetProjectParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // GetProjectHandler interface for that can handle valid get project params 23 | type GetProjectHandler interface { 24 | Handle(GetProjectParams) middleware.Responder 25 | } 26 | 27 | // NewGetProject creates a new http.Handler for the get project operation 28 | func NewGetProject(ctx *middleware.Context, handler GetProjectHandler) *GetProject { 29 | return &GetProject{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*GetProject swagger:route GET /projects/{id} project getProject 33 | 34 | Get a project 35 | 36 | */ 37 | type GetProject struct { 38 | Context *middleware.Context 39 | Handler GetProjectHandler 40 | } 41 | 42 | func (o *GetProject) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewGetProjectParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/models/project_request.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | "github.com/go-openapi/validate" 14 | ) 15 | 16 | // ProjectRequest project request 17 | // swagger:model ProjectRequest 18 | type ProjectRequest struct { 19 | 20 | // data 21 | // Required: true 22 | Data *Project `json:"data"` 23 | } 24 | 25 | // Validate validates this project request 26 | func (m *ProjectRequest) Validate(formats strfmt.Registry) error { 27 | var res []error 28 | 29 | if err := m.validateData(formats); err != nil { 30 | // prop 31 | res = append(res, err) 32 | } 33 | 34 | if len(res) > 0 { 35 | return errors.CompositeValidationError(res...) 36 | } 37 | return nil 38 | } 39 | 40 | func (m *ProjectRequest) validateData(formats strfmt.Registry) error { 41 | 42 | if err := validate.Required("data", "body", m.Data); err != nil { 43 | return err 44 | } 45 | 46 | if m.Data != nil { 47 | 48 | if err := m.Data.Validate(formats); err != nil { 49 | if ve, ok := err.(*errors.Validation); ok { 50 | return ve.ValidateName("data") 51 | } 52 | return err 53 | } 54 | 55 | } 56 | 57 | return nil 58 | } 59 | 60 | // MarshalBinary interface implementation 61 | func (m *ProjectRequest) MarshalBinary() ([]byte, error) { 62 | if m == nil { 63 | return nil, nil 64 | } 65 | return swag.WriteJSON(m) 66 | } 67 | 68 | // UnmarshalBinary interface implementation 69 | func (m *ProjectRequest) UnmarshalBinary(b []byte) error { 70 | var res ProjectRequest 71 | if err := swag.ReadJSON(b, &res); err != nil { 72 | return err 73 | } 74 | *m = res 75 | return nil 76 | } 77 | -------------------------------------------------------------------------------- /gen/models/session_relationships.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | ) 14 | 15 | // SessionRelationships session relationships 16 | // swagger:model SessionRelationships 17 | type SessionRelationships struct { 18 | 19 | // user 20 | User *SessionRelationshipsUser `json:"user,omitempty"` 21 | } 22 | 23 | // Validate validates this session relationships 24 | func (m *SessionRelationships) Validate(formats strfmt.Registry) error { 25 | var res []error 26 | 27 | if err := m.validateUser(formats); err != nil { 28 | // prop 29 | res = append(res, err) 30 | } 31 | 32 | if len(res) > 0 { 33 | return errors.CompositeValidationError(res...) 34 | } 35 | return nil 36 | } 37 | 38 | func (m *SessionRelationships) validateUser(formats strfmt.Registry) error { 39 | 40 | if swag.IsZero(m.User) { // not required 41 | return nil 42 | } 43 | 44 | if m.User != nil { 45 | 46 | if err := m.User.Validate(formats); err != nil { 47 | if ve, ok := err.(*errors.Validation); ok { 48 | return ve.ValidateName("user") 49 | } 50 | return err 51 | } 52 | 53 | } 54 | 55 | return nil 56 | } 57 | 58 | // MarshalBinary interface implementation 59 | func (m *SessionRelationships) MarshalBinary() ([]byte, error) { 60 | if m == nil { 61 | return nil, nil 62 | } 63 | return swag.WriteJSON(m) 64 | } 65 | 66 | // UnmarshalBinary interface implementation 67 | func (m *SessionRelationships) UnmarshalBinary(b []byte) error { 68 | var res SessionRelationships 69 | if err := swag.ReadJSON(b, &res); err != nil { 70 | return err 71 | } 72 | *m = res 73 | return nil 74 | } 75 | -------------------------------------------------------------------------------- /gen/restapi/operations/item/create_item.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package item 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // CreateItemHandlerFunc turns a function with the right signature into a create item handler 15 | type CreateItemHandlerFunc func(CreateItemParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn CreateItemHandlerFunc) Handle(params CreateItemParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // CreateItemHandler interface for that can handle valid create item params 23 | type CreateItemHandler interface { 24 | Handle(CreateItemParams) middleware.Responder 25 | } 26 | 27 | // NewCreateItem creates a new http.Handler for the create item operation 28 | func NewCreateItem(ctx *middleware.Context, handler CreateItemHandler) *CreateItem { 29 | return &CreateItem{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*CreateItem swagger:route POST /projects/{projectId}/items item createItem 33 | 34 | Create a new item 35 | 36 | */ 37 | type CreateItem struct { 38 | Context *middleware.Context 39 | Handler CreateItemHandler 40 | } 41 | 42 | func (o *CreateItem) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewCreateItemParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/restapi/operations/item/update_item.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package item 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // UpdateItemHandlerFunc turns a function with the right signature into a update item handler 15 | type UpdateItemHandlerFunc func(UpdateItemParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn UpdateItemHandlerFunc) Handle(params UpdateItemParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // UpdateItemHandler interface for that can handle valid update item params 23 | type UpdateItemHandler interface { 24 | Handle(UpdateItemParams) middleware.Responder 25 | } 26 | 27 | // NewUpdateItem creates a new http.Handler for the update item operation 28 | func NewUpdateItem(ctx *middleware.Context, handler UpdateItemHandler) *UpdateItem { 29 | return &UpdateItem{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*UpdateItem swagger:route PUT /projects/{projectId}/items/{id} item updateItem 33 | 34 | Update a item 35 | 36 | */ 37 | type UpdateItem struct { 38 | Context *middleware.Context 39 | Handler UpdateItemHandler 40 | } 41 | 42 | func (o *UpdateItem) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewUpdateItemParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/restapi/operations/role/create_role.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package role 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // CreateRoleHandlerFunc turns a function with the right signature into a create role handler 15 | type CreateRoleHandlerFunc func(CreateRoleParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn CreateRoleHandlerFunc) Handle(params CreateRoleParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // CreateRoleHandler interface for that can handle valid create role params 23 | type CreateRoleHandler interface { 24 | Handle(CreateRoleParams) middleware.Responder 25 | } 26 | 27 | // NewCreateRole creates a new http.Handler for the create role operation 28 | func NewCreateRole(ctx *middleware.Context, handler CreateRoleHandler) *CreateRole { 29 | return &CreateRole{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*CreateRole swagger:route POST /projects/{projectId}/roles role createRole 33 | 34 | Create a new role 35 | 36 | */ 37 | type CreateRole struct { 38 | Context *middleware.Context 39 | Handler CreateRoleHandler 40 | } 41 | 42 | func (o *CreateRole) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewCreateRoleParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/restapi/operations/role/update_role.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package role 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // UpdateRoleHandlerFunc turns a function with the right signature into a update role handler 15 | type UpdateRoleHandlerFunc func(UpdateRoleParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn UpdateRoleHandlerFunc) Handle(params UpdateRoleParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // UpdateRoleHandler interface for that can handle valid update role params 23 | type UpdateRoleHandler interface { 24 | Handle(UpdateRoleParams) middleware.Responder 25 | } 26 | 27 | // NewUpdateRole creates a new http.Handler for the update role operation 28 | func NewUpdateRole(ctx *middleware.Context, handler UpdateRoleHandler) *UpdateRole { 29 | return &UpdateRole{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*UpdateRole swagger:route PUT /projects/{projectId}/roles/{id} role updateRole 33 | 34 | Update a role 35 | 36 | */ 37 | type UpdateRole struct { 38 | Context *middleware.Context 39 | Handler UpdateRoleHandler 40 | } 41 | 42 | func (o *UpdateRole) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewUpdateRoleParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/restapi/operations/user/create_user.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package user 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // CreateUserHandlerFunc turns a function with the right signature into a create user handler 15 | type CreateUserHandlerFunc func(CreateUserParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn CreateUserHandlerFunc) Handle(params CreateUserParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // CreateUserHandler interface for that can handle valid create user params 23 | type CreateUserHandler interface { 24 | Handle(CreateUserParams) middleware.Responder 25 | } 26 | 27 | // NewCreateUser creates a new http.Handler for the create user operation 28 | func NewCreateUser(ctx *middleware.Context, handler CreateUserHandler) *CreateUser { 29 | return &CreateUser{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*CreateUser swagger:route POST /projects/{projectId}/users user createUser 33 | 34 | Create a new user 35 | 36 | */ 37 | type CreateUser struct { 38 | Context *middleware.Context 39 | Handler CreateUserHandler 40 | } 41 | 42 | func (o *CreateUser) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewCreateUserParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/restapi/operations/user/update_user.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package user 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // UpdateUserHandlerFunc turns a function with the right signature into a update user handler 15 | type UpdateUserHandlerFunc func(UpdateUserParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn UpdateUserHandlerFunc) Handle(params UpdateUserParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // UpdateUserHandler interface for that can handle valid update user params 23 | type UpdateUserHandler interface { 24 | Handle(UpdateUserParams) middleware.Responder 25 | } 26 | 27 | // NewUpdateUser creates a new http.Handler for the update user operation 28 | func NewUpdateUser(ctx *middleware.Context, handler UpdateUserHandler) *UpdateUser { 29 | return &UpdateUser{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*UpdateUser swagger:route PUT /projects/{projectId}/users/{id} user updateUser 33 | 34 | Update a user 35 | 36 | */ 37 | type UpdateUser struct { 38 | Context *middleware.Context 39 | Handler UpdateUserHandler 40 | } 41 | 42 | func (o *UpdateUser) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewUpdateUserParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/restapi/operations/item/delete_item.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package item 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // DeleteItemHandlerFunc turns a function with the right signature into a delete item handler 15 | type DeleteItemHandlerFunc func(DeleteItemParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn DeleteItemHandlerFunc) Handle(params DeleteItemParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // DeleteItemHandler interface for that can handle valid delete item params 23 | type DeleteItemHandler interface { 24 | Handle(DeleteItemParams) middleware.Responder 25 | } 26 | 27 | // NewDeleteItem creates a new http.Handler for the delete item operation 28 | func NewDeleteItem(ctx *middleware.Context, handler DeleteItemHandler) *DeleteItem { 29 | return &DeleteItem{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*DeleteItem swagger:route DELETE /projects/{projectId}/items/{id} item deleteItem 33 | 34 | Delete a item 35 | 36 | */ 37 | type DeleteItem struct { 38 | Context *middleware.Context 39 | Handler DeleteItemHandler 40 | } 41 | 42 | func (o *DeleteItem) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewDeleteItemParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/restapi/operations/role/delete_role.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package role 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // DeleteRoleHandlerFunc turns a function with the right signature into a delete role handler 15 | type DeleteRoleHandlerFunc func(DeleteRoleParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn DeleteRoleHandlerFunc) Handle(params DeleteRoleParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // DeleteRoleHandler interface for that can handle valid delete role params 23 | type DeleteRoleHandler interface { 24 | Handle(DeleteRoleParams) middleware.Responder 25 | } 26 | 27 | // NewDeleteRole creates a new http.Handler for the delete role operation 28 | func NewDeleteRole(ctx *middleware.Context, handler DeleteRoleHandler) *DeleteRole { 29 | return &DeleteRole{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*DeleteRole swagger:route DELETE /projects/{projectId}/roles/{id} role deleteRole 33 | 34 | Delete a role 35 | 36 | */ 37 | type DeleteRole struct { 38 | Context *middleware.Context 39 | Handler DeleteRoleHandler 40 | } 41 | 42 | func (o *DeleteRole) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewDeleteRoleParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/restapi/operations/user/delete_user.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package user 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // DeleteUserHandlerFunc turns a function with the right signature into a delete user handler 15 | type DeleteUserHandlerFunc func(DeleteUserParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn DeleteUserHandlerFunc) Handle(params DeleteUserParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // DeleteUserHandler interface for that can handle valid delete user params 23 | type DeleteUserHandler interface { 24 | Handle(DeleteUserParams) middleware.Responder 25 | } 26 | 27 | // NewDeleteUser creates a new http.Handler for the delete user operation 28 | func NewDeleteUser(ctx *middleware.Context, handler DeleteUserHandler) *DeleteUser { 29 | return &DeleteUser{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*DeleteUser swagger:route DELETE /projects/{projectId}/users/{id} user deleteUser 33 | 34 | Delete a user 35 | 36 | */ 37 | type DeleteUser struct { 38 | Context *middleware.Context 39 | Handler DeleteUserHandler 40 | } 41 | 42 | func (o *DeleteUser) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewDeleteUserParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/models/item_type_request.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | "github.com/go-openapi/validate" 14 | ) 15 | 16 | // ItemTypeRequest item type request 17 | // swagger:model ItemTypeRequest 18 | type ItemTypeRequest struct { 19 | 20 | // data 21 | // Required: true 22 | Data *ItemType `json:"data"` 23 | } 24 | 25 | // Validate validates this item type request 26 | func (m *ItemTypeRequest) Validate(formats strfmt.Registry) error { 27 | var res []error 28 | 29 | if err := m.validateData(formats); err != nil { 30 | // prop 31 | res = append(res, err) 32 | } 33 | 34 | if len(res) > 0 { 35 | return errors.CompositeValidationError(res...) 36 | } 37 | return nil 38 | } 39 | 40 | func (m *ItemTypeRequest) validateData(formats strfmt.Registry) error { 41 | 42 | if err := validate.Required("data", "body", m.Data); err != nil { 43 | return err 44 | } 45 | 46 | if m.Data != nil { 47 | 48 | if err := m.Data.Validate(formats); err != nil { 49 | if ve, ok := err.(*errors.Validation); ok { 50 | return ve.ValidateName("data") 51 | } 52 | return err 53 | } 54 | 55 | } 56 | 57 | return nil 58 | } 59 | 60 | // MarshalBinary interface implementation 61 | func (m *ItemTypeRequest) MarshalBinary() ([]byte, error) { 62 | if m == nil { 63 | return nil, nil 64 | } 65 | return swag.WriteJSON(m) 66 | } 67 | 68 | // UnmarshalBinary interface implementation 69 | func (m *ItemTypeRequest) UnmarshalBinary(b []byte) error { 70 | var res ItemTypeRequest 71 | if err := swag.ReadJSON(b, &res); err != nil { 72 | return err 73 | } 74 | *m = res 75 | return nil 76 | } 77 | -------------------------------------------------------------------------------- /gen/restapi/operations/field/get_fields.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package field 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // GetFieldsHandlerFunc turns a function with the right signature into a get fields handler 15 | type GetFieldsHandlerFunc func(GetFieldsParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn GetFieldsHandlerFunc) Handle(params GetFieldsParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // GetFieldsHandler interface for that can handle valid get fields params 23 | type GetFieldsHandler interface { 24 | Handle(GetFieldsParams) middleware.Responder 25 | } 26 | 27 | // NewGetFields creates a new http.Handler for the get fields operation 28 | func NewGetFields(ctx *middleware.Context, handler GetFieldsHandler) *GetFields { 29 | return &GetFields{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*GetFields swagger:route GET /projects/{projectId}/item-types/{itemTypeId}/fields field getFields 33 | 34 | Get the fields of the model 35 | 36 | */ 37 | type GetFields struct { 38 | Context *middleware.Context 39 | Handler GetFieldsHandler 40 | } 41 | 42 | func (o *GetFields) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewGetFieldsParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/models/field_relationships.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | ) 14 | 15 | // FieldRelationships field relationships 16 | // swagger:model FieldRelationships 17 | type FieldRelationships struct { 18 | 19 | // item type 20 | ItemType *FieldRelationshipsItemType `json:"itemType,omitempty"` 21 | } 22 | 23 | // Validate validates this field relationships 24 | func (m *FieldRelationships) Validate(formats strfmt.Registry) error { 25 | var res []error 26 | 27 | if err := m.validateItemType(formats); err != nil { 28 | // prop 29 | res = append(res, err) 30 | } 31 | 32 | if len(res) > 0 { 33 | return errors.CompositeValidationError(res...) 34 | } 35 | return nil 36 | } 37 | 38 | func (m *FieldRelationships) validateItemType(formats strfmt.Registry) error { 39 | 40 | if swag.IsZero(m.ItemType) { // not required 41 | return nil 42 | } 43 | 44 | if m.ItemType != nil { 45 | 46 | if err := m.ItemType.Validate(formats); err != nil { 47 | if ve, ok := err.(*errors.Validation); ok { 48 | return ve.ValidateName("itemType") 49 | } 50 | return err 51 | } 52 | 53 | } 54 | 55 | return nil 56 | } 57 | 58 | // MarshalBinary interface implementation 59 | func (m *FieldRelationships) MarshalBinary() ([]byte, error) { 60 | if m == nil { 61 | return nil, nil 62 | } 63 | return swag.WriteJSON(m) 64 | } 65 | 66 | // UnmarshalBinary interface implementation 67 | func (m *FieldRelationships) UnmarshalBinary(b []byte) error { 68 | var res FieldRelationships 69 | if err := swag.ReadJSON(b, &res); err != nil { 70 | return err 71 | } 72 | *m = res 73 | return nil 74 | } 75 | -------------------------------------------------------------------------------- /gen/models/item_type_response.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | ) 14 | 15 | // ItemTypeResponse item type response 16 | // swagger:model ItemTypeResponse 17 | type ItemTypeResponse struct { 18 | 19 | // data 20 | Data *ItemType `json:"data,omitempty"` 21 | 22 | // included 23 | Included ItemTypeIncluded `json:"included"` 24 | } 25 | 26 | // Validate validates this item type response 27 | func (m *ItemTypeResponse) Validate(formats strfmt.Registry) error { 28 | var res []error 29 | 30 | if err := m.validateData(formats); err != nil { 31 | // prop 32 | res = append(res, err) 33 | } 34 | 35 | if len(res) > 0 { 36 | return errors.CompositeValidationError(res...) 37 | } 38 | return nil 39 | } 40 | 41 | func (m *ItemTypeResponse) validateData(formats strfmt.Registry) error { 42 | 43 | if swag.IsZero(m.Data) { // not required 44 | return nil 45 | } 46 | 47 | if m.Data != nil { 48 | 49 | if err := m.Data.Validate(formats); err != nil { 50 | if ve, ok := err.(*errors.Validation); ok { 51 | return ve.ValidateName("data") 52 | } 53 | return err 54 | } 55 | 56 | } 57 | 58 | return nil 59 | } 60 | 61 | // MarshalBinary interface implementation 62 | func (m *ItemTypeResponse) MarshalBinary() ([]byte, error) { 63 | if m == nil { 64 | return nil, nil 65 | } 66 | return swag.WriteJSON(m) 67 | } 68 | 69 | // UnmarshalBinary interface implementation 70 | func (m *ItemTypeResponse) UnmarshalBinary(b []byte) error { 71 | var res ItemTypeResponse 72 | if err := swag.ReadJSON(b, &res); err != nil { 73 | return err 74 | } 75 | *m = res 76 | return nil 77 | } 78 | -------------------------------------------------------------------------------- /gen/restapi/operations/project/get_projects.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package project 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // GetProjectsHandlerFunc turns a function with the right signature into a get projects handler 15 | type GetProjectsHandlerFunc func(GetProjectsParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn GetProjectsHandlerFunc) Handle(params GetProjectsParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // GetProjectsHandler interface for that can handle valid get projects params 23 | type GetProjectsHandler interface { 24 | Handle(GetProjectsParams) middleware.Responder 25 | } 26 | 27 | // NewGetProjects creates a new http.Handler for the get projects operation 28 | func NewGetProjects(ctx *middleware.Context, handler GetProjectsHandler) *GetProjects { 29 | return &GetProjects{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*GetProjects swagger:route GET /projects project getProjects 33 | 34 | Get the projects for the user 35 | 36 | */ 37 | type GetProjects struct { 38 | Context *middleware.Context 39 | Handler GetProjectsHandler 40 | } 41 | 42 | func (o *GetProjects) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewGetProjectsParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/models/project_relationships.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | ) 14 | 15 | // ProjectRelationships project relationships 16 | // swagger:model ProjectRelationships 17 | type ProjectRelationships struct { 18 | 19 | // account 20 | Account *ProjectRelationshipsAccount `json:"account,omitempty"` 21 | } 22 | 23 | // Validate validates this project relationships 24 | func (m *ProjectRelationships) Validate(formats strfmt.Registry) error { 25 | var res []error 26 | 27 | if err := m.validateAccount(formats); err != nil { 28 | // prop 29 | res = append(res, err) 30 | } 31 | 32 | if len(res) > 0 { 33 | return errors.CompositeValidationError(res...) 34 | } 35 | return nil 36 | } 37 | 38 | func (m *ProjectRelationships) validateAccount(formats strfmt.Registry) error { 39 | 40 | if swag.IsZero(m.Account) { // not required 41 | return nil 42 | } 43 | 44 | if m.Account != nil { 45 | 46 | if err := m.Account.Validate(formats); err != nil { 47 | if ve, ok := err.(*errors.Validation); ok { 48 | return ve.ValidateName("account") 49 | } 50 | return err 51 | } 52 | 53 | } 54 | 55 | return nil 56 | } 57 | 58 | // MarshalBinary interface implementation 59 | func (m *ProjectRelationships) MarshalBinary() ([]byte, error) { 60 | if m == nil { 61 | return nil, nil 62 | } 63 | return swag.WriteJSON(m) 64 | } 65 | 66 | // UnmarshalBinary interface implementation 67 | func (m *ProjectRelationships) UnmarshalBinary(b []byte) error { 68 | var res ProjectRelationships 69 | if err := swag.ReadJSON(b, &res); err != nil { 70 | return err 71 | } 72 | *m = res 73 | return nil 74 | } 75 | -------------------------------------------------------------------------------- /gen/models/signin_params_body.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | "github.com/go-openapi/validate" 14 | ) 15 | 16 | // SigninParamsBody signin params body 17 | // swagger:model signinParamsBody 18 | type SigninParamsBody struct { 19 | 20 | // data 21 | // Required: true 22 | Data *EmailCredentials `json:"data"` 23 | } 24 | 25 | // Validate validates this signin params body 26 | func (m *SigninParamsBody) Validate(formats strfmt.Registry) error { 27 | var res []error 28 | 29 | if err := m.validateData(formats); err != nil { 30 | // prop 31 | res = append(res, err) 32 | } 33 | 34 | if len(res) > 0 { 35 | return errors.CompositeValidationError(res...) 36 | } 37 | return nil 38 | } 39 | 40 | func (m *SigninParamsBody) validateData(formats strfmt.Registry) error { 41 | 42 | if err := validate.Required("data", "body", m.Data); err != nil { 43 | return err 44 | } 45 | 46 | if m.Data != nil { 47 | 48 | if err := m.Data.Validate(formats); err != nil { 49 | if ve, ok := err.(*errors.Validation); ok { 50 | return ve.ValidateName("data") 51 | } 52 | return err 53 | } 54 | 55 | } 56 | 57 | return nil 58 | } 59 | 60 | // MarshalBinary interface implementation 61 | func (m *SigninParamsBody) MarshalBinary() ([]byte, error) { 62 | if m == nil { 63 | return nil, nil 64 | } 65 | return swag.WriteJSON(m) 66 | } 67 | 68 | // UnmarshalBinary interface implementation 69 | func (m *SigninParamsBody) UnmarshalBinary(b []byte) error { 70 | var res SigninParamsBody 71 | if err := swag.ReadJSON(b, &res); err != nil { 72 | return err 73 | } 74 | *m = res 75 | return nil 76 | } 77 | -------------------------------------------------------------------------------- /gen/models/signup_params_body.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | "github.com/go-openapi/validate" 14 | ) 15 | 16 | // SignupParamsBody signup params body 17 | // swagger:model signupParamsBody 18 | type SignupParamsBody struct { 19 | 20 | // data 21 | // Required: true 22 | Data *EmailCredentials `json:"data"` 23 | } 24 | 25 | // Validate validates this signup params body 26 | func (m *SignupParamsBody) Validate(formats strfmt.Registry) error { 27 | var res []error 28 | 29 | if err := m.validateData(formats); err != nil { 30 | // prop 31 | res = append(res, err) 32 | } 33 | 34 | if len(res) > 0 { 35 | return errors.CompositeValidationError(res...) 36 | } 37 | return nil 38 | } 39 | 40 | func (m *SignupParamsBody) validateData(formats strfmt.Registry) error { 41 | 42 | if err := validate.Required("data", "body", m.Data); err != nil { 43 | return err 44 | } 45 | 46 | if m.Data != nil { 47 | 48 | if err := m.Data.Validate(formats); err != nil { 49 | if ve, ok := err.(*errors.Validation); ok { 50 | return ve.ValidateName("data") 51 | } 52 | return err 53 | } 54 | 55 | } 56 | 57 | return nil 58 | } 59 | 60 | // MarshalBinary interface implementation 61 | func (m *SignupParamsBody) MarshalBinary() ([]byte, error) { 62 | if m == nil { 63 | return nil, nil 64 | } 65 | return swag.WriteJSON(m) 66 | } 67 | 68 | // UnmarshalBinary interface implementation 69 | func (m *SignupParamsBody) UnmarshalBinary(b []byte) error { 70 | var res SignupParamsBody 71 | if err := swag.ReadJSON(b, &res); err != nil { 72 | return err 73 | } 74 | *m = res 75 | return nil 76 | } 77 | -------------------------------------------------------------------------------- /gen/restapi/operations/field/delete_field.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package field 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // DeleteFieldHandlerFunc turns a function with the right signature into a delete field handler 15 | type DeleteFieldHandlerFunc func(DeleteFieldParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn DeleteFieldHandlerFunc) Handle(params DeleteFieldParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // DeleteFieldHandler interface for that can handle valid delete field params 23 | type DeleteFieldHandler interface { 24 | Handle(DeleteFieldParams) middleware.Responder 25 | } 26 | 27 | // NewDeleteField creates a new http.Handler for the delete field operation 28 | func NewDeleteField(ctx *middleware.Context, handler DeleteFieldHandler) *DeleteField { 29 | return &DeleteField{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*DeleteField swagger:route DELETE /projects/{projectId}/fields/{id} field deleteField 33 | 34 | Delete a field 35 | 36 | */ 37 | type DeleteField struct { 38 | Context *middleware.Context 39 | Handler DeleteFieldHandler 40 | } 41 | 42 | func (o *DeleteField) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewDeleteFieldParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/restapi/operations/field/update_field.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package field 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // UpdateFieldHandlerFunc turns a function with the right signature into a update field handler 15 | type UpdateFieldHandlerFunc func(UpdateFieldParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn UpdateFieldHandlerFunc) Handle(params UpdateFieldParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // UpdateFieldHandler interface for that can handle valid update field params 23 | type UpdateFieldHandler interface { 24 | Handle(UpdateFieldParams) middleware.Responder 25 | } 26 | 27 | // NewUpdateField creates a new http.Handler for the update field operation 28 | func NewUpdateField(ctx *middleware.Context, handler UpdateFieldHandler) *UpdateField { 29 | return &UpdateField{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*UpdateField swagger:route PUT /projects/{projectId}/fields/{id} field updateField 33 | 34 | Update a field 35 | 36 | */ 37 | type UpdateField struct { 38 | Context *middleware.Context 39 | Handler UpdateFieldHandler 40 | } 41 | 42 | func (o *UpdateField) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewUpdateFieldParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/models/session_relationships_user.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | ) 14 | 15 | // SessionRelationshipsUser session relationships user 16 | // swagger:model sessionRelationshipsUser 17 | type SessionRelationshipsUser struct { 18 | 19 | // data 20 | Data *Relationship `json:"data,omitempty"` 21 | } 22 | 23 | // Validate validates this session relationships user 24 | func (m *SessionRelationshipsUser) Validate(formats strfmt.Registry) error { 25 | var res []error 26 | 27 | if err := m.validateData(formats); err != nil { 28 | // prop 29 | res = append(res, err) 30 | } 31 | 32 | if len(res) > 0 { 33 | return errors.CompositeValidationError(res...) 34 | } 35 | return nil 36 | } 37 | 38 | func (m *SessionRelationshipsUser) validateData(formats strfmt.Registry) error { 39 | 40 | if swag.IsZero(m.Data) { // not required 41 | return nil 42 | } 43 | 44 | if m.Data != nil { 45 | 46 | if err := m.Data.Validate(formats); err != nil { 47 | if ve, ok := err.(*errors.Validation); ok { 48 | return ve.ValidateName("data") 49 | } 50 | return err 51 | } 52 | 53 | } 54 | 55 | return nil 56 | } 57 | 58 | // MarshalBinary interface implementation 59 | func (m *SessionRelationshipsUser) MarshalBinary() ([]byte, error) { 60 | if m == nil { 61 | return nil, nil 62 | } 63 | return swag.WriteJSON(m) 64 | } 65 | 66 | // UnmarshalBinary interface implementation 67 | func (m *SessionRelationshipsUser) UnmarshalBinary(b []byte) error { 68 | var res SessionRelationshipsUser 69 | if err := swag.ReadJSON(b, &res); err != nil { 70 | return err 71 | } 72 | *m = res 73 | return nil 74 | } 75 | -------------------------------------------------------------------------------- /gen/models/user_relationships.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | "github.com/go-openapi/validate" 14 | ) 15 | 16 | // UserRelationships user relationships 17 | // swagger:model UserRelationships 18 | type UserRelationships struct { 19 | 20 | // role 21 | // Required: true 22 | Role *UserRelationshipsRole `json:"role"` 23 | } 24 | 25 | // Validate validates this user relationships 26 | func (m *UserRelationships) Validate(formats strfmt.Registry) error { 27 | var res []error 28 | 29 | if err := m.validateRole(formats); err != nil { 30 | // prop 31 | res = append(res, err) 32 | } 33 | 34 | if len(res) > 0 { 35 | return errors.CompositeValidationError(res...) 36 | } 37 | return nil 38 | } 39 | 40 | func (m *UserRelationships) validateRole(formats strfmt.Registry) error { 41 | 42 | if err := validate.Required("role", "body", m.Role); err != nil { 43 | return err 44 | } 45 | 46 | if m.Role != nil { 47 | 48 | if err := m.Role.Validate(formats); err != nil { 49 | if ve, ok := err.(*errors.Validation); ok { 50 | return ve.ValidateName("role") 51 | } 52 | return err 53 | } 54 | 55 | } 56 | 57 | return nil 58 | } 59 | 60 | // MarshalBinary interface implementation 61 | func (m *UserRelationships) MarshalBinary() ([]byte, error) { 62 | if m == nil { 63 | return nil, nil 64 | } 65 | return swag.WriteJSON(m) 66 | } 67 | 68 | // UnmarshalBinary interface implementation 69 | func (m *UserRelationships) UnmarshalBinary(b []byte) error { 70 | var res UserRelationships 71 | if err := swag.ReadJSON(b, &res); err != nil { 72 | return err 73 | } 74 | *m = res 75 | return nil 76 | } 77 | -------------------------------------------------------------------------------- /gen/restapi/operations/item_type/get_item_type.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package item_type 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // GetItemTypeHandlerFunc turns a function with the right signature into a get item type handler 15 | type GetItemTypeHandlerFunc func(GetItemTypeParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn GetItemTypeHandlerFunc) Handle(params GetItemTypeParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // GetItemTypeHandler interface for that can handle valid get item type params 23 | type GetItemTypeHandler interface { 24 | Handle(GetItemTypeParams) middleware.Responder 25 | } 26 | 27 | // NewGetItemType creates a new http.Handler for the get item type operation 28 | func NewGetItemType(ctx *middleware.Context, handler GetItemTypeHandler) *GetItemType { 29 | return &GetItemType{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*GetItemType swagger:route GET /projects/{projectId}/item-types/{id} item-type getItemType 33 | 34 | Get a model 35 | 36 | */ 37 | type GetItemType struct { 38 | Context *middleware.Context 39 | Handler GetItemTypeHandler 40 | } 41 | 42 | func (o *GetItemType) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewGetItemTypeParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/restapi/operations/field/create_field.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package field 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // CreateFieldHandlerFunc turns a function with the right signature into a create field handler 15 | type CreateFieldHandlerFunc func(CreateFieldParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn CreateFieldHandlerFunc) Handle(params CreateFieldParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // CreateFieldHandler interface for that can handle valid create field params 23 | type CreateFieldHandler interface { 24 | Handle(CreateFieldParams) middleware.Responder 25 | } 26 | 27 | // NewCreateField creates a new http.Handler for the create field operation 28 | func NewCreateField(ctx *middleware.Context, handler CreateFieldHandler) *CreateField { 29 | return &CreateField{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*CreateField swagger:route POST /projects/{projectId}/item-types/{itemTypeId}/fields field createField 33 | 34 | Create a new field 35 | 36 | */ 37 | type CreateField struct { 38 | Context *middleware.Context 39 | Handler CreateFieldHandler 40 | } 41 | 42 | func (o *CreateField) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewCreateFieldParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/models/field_relationships_item_type.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | ) 14 | 15 | // FieldRelationshipsItemType field relationships item type 16 | // swagger:model fieldRelationshipsItemType 17 | type FieldRelationshipsItemType struct { 18 | 19 | // data 20 | Data *Relationship `json:"data,omitempty"` 21 | } 22 | 23 | // Validate validates this field relationships item type 24 | func (m *FieldRelationshipsItemType) Validate(formats strfmt.Registry) error { 25 | var res []error 26 | 27 | if err := m.validateData(formats); err != nil { 28 | // prop 29 | res = append(res, err) 30 | } 31 | 32 | if len(res) > 0 { 33 | return errors.CompositeValidationError(res...) 34 | } 35 | return nil 36 | } 37 | 38 | func (m *FieldRelationshipsItemType) validateData(formats strfmt.Registry) error { 39 | 40 | if swag.IsZero(m.Data) { // not required 41 | return nil 42 | } 43 | 44 | if m.Data != nil { 45 | 46 | if err := m.Data.Validate(formats); err != nil { 47 | if ve, ok := err.(*errors.Validation); ok { 48 | return ve.ValidateName("data") 49 | } 50 | return err 51 | } 52 | 53 | } 54 | 55 | return nil 56 | } 57 | 58 | // MarshalBinary interface implementation 59 | func (m *FieldRelationshipsItemType) MarshalBinary() ([]byte, error) { 60 | if m == nil { 61 | return nil, nil 62 | } 63 | return swag.WriteJSON(m) 64 | } 65 | 66 | // UnmarshalBinary interface implementation 67 | func (m *FieldRelationshipsItemType) UnmarshalBinary(b []byte) error { 68 | var res FieldRelationshipsItemType 69 | if err := swag.ReadJSON(b, &res); err != nil { 70 | return err 71 | } 72 | *m = res 73 | return nil 74 | } 75 | -------------------------------------------------------------------------------- /gen/restapi/operations/project/create_project.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package project 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // CreateProjectHandlerFunc turns a function with the right signature into a create project handler 15 | type CreateProjectHandlerFunc func(CreateProjectParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn CreateProjectHandlerFunc) Handle(params CreateProjectParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // CreateProjectHandler interface for that can handle valid create project params 23 | type CreateProjectHandler interface { 24 | Handle(CreateProjectParams) middleware.Responder 25 | } 26 | 27 | // NewCreateProject creates a new http.Handler for the create project operation 28 | func NewCreateProject(ctx *middleware.Context, handler CreateProjectHandler) *CreateProject { 29 | return &CreateProject{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*CreateProject swagger:route POST /projects project createProject 33 | 34 | Create a project 35 | 36 | */ 37 | type CreateProject struct { 38 | Context *middleware.Context 39 | Handler CreateProjectHandler 40 | } 41 | 42 | func (o *CreateProject) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewCreateProjectParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/restapi/operations/project/delete_project.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package project 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // DeleteProjectHandlerFunc turns a function with the right signature into a delete project handler 15 | type DeleteProjectHandlerFunc func(DeleteProjectParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn DeleteProjectHandlerFunc) Handle(params DeleteProjectParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // DeleteProjectHandler interface for that can handle valid delete project params 23 | type DeleteProjectHandler interface { 24 | Handle(DeleteProjectParams) middleware.Responder 25 | } 26 | 27 | // NewDeleteProject creates a new http.Handler for the delete project operation 28 | func NewDeleteProject(ctx *middleware.Context, handler DeleteProjectHandler) *DeleteProject { 29 | return &DeleteProject{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*DeleteProject swagger:route DELETE /projects/{id} project deleteProject 33 | 34 | Delete a project 35 | 36 | */ 37 | type DeleteProject struct { 38 | Context *middleware.Context 39 | Handler DeleteProjectHandler 40 | } 41 | 42 | func (o *DeleteProject) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewDeleteProjectParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/restapi/operations/project/update_project.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package project 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // UpdateProjectHandlerFunc turns a function with the right signature into a update project handler 15 | type UpdateProjectHandlerFunc func(UpdateProjectParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn UpdateProjectHandlerFunc) Handle(params UpdateProjectParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // UpdateProjectHandler interface for that can handle valid update project params 23 | type UpdateProjectHandler interface { 24 | Handle(UpdateProjectParams) middleware.Responder 25 | } 26 | 27 | // NewUpdateProject creates a new http.Handler for the update project operation 28 | func NewUpdateProject(ctx *middleware.Context, handler UpdateProjectHandler) *UpdateProject { 29 | return &UpdateProject{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*UpdateProject swagger:route PUT /projects/{id} project updateProject 33 | 34 | Update a project 35 | 36 | */ 37 | type UpdateProject struct { 38 | Context *middleware.Context 39 | Handler UpdateProjectHandler 40 | } 41 | 42 | func (o *UpdateProject) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewUpdateProjectParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/models/item_relationships_last_editor.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | ) 14 | 15 | // ItemRelationshipsLastEditor item relationships last editor 16 | // swagger:model itemRelationshipsLastEditor 17 | type ItemRelationshipsLastEditor struct { 18 | 19 | // data 20 | Data *Relationship `json:"data,omitempty"` 21 | } 22 | 23 | // Validate validates this item relationships last editor 24 | func (m *ItemRelationshipsLastEditor) Validate(formats strfmt.Registry) error { 25 | var res []error 26 | 27 | if err := m.validateData(formats); err != nil { 28 | // prop 29 | res = append(res, err) 30 | } 31 | 32 | if len(res) > 0 { 33 | return errors.CompositeValidationError(res...) 34 | } 35 | return nil 36 | } 37 | 38 | func (m *ItemRelationshipsLastEditor) validateData(formats strfmt.Registry) error { 39 | 40 | if swag.IsZero(m.Data) { // not required 41 | return nil 42 | } 43 | 44 | if m.Data != nil { 45 | 46 | if err := m.Data.Validate(formats); err != nil { 47 | if ve, ok := err.(*errors.Validation); ok { 48 | return ve.ValidateName("data") 49 | } 50 | return err 51 | } 52 | 53 | } 54 | 55 | return nil 56 | } 57 | 58 | // MarshalBinary interface implementation 59 | func (m *ItemRelationshipsLastEditor) MarshalBinary() ([]byte, error) { 60 | if m == nil { 61 | return nil, nil 62 | } 63 | return swag.WriteJSON(m) 64 | } 65 | 66 | // UnmarshalBinary interface implementation 67 | func (m *ItemRelationshipsLastEditor) UnmarshalBinary(b []byte) error { 68 | var res ItemRelationshipsLastEditor 69 | if err := swag.ReadJSON(b, &res); err != nil { 70 | return err 71 | } 72 | *m = res 73 | return nil 74 | } 75 | -------------------------------------------------------------------------------- /gen/models/project_relationships_account.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | ) 14 | 15 | // ProjectRelationshipsAccount project relationships account 16 | // swagger:model projectRelationshipsAccount 17 | type ProjectRelationshipsAccount struct { 18 | 19 | // data 20 | Data *Relationship `json:"data,omitempty"` 21 | } 22 | 23 | // Validate validates this project relationships account 24 | func (m *ProjectRelationshipsAccount) Validate(formats strfmt.Registry) error { 25 | var res []error 26 | 27 | if err := m.validateData(formats); err != nil { 28 | // prop 29 | res = append(res, err) 30 | } 31 | 32 | if len(res) > 0 { 33 | return errors.CompositeValidationError(res...) 34 | } 35 | return nil 36 | } 37 | 38 | func (m *ProjectRelationshipsAccount) validateData(formats strfmt.Registry) error { 39 | 40 | if swag.IsZero(m.Data) { // not required 41 | return nil 42 | } 43 | 44 | if m.Data != nil { 45 | 46 | if err := m.Data.Validate(formats); err != nil { 47 | if ve, ok := err.(*errors.Validation); ok { 48 | return ve.ValidateName("data") 49 | } 50 | return err 51 | } 52 | 53 | } 54 | 55 | return nil 56 | } 57 | 58 | // MarshalBinary interface implementation 59 | func (m *ProjectRelationshipsAccount) MarshalBinary() ([]byte, error) { 60 | if m == nil { 61 | return nil, nil 62 | } 63 | return swag.WriteJSON(m) 64 | } 65 | 66 | // UnmarshalBinary interface implementation 67 | func (m *ProjectRelationshipsAccount) UnmarshalBinary(b []byte) error { 68 | var res ProjectRelationshipsAccount 69 | if err := swag.ReadJSON(b, &res); err != nil { 70 | return err 71 | } 72 | *m = res 73 | return nil 74 | } 75 | -------------------------------------------------------------------------------- /gen/models/error.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | "github.com/go-openapi/validate" 14 | ) 15 | 16 | // Error error 17 | // swagger:model Error 18 | type Error struct { 19 | 20 | // code 21 | // Required: true 22 | Code int32 `json:"code"` 23 | 24 | // error 25 | // Required: true 26 | Error string `json:"error"` 27 | } 28 | 29 | // Validate validates this error 30 | func (m *Error) Validate(formats strfmt.Registry) error { 31 | var res []error 32 | 33 | if err := m.validateCode(formats); err != nil { 34 | // prop 35 | res = append(res, err) 36 | } 37 | 38 | if err := m.validateError(formats); err != nil { 39 | // prop 40 | res = append(res, err) 41 | } 42 | 43 | if len(res) > 0 { 44 | return errors.CompositeValidationError(res...) 45 | } 46 | return nil 47 | } 48 | 49 | func (m *Error) validateCode(formats strfmt.Registry) error { 50 | 51 | if err := validate.Required("code", "body", int32(m.Code)); err != nil { 52 | return err 53 | } 54 | 55 | return nil 56 | } 57 | 58 | func (m *Error) validateError(formats strfmt.Registry) error { 59 | 60 | if err := validate.RequiredString("error", "body", string(m.Error)); err != nil { 61 | return err 62 | } 63 | 64 | return nil 65 | } 66 | 67 | // MarshalBinary interface implementation 68 | func (m *Error) MarshalBinary() ([]byte, error) { 69 | if m == nil { 70 | return nil, nil 71 | } 72 | return swag.WriteJSON(m) 73 | } 74 | 75 | // UnmarshalBinary interface implementation 76 | func (m *Error) UnmarshalBinary(b []byte) error { 77 | var res Error 78 | if err := swag.ReadJSON(b, &res); err != nil { 79 | return err 80 | } 81 | *m = res 82 | return nil 83 | } 84 | -------------------------------------------------------------------------------- /gen/models/user_relationships_role.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | "github.com/go-openapi/validate" 14 | ) 15 | 16 | // UserRelationshipsRole user relationships role 17 | // swagger:model userRelationshipsRole 18 | type UserRelationshipsRole struct { 19 | 20 | // data 21 | // Required: true 22 | Data *Relationship `json:"data"` 23 | } 24 | 25 | // Validate validates this user relationships role 26 | func (m *UserRelationshipsRole) Validate(formats strfmt.Registry) error { 27 | var res []error 28 | 29 | if err := m.validateData(formats); err != nil { 30 | // prop 31 | res = append(res, err) 32 | } 33 | 34 | if len(res) > 0 { 35 | return errors.CompositeValidationError(res...) 36 | } 37 | return nil 38 | } 39 | 40 | func (m *UserRelationshipsRole) validateData(formats strfmt.Registry) error { 41 | 42 | if err := validate.Required("data", "body", m.Data); err != nil { 43 | return err 44 | } 45 | 46 | if m.Data != nil { 47 | 48 | if err := m.Data.Validate(formats); err != nil { 49 | if ve, ok := err.(*errors.Validation); ok { 50 | return ve.ValidateName("data") 51 | } 52 | return err 53 | } 54 | 55 | } 56 | 57 | return nil 58 | } 59 | 60 | // MarshalBinary interface implementation 61 | func (m *UserRelationshipsRole) MarshalBinary() ([]byte, error) { 62 | if m == nil { 63 | return nil, nil 64 | } 65 | return swag.WriteJSON(m) 66 | } 67 | 68 | // UnmarshalBinary interface implementation 69 | func (m *UserRelationshipsRole) UnmarshalBinary(b []byte) error { 70 | var res UserRelationshipsRole 71 | if err := swag.ReadJSON(b, &res); err != nil { 72 | return err 73 | } 74 | *m = res 75 | return nil 76 | } 77 | -------------------------------------------------------------------------------- /gen/restapi/operations/item_type/get_item_types.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package item_type 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // GetItemTypesHandlerFunc turns a function with the right signature into a get item types handler 15 | type GetItemTypesHandlerFunc func(GetItemTypesParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn GetItemTypesHandlerFunc) Handle(params GetItemTypesParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // GetItemTypesHandler interface for that can handle valid get item types params 23 | type GetItemTypesHandler interface { 24 | Handle(GetItemTypesParams) middleware.Responder 25 | } 26 | 27 | // NewGetItemTypes creates a new http.Handler for the get item types operation 28 | func NewGetItemTypes(ctx *middleware.Context, handler GetItemTypesHandler) *GetItemTypes { 29 | return &GetItemTypes{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*GetItemTypes swagger:route GET /projects/{projectId}/item-types item-type getItemTypes 33 | 34 | Get the item types for the project 35 | 36 | */ 37 | type GetItemTypes struct { 38 | Context *middleware.Context 39 | Handler GetItemTypesHandler 40 | } 41 | 42 | func (o *GetItemTypes) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewGetItemTypesParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/models/roles_response.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | "strconv" 10 | 11 | strfmt "github.com/go-openapi/strfmt" 12 | 13 | "github.com/go-openapi/errors" 14 | "github.com/go-openapi/swag" 15 | ) 16 | 17 | // RolesResponse roles response 18 | // swagger:model RolesResponse 19 | type RolesResponse struct { 20 | 21 | // data 22 | Data []*Role `json:"data"` 23 | } 24 | 25 | // Validate validates this roles response 26 | func (m *RolesResponse) Validate(formats strfmt.Registry) error { 27 | var res []error 28 | 29 | if err := m.validateData(formats); err != nil { 30 | // prop 31 | res = append(res, err) 32 | } 33 | 34 | if len(res) > 0 { 35 | return errors.CompositeValidationError(res...) 36 | } 37 | return nil 38 | } 39 | 40 | func (m *RolesResponse) validateData(formats strfmt.Registry) error { 41 | 42 | if swag.IsZero(m.Data) { // not required 43 | return nil 44 | } 45 | 46 | for i := 0; i < len(m.Data); i++ { 47 | 48 | if swag.IsZero(m.Data[i]) { // not required 49 | continue 50 | } 51 | 52 | if m.Data[i] != nil { 53 | 54 | if err := m.Data[i].Validate(formats); err != nil { 55 | if ve, ok := err.(*errors.Validation); ok { 56 | return ve.ValidateName("data" + "." + strconv.Itoa(i)) 57 | } 58 | return err 59 | } 60 | 61 | } 62 | 63 | } 64 | 65 | return nil 66 | } 67 | 68 | // MarshalBinary interface implementation 69 | func (m *RolesResponse) MarshalBinary() ([]byte, error) { 70 | if m == nil { 71 | return nil, nil 72 | } 73 | return swag.WriteJSON(m) 74 | } 75 | 76 | // UnmarshalBinary interface implementation 77 | func (m *RolesResponse) UnmarshalBinary(b []byte) error { 78 | var res RolesResponse 79 | if err := swag.ReadJSON(b, &res); err != nil { 80 | return err 81 | } 82 | *m = res 83 | return nil 84 | } 85 | -------------------------------------------------------------------------------- /gen/models/users_response.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | "strconv" 10 | 11 | strfmt "github.com/go-openapi/strfmt" 12 | 13 | "github.com/go-openapi/errors" 14 | "github.com/go-openapi/swag" 15 | ) 16 | 17 | // UsersResponse users response 18 | // swagger:model UsersResponse 19 | type UsersResponse struct { 20 | 21 | // data 22 | Data []*User `json:"data"` 23 | } 24 | 25 | // Validate validates this users response 26 | func (m *UsersResponse) Validate(formats strfmt.Registry) error { 27 | var res []error 28 | 29 | if err := m.validateData(formats); err != nil { 30 | // prop 31 | res = append(res, err) 32 | } 33 | 34 | if len(res) > 0 { 35 | return errors.CompositeValidationError(res...) 36 | } 37 | return nil 38 | } 39 | 40 | func (m *UsersResponse) validateData(formats strfmt.Registry) error { 41 | 42 | if swag.IsZero(m.Data) { // not required 43 | return nil 44 | } 45 | 46 | for i := 0; i < len(m.Data); i++ { 47 | 48 | if swag.IsZero(m.Data[i]) { // not required 49 | continue 50 | } 51 | 52 | if m.Data[i] != nil { 53 | 54 | if err := m.Data[i].Validate(formats); err != nil { 55 | if ve, ok := err.(*errors.Validation); ok { 56 | return ve.ValidateName("data" + "." + strconv.Itoa(i)) 57 | } 58 | return err 59 | } 60 | 61 | } 62 | 63 | } 64 | 65 | return nil 66 | } 67 | 68 | // MarshalBinary interface implementation 69 | func (m *UsersResponse) MarshalBinary() ([]byte, error) { 70 | if m == nil { 71 | return nil, nil 72 | } 73 | return swag.WriteJSON(m) 74 | } 75 | 76 | // UnmarshalBinary interface implementation 77 | func (m *UsersResponse) UnmarshalBinary(b []byte) error { 78 | var res UsersResponse 79 | if err := swag.ReadJSON(b, &res); err != nil { 80 | return err 81 | } 82 | *m = res 83 | return nil 84 | } 85 | -------------------------------------------------------------------------------- /gen/models/fields_response.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | "strconv" 10 | 11 | strfmt "github.com/go-openapi/strfmt" 12 | 13 | "github.com/go-openapi/errors" 14 | "github.com/go-openapi/swag" 15 | ) 16 | 17 | // FieldsResponse fields response 18 | // swagger:model FieldsResponse 19 | type FieldsResponse struct { 20 | 21 | // data 22 | Data []*Field `json:"data"` 23 | } 24 | 25 | // Validate validates this fields response 26 | func (m *FieldsResponse) Validate(formats strfmt.Registry) error { 27 | var res []error 28 | 29 | if err := m.validateData(formats); err != nil { 30 | // prop 31 | res = append(res, err) 32 | } 33 | 34 | if len(res) > 0 { 35 | return errors.CompositeValidationError(res...) 36 | } 37 | return nil 38 | } 39 | 40 | func (m *FieldsResponse) validateData(formats strfmt.Registry) error { 41 | 42 | if swag.IsZero(m.Data) { // not required 43 | return nil 44 | } 45 | 46 | for i := 0; i < len(m.Data); i++ { 47 | 48 | if swag.IsZero(m.Data[i]) { // not required 49 | continue 50 | } 51 | 52 | if m.Data[i] != nil { 53 | 54 | if err := m.Data[i].Validate(formats); err != nil { 55 | if ve, ok := err.(*errors.Validation); ok { 56 | return ve.ValidateName("data" + "." + strconv.Itoa(i)) 57 | } 58 | return err 59 | } 60 | 61 | } 62 | 63 | } 64 | 65 | return nil 66 | } 67 | 68 | // MarshalBinary interface implementation 69 | func (m *FieldsResponse) MarshalBinary() ([]byte, error) { 70 | if m == nil { 71 | return nil, nil 72 | } 73 | return swag.WriteJSON(m) 74 | } 75 | 76 | // UnmarshalBinary interface implementation 77 | func (m *FieldsResponse) UnmarshalBinary(b []byte) error { 78 | var res FieldsResponse 79 | if err := swag.ReadJSON(b, &res); err != nil { 80 | return err 81 | } 82 | *m = res 83 | return nil 84 | } 85 | -------------------------------------------------------------------------------- /gen/restapi/operations/item_type/create_item_type.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package item_type 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // CreateItemTypeHandlerFunc turns a function with the right signature into a create item type handler 15 | type CreateItemTypeHandlerFunc func(CreateItemTypeParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn CreateItemTypeHandlerFunc) Handle(params CreateItemTypeParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // CreateItemTypeHandler interface for that can handle valid create item type params 23 | type CreateItemTypeHandler interface { 24 | Handle(CreateItemTypeParams) middleware.Responder 25 | } 26 | 27 | // NewCreateItemType creates a new http.Handler for the create item type operation 28 | func NewCreateItemType(ctx *middleware.Context, handler CreateItemTypeHandler) *CreateItemType { 29 | return &CreateItemType{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*CreateItemType swagger:route POST /projects/{projectId}/item-types item-type createItemType 33 | 34 | Create a model 35 | 36 | */ 37 | type CreateItemType struct { 38 | Context *middleware.Context 39 | Handler CreateItemTypeHandler 40 | } 41 | 42 | func (o *CreateItemType) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewCreateItemTypeParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/restapi/operations/item_type/update_item_type.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package item_type 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // UpdateItemTypeHandlerFunc turns a function with the right signature into a update item type handler 15 | type UpdateItemTypeHandlerFunc func(UpdateItemTypeParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn UpdateItemTypeHandlerFunc) Handle(params UpdateItemTypeParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // UpdateItemTypeHandler interface for that can handle valid update item type params 23 | type UpdateItemTypeHandler interface { 24 | Handle(UpdateItemTypeParams) middleware.Responder 25 | } 26 | 27 | // NewUpdateItemType creates a new http.Handler for the update item type operation 28 | func NewUpdateItemType(ctx *middleware.Context, handler UpdateItemTypeHandler) *UpdateItemType { 29 | return &UpdateItemType{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*UpdateItemType swagger:route PUT /projects/{projectId}/item-types/{id} item-type updateItemType 33 | 34 | Update a model 35 | 36 | */ 37 | type UpdateItemType struct { 38 | Context *middleware.Context 39 | Handler UpdateItemTypeHandler 40 | } 41 | 42 | func (o *UpdateItemType) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewUpdateItemTypeParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Headless CMS 2 | 3 | This is an attempt to make a Headless CMS in `go`. 4 | 5 | ## API documentation 6 | 7 | You can find the API documentation [here](http://rebilly.github.io/ReDoc/?url=https://raw.githubusercontent.com/Xzya/headless-cms/master/swagger/swagger.yml). 8 | 9 | ## Requirements 10 | 11 | - Go 1.10 12 | - [dep](https://github.com/golang/dep) for installing the dependencies 13 | - [go-swagger](https://github.com/go-swagger/go-swagger) for generating the server stubs 14 | - A database, e.g. PostgreSQL 15 | 16 | ## Running the project 17 | 18 | First, generate the server stub from the swagger definition 19 | 20 | ```bash 21 | ./gen.sh 22 | ``` 23 | 24 | Install the dependencies using dep 25 | 26 | ```bash 27 | dep ensure 28 | ``` 29 | 30 | Build the executable 31 | 32 | ```bash 33 | ./build.sh 34 | ``` 35 | 36 | Run the binary 37 | 38 | ```bash 39 | ./main 40 | ``` 41 | 42 | Run `--help` to check the available parameters 43 | 44 | ```bash 45 | ./main --help 46 | Usage of main: 47 | -database string 48 | The database name (default "cms") 49 | -db-host string 50 | The database hostname (default "localhost") 51 | -db-port string 52 | The database port (default "5432") 53 | -dialect string 54 | The database dialect (default "postgres") 55 | -pass string 56 | The database password (default "test") 57 | -port int 58 | Port to run this service on (default 3000) 59 | -user string 60 | The database username (default "test") 61 | ``` 62 | 63 | ## Dashboard 64 | 65 | You can find a dashboard for the project [here](https://github.com/Xzya/headless-cms-dashboard). 66 | 67 | ## Built using 68 | 69 | - [Swagger](https://swagger.io/), API definition 70 | - [go-swagger 0.15.0](https://github.com/go-swagger/go-swagger/releases/tag/0.15.0), generate server stub based on swagger definition 71 | - [gorm](https://github.com/jinzhu/gorm), database operations 72 | 73 | ## License 74 | 75 | Open sourced under the [MIT license](./LICENSE.md). -------------------------------------------------------------------------------- /gen/restapi/operations/item_type/delete_item_type.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package item_type 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // DeleteItemTypeHandlerFunc turns a function with the right signature into a delete item type handler 15 | type DeleteItemTypeHandlerFunc func(DeleteItemTypeParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn DeleteItemTypeHandlerFunc) Handle(params DeleteItemTypeParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // DeleteItemTypeHandler interface for that can handle valid delete item type params 23 | type DeleteItemTypeHandler interface { 24 | Handle(DeleteItemTypeParams) middleware.Responder 25 | } 26 | 27 | // NewDeleteItemType creates a new http.Handler for the delete item type operation 28 | func NewDeleteItemType(ctx *middleware.Context, handler DeleteItemTypeHandler) *DeleteItemType { 29 | return &DeleteItemType{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*DeleteItemType swagger:route DELETE /projects/{projectId}/item-types/{id} item-type deleteItemType 33 | 34 | Delete a model 35 | 36 | */ 37 | type DeleteItemType struct { 38 | Context *middleware.Context 39 | Handler DeleteItemTypeHandler 40 | } 41 | 42 | func (o *DeleteItemType) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewDeleteItemTypeParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/models/field_attributes_validators_enum.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | "github.com/go-openapi/validate" 14 | ) 15 | 16 | // FieldAttributesValidatorsEnum field attributes validators enum 17 | // swagger:model fieldAttributesValidatorsEnum 18 | type FieldAttributesValidatorsEnum struct { 19 | 20 | // values 21 | // Required: true 22 | // Min Items: 1 23 | Values []string `json:"values"` 24 | } 25 | 26 | // Validate validates this field attributes validators enum 27 | func (m *FieldAttributesValidatorsEnum) Validate(formats strfmt.Registry) error { 28 | var res []error 29 | 30 | if err := m.validateValues(formats); err != nil { 31 | // prop 32 | res = append(res, err) 33 | } 34 | 35 | if len(res) > 0 { 36 | return errors.CompositeValidationError(res...) 37 | } 38 | return nil 39 | } 40 | 41 | func (m *FieldAttributesValidatorsEnum) validateValues(formats strfmt.Registry) error { 42 | 43 | if err := validate.Required("values", "body", m.Values); err != nil { 44 | return err 45 | } 46 | 47 | iValuesSize := int64(len(m.Values)) 48 | 49 | if err := validate.MinItems("values", "body", iValuesSize, 1); err != nil { 50 | return err 51 | } 52 | 53 | return nil 54 | } 55 | 56 | // MarshalBinary interface implementation 57 | func (m *FieldAttributesValidatorsEnum) MarshalBinary() ([]byte, error) { 58 | if m == nil { 59 | return nil, nil 60 | } 61 | return swag.WriteJSON(m) 62 | } 63 | 64 | // UnmarshalBinary interface implementation 65 | func (m *FieldAttributesValidatorsEnum) UnmarshalBinary(b []byte) error { 66 | var res FieldAttributesValidatorsEnum 67 | if err := swag.ReadJSON(b, &res); err != nil { 68 | return err 69 | } 70 | *m = res 71 | return nil 72 | } 73 | -------------------------------------------------------------------------------- /gen/models/item_relationships_item_type.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | "github.com/go-openapi/validate" 14 | ) 15 | 16 | // ItemRelationshipsItemType item relationships item type 17 | // swagger:model itemRelationshipsItemType 18 | type ItemRelationshipsItemType struct { 19 | 20 | // data 21 | // Required: true 22 | Data *Relationship `json:"data"` 23 | } 24 | 25 | // Validate validates this item relationships item type 26 | func (m *ItemRelationshipsItemType) Validate(formats strfmt.Registry) error { 27 | var res []error 28 | 29 | if err := m.validateData(formats); err != nil { 30 | // prop 31 | res = append(res, err) 32 | } 33 | 34 | if len(res) > 0 { 35 | return errors.CompositeValidationError(res...) 36 | } 37 | return nil 38 | } 39 | 40 | func (m *ItemRelationshipsItemType) validateData(formats strfmt.Registry) error { 41 | 42 | if err := validate.Required("data", "body", m.Data); err != nil { 43 | return err 44 | } 45 | 46 | if m.Data != nil { 47 | 48 | if err := m.Data.Validate(formats); err != nil { 49 | if ve, ok := err.(*errors.Validation); ok { 50 | return ve.ValidateName("data") 51 | } 52 | return err 53 | } 54 | 55 | } 56 | 57 | return nil 58 | } 59 | 60 | // MarshalBinary interface implementation 61 | func (m *ItemRelationshipsItemType) MarshalBinary() ([]byte, error) { 62 | if m == nil { 63 | return nil, nil 64 | } 65 | return swag.WriteJSON(m) 66 | } 67 | 68 | // UnmarshalBinary interface implementation 69 | func (m *ItemRelationshipsItemType) UnmarshalBinary(b []byte) error { 70 | var res ItemRelationshipsItemType 71 | if err := swag.ReadJSON(b, &res); err != nil { 72 | return err 73 | } 74 | *m = res 75 | return nil 76 | } 77 | -------------------------------------------------------------------------------- /gen/models/projects_response.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | "strconv" 10 | 11 | strfmt "github.com/go-openapi/strfmt" 12 | 13 | "github.com/go-openapi/errors" 14 | "github.com/go-openapi/swag" 15 | ) 16 | 17 | // ProjectsResponse projects response 18 | // swagger:model ProjectsResponse 19 | type ProjectsResponse struct { 20 | 21 | // data 22 | Data []*Project `json:"data"` 23 | } 24 | 25 | // Validate validates this projects response 26 | func (m *ProjectsResponse) Validate(formats strfmt.Registry) error { 27 | var res []error 28 | 29 | if err := m.validateData(formats); err != nil { 30 | // prop 31 | res = append(res, err) 32 | } 33 | 34 | if len(res) > 0 { 35 | return errors.CompositeValidationError(res...) 36 | } 37 | return nil 38 | } 39 | 40 | func (m *ProjectsResponse) validateData(formats strfmt.Registry) error { 41 | 42 | if swag.IsZero(m.Data) { // not required 43 | return nil 44 | } 45 | 46 | for i := 0; i < len(m.Data); i++ { 47 | 48 | if swag.IsZero(m.Data[i]) { // not required 49 | continue 50 | } 51 | 52 | if m.Data[i] != nil { 53 | 54 | if err := m.Data[i].Validate(formats); err != nil { 55 | if ve, ok := err.(*errors.Validation); ok { 56 | return ve.ValidateName("data" + "." + strconv.Itoa(i)) 57 | } 58 | return err 59 | } 60 | 61 | } 62 | 63 | } 64 | 65 | return nil 66 | } 67 | 68 | // MarshalBinary interface implementation 69 | func (m *ProjectsResponse) MarshalBinary() ([]byte, error) { 70 | if m == nil { 71 | return nil, nil 72 | } 73 | return swag.WriteJSON(m) 74 | } 75 | 76 | // UnmarshalBinary interface implementation 77 | func (m *ProjectsResponse) UnmarshalBinary(b []byte) error { 78 | var res ProjectsResponse 79 | if err := swag.ReadJSON(b, &res); err != nil { 80 | return err 81 | } 82 | *m = res 83 | return nil 84 | } 85 | -------------------------------------------------------------------------------- /gen/models/item_type_relationships_ordering_field.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | ) 14 | 15 | // ItemTypeRelationshipsOrderingField item type relationships ordering field 16 | // swagger:model itemTypeRelationshipsOrderingField 17 | type ItemTypeRelationshipsOrderingField struct { 18 | 19 | // data 20 | Data *Relationship `json:"data,omitempty"` 21 | } 22 | 23 | // Validate validates this item type relationships ordering field 24 | func (m *ItemTypeRelationshipsOrderingField) Validate(formats strfmt.Registry) error { 25 | var res []error 26 | 27 | if err := m.validateData(formats); err != nil { 28 | // prop 29 | res = append(res, err) 30 | } 31 | 32 | if len(res) > 0 { 33 | return errors.CompositeValidationError(res...) 34 | } 35 | return nil 36 | } 37 | 38 | func (m *ItemTypeRelationshipsOrderingField) validateData(formats strfmt.Registry) error { 39 | 40 | if swag.IsZero(m.Data) { // not required 41 | return nil 42 | } 43 | 44 | if m.Data != nil { 45 | 46 | if err := m.Data.Validate(formats); err != nil { 47 | if ve, ok := err.(*errors.Validation); ok { 48 | return ve.ValidateName("data") 49 | } 50 | return err 51 | } 52 | 53 | } 54 | 55 | return nil 56 | } 57 | 58 | // MarshalBinary interface implementation 59 | func (m *ItemTypeRelationshipsOrderingField) MarshalBinary() ([]byte, error) { 60 | if m == nil { 61 | return nil, nil 62 | } 63 | return swag.WriteJSON(m) 64 | } 65 | 66 | // UnmarshalBinary interface implementation 67 | func (m *ItemTypeRelationshipsOrderingField) UnmarshalBinary(b []byte) error { 68 | var res ItemTypeRelationshipsOrderingField 69 | if err := swag.ReadJSON(b, &res); err != nil { 70 | return err 71 | } 72 | *m = res 73 | return nil 74 | } 75 | -------------------------------------------------------------------------------- /gen/models/item_type_relationships_singleton_item.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | ) 14 | 15 | // ItemTypeRelationshipsSingletonItem item type relationships singleton item 16 | // swagger:model itemTypeRelationshipsSingletonItem 17 | type ItemTypeRelationshipsSingletonItem struct { 18 | 19 | // data 20 | Data *Relationship `json:"data,omitempty"` 21 | } 22 | 23 | // Validate validates this item type relationships singleton item 24 | func (m *ItemTypeRelationshipsSingletonItem) Validate(formats strfmt.Registry) error { 25 | var res []error 26 | 27 | if err := m.validateData(formats); err != nil { 28 | // prop 29 | res = append(res, err) 30 | } 31 | 32 | if len(res) > 0 { 33 | return errors.CompositeValidationError(res...) 34 | } 35 | return nil 36 | } 37 | 38 | func (m *ItemTypeRelationshipsSingletonItem) validateData(formats strfmt.Registry) error { 39 | 40 | if swag.IsZero(m.Data) { // not required 41 | return nil 42 | } 43 | 44 | if m.Data != nil { 45 | 46 | if err := m.Data.Validate(formats); err != nil { 47 | if ve, ok := err.(*errors.Validation); ok { 48 | return ve.ValidateName("data") 49 | } 50 | return err 51 | } 52 | 53 | } 54 | 55 | return nil 56 | } 57 | 58 | // MarshalBinary interface implementation 59 | func (m *ItemTypeRelationshipsSingletonItem) MarshalBinary() ([]byte, error) { 60 | if m == nil { 61 | return nil, nil 62 | } 63 | return swag.WriteJSON(m) 64 | } 65 | 66 | // UnmarshalBinary interface implementation 67 | func (m *ItemTypeRelationshipsSingletonItem) UnmarshalBinary(b []byte) error { 68 | var res ItemTypeRelationshipsSingletonItem 69 | if err := swag.ReadJSON(b, &res); err != nil { 70 | return err 71 | } 72 | *m = res 73 | return nil 74 | } 75 | -------------------------------------------------------------------------------- /gen/models/item_types_response.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | "strconv" 10 | 11 | strfmt "github.com/go-openapi/strfmt" 12 | 13 | "github.com/go-openapi/errors" 14 | "github.com/go-openapi/swag" 15 | ) 16 | 17 | // ItemTypesResponse item types response 18 | // swagger:model ItemTypesResponse 19 | type ItemTypesResponse struct { 20 | 21 | // data 22 | Data []*ItemType `json:"data"` 23 | } 24 | 25 | // Validate validates this item types response 26 | func (m *ItemTypesResponse) Validate(formats strfmt.Registry) error { 27 | var res []error 28 | 29 | if err := m.validateData(formats); err != nil { 30 | // prop 31 | res = append(res, err) 32 | } 33 | 34 | if len(res) > 0 { 35 | return errors.CompositeValidationError(res...) 36 | } 37 | return nil 38 | } 39 | 40 | func (m *ItemTypesResponse) validateData(formats strfmt.Registry) error { 41 | 42 | if swag.IsZero(m.Data) { // not required 43 | return nil 44 | } 45 | 46 | for i := 0; i < len(m.Data); i++ { 47 | 48 | if swag.IsZero(m.Data[i]) { // not required 49 | continue 50 | } 51 | 52 | if m.Data[i] != nil { 53 | 54 | if err := m.Data[i].Validate(formats); err != nil { 55 | if ve, ok := err.(*errors.Validation); ok { 56 | return ve.ValidateName("data" + "." + strconv.Itoa(i)) 57 | } 58 | return err 59 | } 60 | 61 | } 62 | 63 | } 64 | 65 | return nil 66 | } 67 | 68 | // MarshalBinary interface implementation 69 | func (m *ItemTypesResponse) MarshalBinary() ([]byte, error) { 70 | if m == nil { 71 | return nil, nil 72 | } 73 | return swag.WriteJSON(m) 74 | } 75 | 76 | // UnmarshalBinary interface implementation 77 | func (m *ItemTypesResponse) UnmarshalBinary(b []byte) error { 78 | var res ItemTypesResponse 79 | if err := swag.ReadJSON(b, &res); err != nil { 80 | return err 81 | } 82 | *m = res 83 | return nil 84 | } 85 | -------------------------------------------------------------------------------- /gen/restapi/operations/field/get_project_fields.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package field 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // GetProjectFieldsHandlerFunc turns a function with the right signature into a get project fields handler 15 | type GetProjectFieldsHandlerFunc func(GetProjectFieldsParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn GetProjectFieldsHandlerFunc) Handle(params GetProjectFieldsParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // GetProjectFieldsHandler interface for that can handle valid get project fields params 23 | type GetProjectFieldsHandler interface { 24 | Handle(GetProjectFieldsParams) middleware.Responder 25 | } 26 | 27 | // NewGetProjectFields creates a new http.Handler for the get project fields operation 28 | func NewGetProjectFields(ctx *middleware.Context, handler GetProjectFieldsHandler) *GetProjectFields { 29 | return &GetProjectFields{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*GetProjectFields swagger:route GET /projects/{projectId}/fields field getProjectFields 33 | 34 | Get all the fields of the project 35 | 36 | */ 37 | type GetProjectFields struct { 38 | Context *middleware.Context 39 | Handler GetProjectFieldsHandler 40 | } 41 | 42 | func (o *GetProjectFields) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewGetProjectFieldsParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/models/item_type_attributes.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | "github.com/go-openapi/validate" 14 | ) 15 | 16 | // ItemTypeAttributes item type attributes 17 | // swagger:model itemTypeAttributes 18 | type ItemTypeAttributes struct { 19 | 20 | // api key 21 | // Required: true 22 | // Max Length: 32 23 | // Min Length: 1 24 | APIKey string `json:"apiKey"` 25 | 26 | // name 27 | Name string `json:"name,omitempty"` 28 | } 29 | 30 | // Validate validates this item type attributes 31 | func (m *ItemTypeAttributes) Validate(formats strfmt.Registry) error { 32 | var res []error 33 | 34 | if err := m.validateAPIKey(formats); err != nil { 35 | // prop 36 | res = append(res, err) 37 | } 38 | 39 | if len(res) > 0 { 40 | return errors.CompositeValidationError(res...) 41 | } 42 | return nil 43 | } 44 | 45 | func (m *ItemTypeAttributes) validateAPIKey(formats strfmt.Registry) error { 46 | 47 | if err := validate.RequiredString("apiKey", "body", string(m.APIKey)); err != nil { 48 | return err 49 | } 50 | 51 | if err := validate.MinLength("apiKey", "body", string(m.APIKey), 1); err != nil { 52 | return err 53 | } 54 | 55 | if err := validate.MaxLength("apiKey", "body", string(m.APIKey), 32); err != nil { 56 | return err 57 | } 58 | 59 | return nil 60 | } 61 | 62 | // MarshalBinary interface implementation 63 | func (m *ItemTypeAttributes) MarshalBinary() ([]byte, error) { 64 | if m == nil { 65 | return nil, nil 66 | } 67 | return swag.WriteJSON(m) 68 | } 69 | 70 | // UnmarshalBinary interface implementation 71 | func (m *ItemTypeAttributes) UnmarshalBinary(b []byte) error { 72 | var res ItemTypeAttributes 73 | if err := swag.ReadJSON(b, &res); err != nil { 74 | return err 75 | } 76 | *m = res 77 | return nil 78 | } 79 | -------------------------------------------------------------------------------- /gen/restapi/operations/item_type/duplicate_item_type.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package item_type 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | middleware "github.com/go-openapi/runtime/middleware" 12 | ) 13 | 14 | // DuplicateItemTypeHandlerFunc turns a function with the right signature into a duplicate item type handler 15 | type DuplicateItemTypeHandlerFunc func(DuplicateItemTypeParams) middleware.Responder 16 | 17 | // Handle executing the request and returning a response 18 | func (fn DuplicateItemTypeHandlerFunc) Handle(params DuplicateItemTypeParams) middleware.Responder { 19 | return fn(params) 20 | } 21 | 22 | // DuplicateItemTypeHandler interface for that can handle valid duplicate item type params 23 | type DuplicateItemTypeHandler interface { 24 | Handle(DuplicateItemTypeParams) middleware.Responder 25 | } 26 | 27 | // NewDuplicateItemType creates a new http.Handler for the duplicate item type operation 28 | func NewDuplicateItemType(ctx *middleware.Context, handler DuplicateItemTypeHandler) *DuplicateItemType { 29 | return &DuplicateItemType{Context: ctx, Handler: handler} 30 | } 31 | 32 | /*DuplicateItemType swagger:route POST /projects/{projectId}/item-types/{id}/duplicate item-type duplicateItemType 33 | 34 | Duplicate a model 35 | 36 | */ 37 | type DuplicateItemType struct { 38 | Context *middleware.Context 39 | Handler DuplicateItemTypeHandler 40 | } 41 | 42 | func (o *DuplicateItemType) ServeHTTP(rw http.ResponseWriter, r *http.Request) { 43 | route, rCtx, _ := o.Context.RouteInfo(r) 44 | if rCtx != nil { 45 | r = rCtx 46 | } 47 | var Params = NewDuplicateItemTypeParams() 48 | 49 | if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params 50 | o.Context.Respond(rw, r, route.Produces, route, err) 51 | return 52 | } 53 | 54 | res := o.Handler.Handle(Params) // actually handle the request 55 | 56 | o.Context.Respond(rw, r, route.Produces, route, res) 57 | 58 | } 59 | -------------------------------------------------------------------------------- /gen/restapi/operations/project/get_project_parameters.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package project 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/runtime/middleware" 13 | 14 | strfmt "github.com/go-openapi/strfmt" 15 | ) 16 | 17 | // NewGetProjectParams creates a new GetProjectParams object 18 | // no default values defined in spec. 19 | func NewGetProjectParams() GetProjectParams { 20 | 21 | return GetProjectParams{} 22 | } 23 | 24 | // GetProjectParams contains all the bound params for the get project operation 25 | // typically these are obtained from a http.Request 26 | // 27 | // swagger:parameters getProject 28 | type GetProjectParams struct { 29 | 30 | // HTTP Request Object 31 | HTTPRequest *http.Request `json:"-"` 32 | 33 | /*The project id 34 | Required: true 35 | In: path 36 | */ 37 | ID string 38 | } 39 | 40 | // BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface 41 | // for simple values it will use straight method calls. 42 | // 43 | // To ensure default values, the struct must have been initialized with NewGetProjectParams() beforehand. 44 | func (o *GetProjectParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error { 45 | var res []error 46 | 47 | o.HTTPRequest = r 48 | 49 | rID, rhkID, _ := route.Params.GetOK("id") 50 | if err := o.bindID(rID, rhkID, route.Formats); err != nil { 51 | res = append(res, err) 52 | } 53 | 54 | if len(res) > 0 { 55 | return errors.CompositeValidationError(res...) 56 | } 57 | return nil 58 | } 59 | 60 | func (o *GetProjectParams) bindID(rawData []string, hasKey bool, formats strfmt.Registry) error { 61 | var raw string 62 | if len(rawData) > 0 { 63 | raw = rawData[len(rawData)-1] 64 | } 65 | 66 | // Required: true 67 | // Parameter is provided by construction from the route 68 | 69 | o.ID = raw 70 | 71 | return nil 72 | } 73 | -------------------------------------------------------------------------------- /gen/models/role_attributes.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | strfmt "github.com/go-openapi/strfmt" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/swag" 13 | "github.com/go-openapi/validate" 14 | ) 15 | 16 | // RoleAttributes role attributes 17 | // swagger:model roleAttributes 18 | type RoleAttributes struct { 19 | 20 | // can edit project 21 | CanEditProject bool `json:"canEditProject,omitempty"` 22 | 23 | // can edit schema 24 | CanEditSchema bool `json:"canEditSchema,omitempty"` 25 | 26 | // can manage access tokens 27 | CanManageAccessTokens bool `json:"canManageAccessTokens,omitempty"` 28 | 29 | // can manage users 30 | CanManageUsers bool `json:"canManageUsers,omitempty"` 31 | 32 | // can publish content 33 | CanPublishContent bool `json:"canPublishContent,omitempty"` 34 | 35 | // name 36 | // Required: true 37 | Name string `json:"name"` 38 | } 39 | 40 | // Validate validates this role attributes 41 | func (m *RoleAttributes) Validate(formats strfmt.Registry) error { 42 | var res []error 43 | 44 | if err := m.validateName(formats); err != nil { 45 | // prop 46 | res = append(res, err) 47 | } 48 | 49 | if len(res) > 0 { 50 | return errors.CompositeValidationError(res...) 51 | } 52 | return nil 53 | } 54 | 55 | func (m *RoleAttributes) validateName(formats strfmt.Registry) error { 56 | 57 | if err := validate.RequiredString("name", "body", string(m.Name)); err != nil { 58 | return err 59 | } 60 | 61 | return nil 62 | } 63 | 64 | // MarshalBinary interface implementation 65 | func (m *RoleAttributes) MarshalBinary() ([]byte, error) { 66 | if m == nil { 67 | return nil, nil 68 | } 69 | return swag.WriteJSON(m) 70 | } 71 | 72 | // UnmarshalBinary interface implementation 73 | func (m *RoleAttributes) UnmarshalBinary(b []byte) error { 74 | var res RoleAttributes 75 | if err := swag.ReadJSON(b, &res); err != nil { 76 | return err 77 | } 78 | *m = res 79 | return nil 80 | } 81 | -------------------------------------------------------------------------------- /gen/models/item_type_relationships_fields.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package models 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | "strconv" 10 | 11 | strfmt "github.com/go-openapi/strfmt" 12 | 13 | "github.com/go-openapi/errors" 14 | "github.com/go-openapi/swag" 15 | ) 16 | 17 | // ItemTypeRelationshipsFields item type relationships fields 18 | // swagger:model itemTypeRelationshipsFields 19 | type ItemTypeRelationshipsFields struct { 20 | 21 | // data 22 | Data []*Relationship `json:"data"` 23 | } 24 | 25 | // Validate validates this item type relationships fields 26 | func (m *ItemTypeRelationshipsFields) Validate(formats strfmt.Registry) error { 27 | var res []error 28 | 29 | if err := m.validateData(formats); err != nil { 30 | // prop 31 | res = append(res, err) 32 | } 33 | 34 | if len(res) > 0 { 35 | return errors.CompositeValidationError(res...) 36 | } 37 | return nil 38 | } 39 | 40 | func (m *ItemTypeRelationshipsFields) validateData(formats strfmt.Registry) error { 41 | 42 | if swag.IsZero(m.Data) { // not required 43 | return nil 44 | } 45 | 46 | for i := 0; i < len(m.Data); i++ { 47 | 48 | if swag.IsZero(m.Data[i]) { // not required 49 | continue 50 | } 51 | 52 | if m.Data[i] != nil { 53 | 54 | if err := m.Data[i].Validate(formats); err != nil { 55 | if ve, ok := err.(*errors.Validation); ok { 56 | return ve.ValidateName("data" + "." + strconv.Itoa(i)) 57 | } 58 | return err 59 | } 60 | 61 | } 62 | 63 | } 64 | 65 | return nil 66 | } 67 | 68 | // MarshalBinary interface implementation 69 | func (m *ItemTypeRelationshipsFields) MarshalBinary() ([]byte, error) { 70 | if m == nil { 71 | return nil, nil 72 | } 73 | return swag.WriteJSON(m) 74 | } 75 | 76 | // UnmarshalBinary interface implementation 77 | func (m *ItemTypeRelationshipsFields) UnmarshalBinary(b []byte) error { 78 | var res ItemTypeRelationshipsFields 79 | if err := swag.ReadJSON(b, &res); err != nil { 80 | return err 81 | } 82 | *m = res 83 | return nil 84 | } 85 | -------------------------------------------------------------------------------- /gen/restapi/operations/role/get_roles_parameters.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package role 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/runtime/middleware" 13 | 14 | strfmt "github.com/go-openapi/strfmt" 15 | ) 16 | 17 | // NewGetRolesParams creates a new GetRolesParams object 18 | // no default values defined in spec. 19 | func NewGetRolesParams() GetRolesParams { 20 | 21 | return GetRolesParams{} 22 | } 23 | 24 | // GetRolesParams contains all the bound params for the get roles operation 25 | // typically these are obtained from a http.Request 26 | // 27 | // swagger:parameters getRoles 28 | type GetRolesParams struct { 29 | 30 | // HTTP Request Object 31 | HTTPRequest *http.Request `json:"-"` 32 | 33 | /*The project id 34 | Required: true 35 | In: path 36 | */ 37 | ProjectID string 38 | } 39 | 40 | // BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface 41 | // for simple values it will use straight method calls. 42 | // 43 | // To ensure default values, the struct must have been initialized with NewGetRolesParams() beforehand. 44 | func (o *GetRolesParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error { 45 | var res []error 46 | 47 | o.HTTPRequest = r 48 | 49 | rProjectID, rhkProjectID, _ := route.Params.GetOK("projectId") 50 | if err := o.bindProjectID(rProjectID, rhkProjectID, route.Formats); err != nil { 51 | res = append(res, err) 52 | } 53 | 54 | if len(res) > 0 { 55 | return errors.CompositeValidationError(res...) 56 | } 57 | return nil 58 | } 59 | 60 | func (o *GetRolesParams) bindProjectID(rawData []string, hasKey bool, formats strfmt.Registry) error { 61 | var raw string 62 | if len(rawData) > 0 { 63 | raw = rawData[len(rawData)-1] 64 | } 65 | 66 | // Required: true 67 | // Parameter is provided by construction from the route 68 | 69 | o.ProjectID = raw 70 | 71 | return nil 72 | } 73 | -------------------------------------------------------------------------------- /gen/restapi/operations/user/get_users_parameters.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package user 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/runtime/middleware" 13 | 14 | strfmt "github.com/go-openapi/strfmt" 15 | ) 16 | 17 | // NewGetUsersParams creates a new GetUsersParams object 18 | // no default values defined in spec. 19 | func NewGetUsersParams() GetUsersParams { 20 | 21 | return GetUsersParams{} 22 | } 23 | 24 | // GetUsersParams contains all the bound params for the get users operation 25 | // typically these are obtained from a http.Request 26 | // 27 | // swagger:parameters getUsers 28 | type GetUsersParams struct { 29 | 30 | // HTTP Request Object 31 | HTTPRequest *http.Request `json:"-"` 32 | 33 | /*The project id 34 | Required: true 35 | In: path 36 | */ 37 | ProjectID string 38 | } 39 | 40 | // BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface 41 | // for simple values it will use straight method calls. 42 | // 43 | // To ensure default values, the struct must have been initialized with NewGetUsersParams() beforehand. 44 | func (o *GetUsersParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error { 45 | var res []error 46 | 47 | o.HTTPRequest = r 48 | 49 | rProjectID, rhkProjectID, _ := route.Params.GetOK("projectId") 50 | if err := o.bindProjectID(rProjectID, rhkProjectID, route.Formats); err != nil { 51 | res = append(res, err) 52 | } 53 | 54 | if len(res) > 0 { 55 | return errors.CompositeValidationError(res...) 56 | } 57 | return nil 58 | } 59 | 60 | func (o *GetUsersParams) bindProjectID(rawData []string, hasKey bool, formats strfmt.Registry) error { 61 | var raw string 62 | if len(rawData) > 0 { 63 | raw = rawData[len(rawData)-1] 64 | } 65 | 66 | // Required: true 67 | // Parameter is provided by construction from the route 68 | 69 | o.ProjectID = raw 70 | 71 | return nil 72 | } 73 | -------------------------------------------------------------------------------- /gen/restapi/operations/project/delete_project_parameters.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package project 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/runtime/middleware" 13 | 14 | strfmt "github.com/go-openapi/strfmt" 15 | ) 16 | 17 | // NewDeleteProjectParams creates a new DeleteProjectParams object 18 | // no default values defined in spec. 19 | func NewDeleteProjectParams() DeleteProjectParams { 20 | 21 | return DeleteProjectParams{} 22 | } 23 | 24 | // DeleteProjectParams contains all the bound params for the delete project operation 25 | // typically these are obtained from a http.Request 26 | // 27 | // swagger:parameters deleteProject 28 | type DeleteProjectParams struct { 29 | 30 | // HTTP Request Object 31 | HTTPRequest *http.Request `json:"-"` 32 | 33 | /*The project id 34 | Required: true 35 | In: path 36 | */ 37 | ID string 38 | } 39 | 40 | // BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface 41 | // for simple values it will use straight method calls. 42 | // 43 | // To ensure default values, the struct must have been initialized with NewDeleteProjectParams() beforehand. 44 | func (o *DeleteProjectParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error { 45 | var res []error 46 | 47 | o.HTTPRequest = r 48 | 49 | rID, rhkID, _ := route.Params.GetOK("id") 50 | if err := o.bindID(rID, rhkID, route.Formats); err != nil { 51 | res = append(res, err) 52 | } 53 | 54 | if len(res) > 0 { 55 | return errors.CompositeValidationError(res...) 56 | } 57 | return nil 58 | } 59 | 60 | func (o *DeleteProjectParams) bindID(rawData []string, hasKey bool, formats strfmt.Registry) error { 61 | var raw string 62 | if len(rawData) > 0 { 63 | raw = rawData[len(rawData)-1] 64 | } 65 | 66 | // Required: true 67 | // Parameter is provided by construction from the route 68 | 69 | o.ID = raw 70 | 71 | return nil 72 | } 73 | -------------------------------------------------------------------------------- /gen/restapi/operations/item_type/get_item_types_parameters.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package item_type 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | "net/http" 10 | 11 | "github.com/go-openapi/errors" 12 | "github.com/go-openapi/runtime/middleware" 13 | 14 | strfmt "github.com/go-openapi/strfmt" 15 | ) 16 | 17 | // NewGetItemTypesParams creates a new GetItemTypesParams object 18 | // no default values defined in spec. 19 | func NewGetItemTypesParams() GetItemTypesParams { 20 | 21 | return GetItemTypesParams{} 22 | } 23 | 24 | // GetItemTypesParams contains all the bound params for the get item types operation 25 | // typically these are obtained from a http.Request 26 | // 27 | // swagger:parameters getItemTypes 28 | type GetItemTypesParams struct { 29 | 30 | // HTTP Request Object 31 | HTTPRequest *http.Request `json:"-"` 32 | 33 | /*The project id 34 | Required: true 35 | In: path 36 | */ 37 | ProjectID string 38 | } 39 | 40 | // BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface 41 | // for simple values it will use straight method calls. 42 | // 43 | // To ensure default values, the struct must have been initialized with NewGetItemTypesParams() beforehand. 44 | func (o *GetItemTypesParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error { 45 | var res []error 46 | 47 | o.HTTPRequest = r 48 | 49 | rProjectID, rhkProjectID, _ := route.Params.GetOK("projectId") 50 | if err := o.bindProjectID(rProjectID, rhkProjectID, route.Formats); err != nil { 51 | res = append(res, err) 52 | } 53 | 54 | if len(res) > 0 { 55 | return errors.CompositeValidationError(res...) 56 | } 57 | return nil 58 | } 59 | 60 | func (o *GetItemTypesParams) bindProjectID(rawData []string, hasKey bool, formats strfmt.Registry) error { 61 | var raw string 62 | if len(rawData) > 0 { 63 | raw = rawData[len(rawData)-1] 64 | } 65 | 66 | // Required: true 67 | // Parameter is provided by construction from the route 68 | 69 | o.ProjectID = raw 70 | 71 | return nil 72 | } 73 | -------------------------------------------------------------------------------- /gen/restapi/operations/account/signin_parameters.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package account 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | "io" 10 | "net/http" 11 | 12 | "github.com/go-openapi/errors" 13 | "github.com/go-openapi/runtime" 14 | "github.com/go-openapi/runtime/middleware" 15 | 16 | models "github.com/Xzya/headless-cms/gen/models" 17 | ) 18 | 19 | // NewSigninParams creates a new SigninParams object 20 | // no default values defined in spec. 21 | func NewSigninParams() SigninParams { 22 | 23 | return SigninParams{} 24 | } 25 | 26 | // SigninParams contains all the bound params for the signin operation 27 | // typically these are obtained from a http.Request 28 | // 29 | // swagger:parameters signin 30 | type SigninParams struct { 31 | 32 | // HTTP Request Object 33 | HTTPRequest *http.Request `json:"-"` 34 | 35 | /*The account details 36 | Required: true 37 | In: body 38 | */ 39 | Body *models.SigninParamsBody 40 | } 41 | 42 | // BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface 43 | // for simple values it will use straight method calls. 44 | // 45 | // To ensure default values, the struct must have been initialized with NewSigninParams() beforehand. 46 | func (o *SigninParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error { 47 | var res []error 48 | 49 | o.HTTPRequest = r 50 | 51 | if runtime.HasBody(r) { 52 | defer r.Body.Close() 53 | var body models.SigninParamsBody 54 | if err := route.Consumer.Consume(r.Body, &body); err != nil { 55 | if err == io.EOF { 56 | res = append(res, errors.Required("body", "body")) 57 | } else { 58 | res = append(res, errors.NewParseError("body", "body", "", err)) 59 | } 60 | } else { 61 | 62 | // validate body object 63 | if err := body.Validate(route.Formats); err != nil { 64 | res = append(res, err) 65 | } 66 | 67 | if len(res) == 0 { 68 | o.Body = &body 69 | } 70 | } 71 | } else { 72 | res = append(res, errors.Required("body", "body")) 73 | } 74 | if len(res) > 0 { 75 | return errors.CompositeValidationError(res...) 76 | } 77 | return nil 78 | } 79 | -------------------------------------------------------------------------------- /gen/restapi/operations/account/signup_parameters.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package account 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | "io" 10 | "net/http" 11 | 12 | "github.com/go-openapi/errors" 13 | "github.com/go-openapi/runtime" 14 | "github.com/go-openapi/runtime/middleware" 15 | 16 | models "github.com/Xzya/headless-cms/gen/models" 17 | ) 18 | 19 | // NewSignupParams creates a new SignupParams object 20 | // no default values defined in spec. 21 | func NewSignupParams() SignupParams { 22 | 23 | return SignupParams{} 24 | } 25 | 26 | // SignupParams contains all the bound params for the signup operation 27 | // typically these are obtained from a http.Request 28 | // 29 | // swagger:parameters signup 30 | type SignupParams struct { 31 | 32 | // HTTP Request Object 33 | HTTPRequest *http.Request `json:"-"` 34 | 35 | /*The account details 36 | Required: true 37 | In: body 38 | */ 39 | Body *models.SignupParamsBody 40 | } 41 | 42 | // BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface 43 | // for simple values it will use straight method calls. 44 | // 45 | // To ensure default values, the struct must have been initialized with NewSignupParams() beforehand. 46 | func (o *SignupParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error { 47 | var res []error 48 | 49 | o.HTTPRequest = r 50 | 51 | if runtime.HasBody(r) { 52 | defer r.Body.Close() 53 | var body models.SignupParamsBody 54 | if err := route.Consumer.Consume(r.Body, &body); err != nil { 55 | if err == io.EOF { 56 | res = append(res, errors.Required("body", "body")) 57 | } else { 58 | res = append(res, errors.NewParseError("body", "body", "", err)) 59 | } 60 | } else { 61 | 62 | // validate body object 63 | if err := body.Validate(route.Formats); err != nil { 64 | res = append(res, err) 65 | } 66 | 67 | if len(res) == 0 { 68 | o.Body = &body 69 | } 70 | } 71 | } else { 72 | res = append(res, errors.Required("body", "body")) 73 | } 74 | if len(res) > 0 { 75 | return errors.CompositeValidationError(res...) 76 | } 77 | return nil 78 | } 79 | -------------------------------------------------------------------------------- /gen/restapi/operations/project/create_project_parameters.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package project 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the swagger generate command 7 | 8 | import ( 9 | "io" 10 | "net/http" 11 | 12 | "github.com/go-openapi/errors" 13 | "github.com/go-openapi/runtime" 14 | "github.com/go-openapi/runtime/middleware" 15 | 16 | models "github.com/Xzya/headless-cms/gen/models" 17 | ) 18 | 19 | // NewCreateProjectParams creates a new CreateProjectParams object 20 | // no default values defined in spec. 21 | func NewCreateProjectParams() CreateProjectParams { 22 | 23 | return CreateProjectParams{} 24 | } 25 | 26 | // CreateProjectParams contains all the bound params for the create project operation 27 | // typically these are obtained from a http.Request 28 | // 29 | // swagger:parameters createProject 30 | type CreateProjectParams struct { 31 | 32 | // HTTP Request Object 33 | HTTPRequest *http.Request `json:"-"` 34 | 35 | /*The project details 36 | Required: true 37 | In: body 38 | */ 39 | Body *models.ProjectRequest 40 | } 41 | 42 | // BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface 43 | // for simple values it will use straight method calls. 44 | // 45 | // To ensure default values, the struct must have been initialized with NewCreateProjectParams() beforehand. 46 | func (o *CreateProjectParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error { 47 | var res []error 48 | 49 | o.HTTPRequest = r 50 | 51 | if runtime.HasBody(r) { 52 | defer r.Body.Close() 53 | var body models.ProjectRequest 54 | if err := route.Consumer.Consume(r.Body, &body); err != nil { 55 | if err == io.EOF { 56 | res = append(res, errors.Required("body", "body")) 57 | } else { 58 | res = append(res, errors.NewParseError("body", "body", "", err)) 59 | } 60 | } else { 61 | 62 | // validate body object 63 | if err := body.Validate(route.Formats); err != nil { 64 | res = append(res, err) 65 | } 66 | 67 | if len(res) == 0 { 68 | o.Body = &body 69 | } 70 | } 71 | } else { 72 | res = append(res, errors.Required("body", "body")) 73 | } 74 | if len(res) > 0 { 75 | return errors.CompositeValidationError(res...) 76 | } 77 | return nil 78 | } 79 | -------------------------------------------------------------------------------- /gen/restapi/operations/account/signin_urlbuilder.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package account 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "errors" 10 | "net/url" 11 | golangswaggerpaths "path" 12 | ) 13 | 14 | // SigninURL generates an URL for the signin operation 15 | type SigninURL struct { 16 | _basePath string 17 | } 18 | 19 | // WithBasePath sets the base path for this url builder, only required when it's different from the 20 | // base path specified in the swagger spec. 21 | // When the value of the base path is an empty string 22 | func (o *SigninURL) WithBasePath(bp string) *SigninURL { 23 | o.SetBasePath(bp) 24 | return o 25 | } 26 | 27 | // SetBasePath sets the base path for this url builder, only required when it's different from the 28 | // base path specified in the swagger spec. 29 | // When the value of the base path is an empty string 30 | func (o *SigninURL) SetBasePath(bp string) { 31 | o._basePath = bp 32 | } 33 | 34 | // Build a url path and query string 35 | func (o *SigninURL) Build() (*url.URL, error) { 36 | var result url.URL 37 | 38 | var _path = "/signin" 39 | 40 | _basePath := o._basePath 41 | if _basePath == "" { 42 | _basePath = "/api" 43 | } 44 | result.Path = golangswaggerpaths.Join(_basePath, _path) 45 | 46 | return &result, nil 47 | } 48 | 49 | // Must is a helper function to panic when the url builder returns an error 50 | func (o *SigninURL) Must(u *url.URL, err error) *url.URL { 51 | if err != nil { 52 | panic(err) 53 | } 54 | if u == nil { 55 | panic("url can't be nil") 56 | } 57 | return u 58 | } 59 | 60 | // String returns the string representation of the path with query string 61 | func (o *SigninURL) String() string { 62 | return o.Must(o.Build()).String() 63 | } 64 | 65 | // BuildFull builds a full url with scheme, host, path and query string 66 | func (o *SigninURL) BuildFull(scheme, host string) (*url.URL, error) { 67 | if scheme == "" { 68 | return nil, errors.New("scheme is required for a full url on SigninURL") 69 | } 70 | if host == "" { 71 | return nil, errors.New("host is required for a full url on SigninURL") 72 | } 73 | 74 | base, err := o.Build() 75 | if err != nil { 76 | return nil, err 77 | } 78 | 79 | base.Scheme = scheme 80 | base.Host = host 81 | return base, nil 82 | } 83 | 84 | // StringFull returns the string representation of a complete url 85 | func (o *SigninURL) StringFull(scheme, host string) string { 86 | return o.Must(o.BuildFull(scheme, host)).String() 87 | } 88 | -------------------------------------------------------------------------------- /gen/restapi/operations/account/signup_urlbuilder.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-swagger; DO NOT EDIT. 2 | 3 | package account 4 | 5 | // This file was generated by the swagger tool. 6 | // Editing this file might prove futile when you re-run the generate command 7 | 8 | import ( 9 | "errors" 10 | "net/url" 11 | golangswaggerpaths "path" 12 | ) 13 | 14 | // SignupURL generates an URL for the signup operation 15 | type SignupURL struct { 16 | _basePath string 17 | } 18 | 19 | // WithBasePath sets the base path for this url builder, only required when it's different from the 20 | // base path specified in the swagger spec. 21 | // When the value of the base path is an empty string 22 | func (o *SignupURL) WithBasePath(bp string) *SignupURL { 23 | o.SetBasePath(bp) 24 | return o 25 | } 26 | 27 | // SetBasePath sets the base path for this url builder, only required when it's different from the 28 | // base path specified in the swagger spec. 29 | // When the value of the base path is an empty string 30 | func (o *SignupURL) SetBasePath(bp string) { 31 | o._basePath = bp 32 | } 33 | 34 | // Build a url path and query string 35 | func (o *SignupURL) Build() (*url.URL, error) { 36 | var result url.URL 37 | 38 | var _path = "/signup" 39 | 40 | _basePath := o._basePath 41 | if _basePath == "" { 42 | _basePath = "/api" 43 | } 44 | result.Path = golangswaggerpaths.Join(_basePath, _path) 45 | 46 | return &result, nil 47 | } 48 | 49 | // Must is a helper function to panic when the url builder returns an error 50 | func (o *SignupURL) Must(u *url.URL, err error) *url.URL { 51 | if err != nil { 52 | panic(err) 53 | } 54 | if u == nil { 55 | panic("url can't be nil") 56 | } 57 | return u 58 | } 59 | 60 | // String returns the string representation of the path with query string 61 | func (o *SignupURL) String() string { 62 | return o.Must(o.Build()).String() 63 | } 64 | 65 | // BuildFull builds a full url with scheme, host, path and query string 66 | func (o *SignupURL) BuildFull(scheme, host string) (*url.URL, error) { 67 | if scheme == "" { 68 | return nil, errors.New("scheme is required for a full url on SignupURL") 69 | } 70 | if host == "" { 71 | return nil, errors.New("host is required for a full url on SignupURL") 72 | } 73 | 74 | base, err := o.Build() 75 | if err != nil { 76 | return nil, err 77 | } 78 | 79 | base.Scheme = scheme 80 | base.Host = host 81 | return base, nil 82 | } 83 | 84 | // StringFull returns the string representation of a complete url 85 | func (o *SignupURL) StringFull(scheme, host string) string { 86 | return o.Must(o.BuildFull(scheme, host)).String() 87 | } 88 | --------------------------------------------------------------------------------