resource

package
v0.3.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 5, 2017 License: GPL-3.0 Imports: 52 Imported by: 6

Documentation

Index

Constants

View Source 
const (
	Added changeType = iota
	Removed
	ChangedType
	ChangedValue
)

Variables

View Source 
var CollectionTypes = []string{
	"Pair",
	"Triplet",
	"Set",
	"OrderedSet",
}
View Source 
var ColumnTypes = []ColumnType{
	{
		Name:          "id",
		BlueprintType: "string",
		Validations:   []string{},
	},
	{
		Name:          "alias",
		BlueprintType: "string",
	},
	{
		Name:          "date",
		BlueprintType: "string",
	},
	{
		Name:          "time",
		BlueprintType: "string",
	},
	{
		Name:          "day",
		BlueprintType: "string",
	},
	{
		Name:          "month",
		BlueprintType: "number",
		Validations:   []string{"min=1,max=12"},
	},
	{
		Name:          "year",
		BlueprintType: "number",
		Validations:   []string{"min=1900,max=2100"},
	},
	{
		Name:          "minute",
		BlueprintType: "number",
		Validations:   []string{"min=0,max=59"},
	},
	{
		Name:          "hour",
		BlueprintType: "number",
	},
	{
		Name:          "datetime",
		BlueprintType: "string",
	},
	{
		Name:          "email",
		BlueprintType: "string",
		Validations:   []string{"email"},
		Conformations: []string{"email"},
	},
	{
		Name:          "namespace",
		BlueprintType: "string",
	},
	{
		Name:          "name",
		BlueprintType: "string",
		Validations:   []string{"required"},
		Conformations: []string{"name"},
	},
	{
		Name:          "encrypted",
		BlueprintType: "string",
	},
	{
		Name:          "json",
		BlueprintType: "string",
	},
	{
		Name:          "password",
		BlueprintType: "string",
		Validations:   []string{"required"},
	},
	{
		Name:          "value",
		BlueprintType: "number",
	},
	{
		Name:          "truefalse",
		BlueprintType: "boolean",
	},
	{
		Name:          "timestamp",
		BlueprintType: "timestamp",
	},
	{
		Name:          "location.latitude",
		BlueprintType: "string",
		Validations:   []string{"latitude"},
	},
	{
		Name:          "location.longitude",
		BlueprintType: "string",
		Validations:   []string{"longitude"},
	},
	{
		Name:          "location.altitude",
		BlueprintType: "string",
	},
	{
		Name:          "color",
		BlueprintType: "string",
		Validations:   []string{"iscolor"},
	},
	{
		Name:          "rating.10",
		BlueprintType: "number",
		Validations:   []string{"min=0,max=10"},
	},
	{
		Name:          "measurement",
		BlueprintType: "number",
	},
	{
		Name:          "label",
		BlueprintType: "string",
	},
	{
		Name:          "content",
		BlueprintType: "string",
	},
	{
		Name:          "file",
		BlueprintType: "string",
		Validations:   []string{"base64"},
	},
	{
		Name:          "url",
		BlueprintType: "string",
		Validations:   []string{"url"},
	},
	{
		Name:          "image",
		BlueprintType: "string",
		Validations:   []string{"base64"},
	},
}
View Source 
var ConfigTableStructure = TableInfo{
	TableName: settingsTableName,
	Columns: []api2go.ColumnInfo{
		{
			Name:            "id",
			ColumnName:      "id",
			ColumnType:      "id",
			DataType:        "INTEGER",
			IsPrimaryKey:    true,
			IsAutoIncrement: true,
		},
		{
			Name:       "name",
			ColumnName: "name",
			ColumnType: "string",
			DataType:   "varchar(100)",
			IsNullable: false,
			IsIndexed:  true,
		},
		{
			Name:       "ConfigType",
			ColumnName: "configtype",
			ColumnType: "string",
			DataType:   "varchar(100)",
			IsNullable: false,
			IsIndexed:  true,
		},
		{
			Name:       "ConfigState",
			ColumnName: "configstate",
			ColumnType: "string",
			DataType:   "varchar(100)",
			IsNullable: false,
			IsIndexed:  true,
		},
		{
			Name:       "ConfigEnv",
			ColumnName: "configenv",
			ColumnType: "string",
			DataType:   "varchar(100)",
			IsNullable: false,
			IsIndexed:  true,
		},
		{
			Name:       "Value",
			ColumnName: "value",
			ColumnType: "string",
			DataType:   "varchar(100)",
			IsNullable: true,
			IsIndexed:  true,
		},
		{
			Name:       "ValueType",
			ColumnName: "valuetype",
			ColumnType: "string",
			DataType:   "varchar(100)",
			IsNullable: true,
			IsIndexed:  true,
		},
		{
			Name:       "PreviousValue",
			ColumnName: "previousvalue",
			ColumnType: "string",
			DataType:   "varchar(100)",
			IsNullable: true,
			IsIndexed:  true,
		},
		{
			Name:         "CreatedAt",
			ColumnName:   "created_at",
			ColumnType:   "datetime",
			DataType:     "timestamp",
			DefaultValue: "current_timestamp",
			IsNullable:   false,
			IsIndexed:    true,
		},
		{
			Name:       "UpdatedAt",
			ColumnName: "updated_at",
			ColumnType: "datetime",
			DataType:   "timestamp",
			IsNullable: true,
			IsIndexed:  true,
		},
	},
}
View Source 
var (
	ERR_UNAUTHORIZED = errors.New("Unauthorized")
)
View Source 
var EntityTypeToColumnTypeMap = map[fieldtypes.EntityType]string{
	fieldtypes.DateTime:    "datetime",
	fieldtypes.Id:          "label",
	fieldtypes.Time:        "time",
	fieldtypes.Date:        "date",
	fieldtypes.Ipaddress:   "label",
	fieldtypes.Money:       "measurement",
	fieldtypes.Rating5:     "measurement",
	fieldtypes.Rating10:    "measurement",
	fieldtypes.Rating100:   "measurement",
	fieldtypes.Timestamp:   "timestamp",
	fieldtypes.NumberInt:   "measurement",
	fieldtypes.NumberFloat: "measurement",
	fieldtypes.Boolean:     "truefalse",
	fieldtypes.Latitude:    "location.latitude",
	fieldtypes.Longitude:   "location.longitude",
	fieldtypes.City:        "label",
	fieldtypes.Country:     "label",
	fieldtypes.Continent:   "label",
	fieldtypes.State:       "label",
	fieldtypes.Pincode:     "label",
	fieldtypes.None:        "content",
	fieldtypes.Label:       "label",
	fieldtypes.Name:        "name",
	fieldtypes.Email:       "email",
	fieldtypes.Content:     "content",
	fieldtypes.Json:        "json",
	fieldtypes.Color:       "color",
	fieldtypes.Alias:       "alias",
	fieldtypes.Namespace:   "namespace",
}
View Source 
var EntityTypeToDataTypeMap = map[fieldtypes.EntityType]string{
	fieldtypes.DateTime:    "datetime",
	fieldtypes.Id:          "varchar(100)",
	fieldtypes.Time:        "time",
	fieldtypes.Date:        "date",
	fieldtypes.Ipaddress:   "varchar(100)",
	fieldtypes.Money:       "float(11)",
	fieldtypes.Rating5:     "int(4)",
	fieldtypes.Rating10:    "int(4)",
	fieldtypes.Rating100:   "int(4)",
	fieldtypes.Timestamp:   "timestamp",
	fieldtypes.NumberInt:   "int(5)",
	fieldtypes.NumberFloat: "float(11)",
	fieldtypes.Boolean:     "bool",
	fieldtypes.Latitude:    "float(11)",
	fieldtypes.Longitude:   "float(11)",
	fieldtypes.City:        "varchar(100)",
	fieldtypes.Country:     "varchar(100)",
	fieldtypes.Continent:   "varchar(100)",
	fieldtypes.State:       "varchar(100)",
	fieldtypes.Pincode:     "varchar(20)",
	fieldtypes.None:        "varchar(100)",
	fieldtypes.Label:       "varchar(100)",
	fieldtypes.Name:        "varchar(100)",
	fieldtypes.Email:       "varchar(100)",
	fieldtypes.Content:     "text",
	fieldtypes.Json:        "text",
	fieldtypes.Color:       "varchar(10)",
	fieldtypes.Alias:       "varchar(100)",
	fieldtypes.Namespace:   "varchar(100)",
}
View Source 
var ReservedWords = []string{}/* 825 elements not displayed */

thanks to https://www.drupal.org/node/141051

View Source 
var StandardColumns = []api2go.ColumnInfo{
	{
		Name:            "id",
		ColumnName:      "id",
		DataType:        "INTEGER",
		IsPrimaryKey:    true,
		IsAutoIncrement: true,
		ExcludeFromApi:  true,
		ColumnType:      "id",
	},
	{
		Name:           "version",
		ColumnName:     "version",
		DataType:       "INTEGER",
		ColumnType:     "measurement",
		DefaultValue:   "1",
		ExcludeFromApi: true,
	},
	{
		Name:         "created_at",
		ColumnName:   "created_at",
		DataType:     "timestamp",
		DefaultValue: "current_timestamp",
		ColumnType:   "datetime",
		IsIndexed:    true,
	},
	{
		Name:       "updated_at",
		ColumnName: "updated_at",
		DataType:   "timestamp",
		IsIndexed:  true,
		IsNullable: true,
		ColumnType: "datetime",
	},
	{
		Name:           "deleted_at",
		ColumnName:     "deleted_at",
		DataType:       "timestamp",
		ExcludeFromApi: true,
		IsIndexed:      true,
		IsNullable:     true,
		ColumnType:     "datetime",
	},
	{
		Name:       "reference_id",
		ColumnName: "reference_id",
		DataType:   "varchar(40)",
		IsIndexed:  true,
		ColumnType: "alias",
	},
	{
		Name:       "permission",
		ColumnName: "permission",
		DataType:   "int(11)",
		IsIndexed:  false,
		ColumnType: "value",
	},
}
View Source 
var StandardRelations = []api2go.TableRelation{
	api2go.NewTableRelation("world_column", "belongs_to", "world"),
	api2go.NewTableRelation("action", "belongs_to", "world"),
	api2go.NewTableRelation("world", "has_many", "smd"),
	api2go.NewTableRelation("oauth_token", "has_one", "oauth_connect"),
	api2go.NewTableRelation("data_exchange", "has_one", "oauth_token"),
	api2go.NewTableRelation("timeline", "belongs_to", "world"),
	api2go.NewTableRelation("cloud_store", "has_one", "oauth_token"),
	api2go.NewTableRelation("site", "has_one", "cloud_store"),
}
View Source 
var StandardTables = []TableInfo{
	{
		TableName: "timeline",
		IsHidden:  true,
		Columns: []api2go.ColumnInfo{
			{
				Name:       "event_type",
				ColumnName: "event_type",
				ColumnType: "label",
				DataType:   "varchar(50)",
				IsNullable: false,
			},
			{
				Name:       "title",
				ColumnName: "title",
				ColumnType: "label",
				DataType:   "varchar(50)",
				IsNullable: false,
			},
			{
				Name:       "payload",
				ColumnName: "payload",
				ColumnType: "content",
				DataType:   "text",
				IsNullable: true,
			},
		},
	},
	{
		TableName: "world",
		IsHidden:  true,
		Columns: []api2go.ColumnInfo{
			{
				Name:       "table_name",
				ColumnName: "table_name",
				IsNullable: false,
				IsUnique:   true,
				DataType:   "varchar(200)",
				ColumnType: "name",
			},
			{
				Name:       "schema_json",
				ColumnName: "schema_json",
				DataType:   "text",
				IsNullable: false,
				ColumnType: "json",
			},
			{
				Name:         "default_permission",
				ColumnName:   "default_permission",
				DataType:     "int(4)",
				IsNullable:   false,
				DefaultValue: "644",
				ColumnType:   "value",
			},

			{
				Name:         "is_top_level",
				ColumnName:   "is_top_level",
				DataType:     "bool",
				IsNullable:   false,
				DefaultValue: "true",
				ColumnType:   "truefalse",
			},
			{
				Name:         "is_hidden",
				ColumnName:   "is_hidden",
				DataType:     "bool",
				IsNullable:   false,
				DefaultValue: "false",
				ColumnType:   "truefalse",
			},
			{
				Name:         "is_join_table",
				ColumnName:   "is_join_table",
				DataType:     "bool",
				IsNullable:   false,
				DefaultValue: "false",
				ColumnType:   "truefalse",
			},
			{
				Name:         "is_state_tracking_enabled",
				ColumnName:   "is_state_tracking_enabled",
				DataType:     "bool",
				IsNullable:   false,
				DefaultValue: "false",
				ColumnType:   "truefalse",
			},
		},
	},
	{
		TableName: "world_column",
		IsHidden:  true,
		Columns: []api2go.ColumnInfo{
			{
				Name:       "name",
				ColumnName: "name",
				DataType:   "varchar(100)",
				IsIndexed:  true,
				IsNullable: false,
				ColumnType: "name",
			},
			{
				Name:       "column_name",
				ColumnName: "column_name",
				DataType:   "varchar(100)",
				IsIndexed:  true,
				IsNullable: false,
				ColumnType: "name",
			},
			{
				Name:       "column_type",
				ColumnName: "column_type",
				DataType:   "varchar(100)",
				IsNullable: false,
				ColumnType: "label",
			},
			{
				Name:       "column_description",
				ColumnName: "column_description",
				DataType:   "varchar(100)",
				IsNullable: true,
				ColumnType: "content",
			},
			{
				Name:         "is_primary_key",
				ColumnName:   "is_primary_key",
				DataType:     "bool",
				IsNullable:   false,
				DefaultValue: "false",
				ColumnType:   "truefalse",
			},
			{
				Name:         "is_auto_increment",
				ColumnName:   "is_auto_increment",
				DataType:     "bool",
				IsNullable:   false,
				DefaultValue: "false",
				ColumnType:   "truefalse",
			},
			{
				Name:         "is_indexed",
				ColumnName:   "is_indexed",
				DataType:     "bool",
				IsNullable:   false,
				DefaultValue: "false",
				ColumnType:   "truefalse",
			},
			{
				Name:         "is_unique",
				ColumnName:   "is_unique",
				DataType:     "bool",
				IsNullable:   false,
				DefaultValue: "false",
				ColumnType:   "truefalse",
			},
			{
				Name:         "is_nullable",
				ColumnName:   "is_nullable",
				DataType:     "bool",
				IsNullable:   false,
				DefaultValue: "false",
				ColumnType:   "truefalse",
			},
			{
				Name:         "is_foreign_key",
				ColumnName:   "is_foreign_key",
				DataType:     "bool",
				IsNullable:   false,
				DefaultValue: "false",
				ColumnType:   "truefalse",
			},
			{
				Name:         "include_in_api",
				ColumnName:   "include_in_api",
				DataType:     "bool",
				IsNullable:   false,
				DefaultValue: "true",
				ColumnType:   "truefalse",
			},
			{
				Name:       "foreign_key_data",
				ColumnName: "foreign_key_data",
				DataType:   "varchar(100)",
				IsNullable: true,
				ColumnType: "content",
			},
			{
				Name:       "default_value",
				ColumnName: "default_value",
				DataType:   "varchar(100)",
				IsNullable: true,
				ColumnType: "content",
			},
			{
				Name:       "data_type",
				ColumnName: "data_type",
				DataType:   "varchar(50)",
				IsNullable: true,
				ColumnType: "label",
			},
		},
	},
	{
		TableName: "user",
		Columns: []api2go.ColumnInfo{
			{
				Name:       "name",
				ColumnName: "name",
				IsIndexed:  true,
				DataType:   "varchar(80)",
				ColumnType: "name",
			},
			{
				Name:       "email",
				ColumnName: "email",
				DataType:   "varchar(80)",
				IsIndexed:  true,
				IsUnique:   true,
				ColumnType: "email",
			},

			{
				Name:       "password",
				ColumnName: "password",
				DataType:   "varchar(100)",
				ColumnType: "password",
				IsNullable: true,
			},
			{
				Name:         "confirmed",
				ColumnName:   "confirmed",
				DataType:     "boolean",
				ColumnType:   "truefalse",
				IsNullable:   false,
				DefaultValue: "false",
			},
		},
		Validations: []ColumnTag{
			{
				ColumnName: "email",
				Tags:       "email",
			},
			{
				ColumnName: "password",
				Tags:       "required",
			},
			{
				ColumnName: "name",
				Tags:       "required",
			},
		},
		Conformations: []ColumnTag{
			{
				ColumnName: "email",
				Tags:       "email",
			},
		},
	},
	{
		TableName: "usergroup",
		Columns: []api2go.ColumnInfo{
			{
				Name:       "name",
				ColumnName: "name",
				IsIndexed:  true,
				DataType:   "varchar(80)",
				ColumnType: "name",
			},
		},
	},
	{
		TableName: "action",
		Columns: []api2go.ColumnInfo{
			{
				Name:       "action_name",
				IsIndexed:  true,
				ColumnName: "action_name",
				DataType:   "varchar(100)",
				ColumnType: "name",
			},
			{
				Name:       "label",
				ColumnName: "label",
				IsIndexed:  true,
				DataType:   "varchar(100)",
				ColumnType: "label",
			},
			{
				Name:         "instance_optional",
				ColumnName:   "instance_optional",
				IsIndexed:    false,
				DataType:     "bool",
				ColumnType:   "truefalse",
				DefaultValue: "true",
			},
			{
				Name:       "action_schema",
				ColumnName: "action_schema",
				DataType:   "text",
				ColumnType: "json",
			},
		},
	},
	{
		TableName: "smd",
		IsHidden:  true,
		Columns: []api2go.ColumnInfo{
			{
				Name:       "name",
				ColumnName: "name",
				IsIndexed:  true,
				DataType:   "varchar(100)",
				ColumnType: "label",
				IsNullable: false,
			},
			{
				Name:       "label",
				ColumnName: "label",
				DataType:   "varchar(100)",
				ColumnType: "label",
				IsNullable: false,
			},
			{
				Name:       "initial_state",
				ColumnName: "initial_state",
				DataType:   "varchar(100)",
				ColumnType: "label",
				IsNullable: false,
			},
			{
				Name:       "events",
				ColumnName: "events",
				DataType:   "text",
				ColumnType: "json",
				IsNullable: false,
			},
		},
	},
	{
		TableName: "oauth_connect",
		IsHidden:  true,
		Columns: []api2go.ColumnInfo{
			{
				Name:       "name",
				ColumnName: "name",
				IsUnique:   true,
				IsIndexed:  true,
				DataType:   "varchar(80)",
				ColumnType: "name",
			},
			{
				Name:       "client_id",
				ColumnName: "client_id",
				DataType:   "varchar(80)",
				ColumnType: "name",
			},
			{
				Name:       "client_secret",
				ColumnName: "client_secret",
				DataType:   "varchar(80)",
				ColumnType: "encrypted",
			},
			{
				Name:         "scope",
				ColumnName:   "scope",
				DataType:     "varchar(1000)",
				ColumnType:   "content",
				DefaultValue: "'https://www.googleapis.com/auth/spreadsheets'",
			},
			{
				Name:         "response_type",
				ColumnName:   "response_type",
				DataType:     "varchar(80)",
				ColumnType:   "name",
				DefaultValue: "'code'",
			},
			{
				Name:       "redirect_uri",
				ColumnName: "redirect_uri",
				DataType:   "varchar(80)",
				ColumnType: "url",
			},
			{
				Name:         "auth_url",
				ColumnName:   "auth_url",
				DataType:     "varchar(200)",
				DefaultValue: "'https://accounts.google.com/o/oauth2/auth'",
				ColumnType:   "url",
			},
			{
				Name:         "token_url",
				ColumnName:   "token_url",
				DataType:     "varchar(200)",
				DefaultValue: "'https://accounts.google.com/o/oauth2/token'",
				ColumnType:   "url",
			},
		},
	},
	{
		TableName: "data_exchange",
		IsHidden:  true,
		Columns: []api2go.ColumnInfo{
			{
				Name:       "name",
				ColumnName: "name",
				ColumnType: "name",
				DataType:   "varchar(200)",
				IsIndexed:  true,
			},
			{
				Name:       "source_attributes",
				ColumnName: "source_attributes",
				ColumnType: "json",
				DataType:   "text",
			},
			{
				Name:       "source_type",
				ColumnName: "source_type",
				ColumnType: "name",
				DataType:   "varchar(100)",
			},
			{
				Name:       "target_attributes",
				ColumnName: "target_attributes",
				ColumnType: "json",
				DataType:   "text",
			},
			{
				Name:       "target_type",
				ColumnName: "target_type",
				ColumnType: "name",
				DataType:   "varchar(100)",
			},
			{
				Name:       "attributes",
				ColumnName: "attributes",
				ColumnType: "json",
				DataType:   "text",
			},
			{
				Name:       "options",
				ColumnName: "options",
				ColumnType: "json",
				DataType:   "text",
			},
		},
	},
	{
		TableName: "oauth_token",
		IsHidden:  true,
		Columns: []api2go.ColumnInfo{
			{
				Name:       "access_token",
				ColumnName: "access_token",
				ColumnType: "encrypted",
				DataType:   "varchar(1000)",
			},
			{
				Name:       "expires_in",
				ColumnName: "expires_in",
				ColumnType: "measurement",
				DataType:   "int(11)",
			},
			{
				Name:       "refresh_token",
				ColumnName: "refresh_token",
				ColumnType: "encrypted",
				DataType:   "varchar(1000)",
			},
			{
				Name:       "token_type",
				ColumnName: "token_type",
				ColumnType: "label",
				DataType:   "varchar(20)",
			},
		},
	},
	{
		TableName: "cloud_store",
		IsHidden:  true,
		Columns: []api2go.ColumnInfo{
			{
				Name:       "Name",
				ColumnName: "name",
				ColumnType: "label",
				DataType:   "varchar(100)",
			},
			{
				Name:       "Store type",
				ColumnName: "store_type",
				ColumnType: "label",
				DataType:   "varchar(100)",
			},
			{
				Name:       "Store provider",
				ColumnName: "store_provider",
				ColumnType: "label",
				DataType:   "varchar(100)",
			},
			{
				Name:       "Root path",
				ColumnName: "root_path",
				ColumnType: "label",
				DataType:   "varchar(1000)",
			},
			{
				Name:       "Store parameters",
				ColumnName: "store_parameters",
				ColumnType: "json",
				DataType:   "text",
			},
		},
	},
	{
		TableName: "site",
		IsHidden:  true,
		Columns: []api2go.ColumnInfo{
			{
				Name:       "Name",
				ColumnName: "name",
				ColumnType: "label",
				DataType:   "varchar(100)",
			},
			{
				Name:       "Host name",
				ColumnName: "hostname",
				ColumnType: "label",
				DataType:   "varchar(100)",
			},
			{
				Name:       "Path",
				ColumnName: "path",
				ColumnType: "label",
				DataType:   "varchar(100)",
			},
		},
	},
}
View Source 
var SystemActions = []Action{
	{
		Name:             "export_data",
		Label:            "Export data for backup",
		OnType:           "world",
		InstanceOptional: true,
		InFields:         []api2go.ColumnInfo{},
		OutFields: []Outcome{
			{
				Type:   "__data_export",
				Method: "EXECUTE",
				Attributes: map[string]interface{}{
					"world_reference_id": "$.reference_id",
				},
			},
		},
	},
	{
		Name:             "import_json_data",
		Label:            "Import data from JSON backup",
		OnType:           "world",
		InstanceOptional: true,
		InFields: []api2go.ColumnInfo{
			{
				Name:       "JSON Dump file",
				ColumnName: "json_dump_file",
				ColumnType: "file.application/json",
				IsNullable: false,
			},
			{
				Name:       "truncate_before_insert",
				ColumnName: "truncate_before_insert",
				ColumnType: "truefalse",
			},
		},
		OutFields: []Outcome{
			{
				Type:   "__data_import",
				Method: "EXECUTE",
				Attributes: map[string]interface{}{
					"world_reference_id":       "$.reference_id",
					"execute_middleware_chain": "~execute_middleware_chain",
					"truncate_before_insert":   "~truncate_before_insert",
					"json_dump_file":           "~json_dump_file",
				},
			},
		},
	},
	{
		Name:             "upload_file",
		Label:            "Upload file to external store",
		OnType:           "cloud_store",
		InstanceOptional: false,
		InFields: []api2go.ColumnInfo{
			{
				Name:       "File",
				ColumnName: "file",
				ColumnType: "file.*",
				IsNullable: false,
			},
		},
		OutFields: []Outcome{
			{
				Type:   "__external_file_upload",
				Method: "EXECUTE",
				Attributes: map[string]interface{}{
					"file": "~file",
				},
			},
		},
	},
	{
		Name:             "upload_system_schema",
		Label:            "Upload features",
		OnType:           "world",
		InstanceOptional: true,
		InFields: []api2go.ColumnInfo{
			{
				Name:       "Schema JSON file",
				ColumnName: "schema_json_file",
				ColumnType: "file.application/json",
				IsNullable: false,
			},
		},
		OutFields: []Outcome{
			{
				Type:   "system_json_schema_update",
				Method: "EXECUTE",
				Attributes: map[string]interface{}{
					"json_schema": "~schema_json_file",
				},
			},
		},
	},
	{
		Name:             "upload_xls_to_system_schema",
		Label:            "Upload xls to entity",
		OnType:           "world",
		InstanceOptional: true,
		InFields: []api2go.ColumnInfo{
			{
				Name:       "XLSX file",
				ColumnName: "data_xls_file",
				ColumnType: "file.application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
				IsNullable: false,
			},
			{
				Name:       "Entity name",
				ColumnName: "entity_name",
				ColumnType: "label",
				IsNullable: false,
			},
		},
		Validations: []ColumnTag{
			{
				ColumnName: "entity_name",
				Tags:       "required",
			},
		},
		OutFields: []Outcome{
			{
				Type:   "__upload_file_to_entity",
				Method: "EXECUTE",
				Attributes: map[string]interface{}{
					"xls_data": "~data_xls_file",
					"name":     "entity_name",
				},
			},
		},
	},
	{
		Name:             "download_system_schema",
		Label:            "Download system schema",
		OnType:           "world",
		InstanceOptional: true,
		InFields:         []api2go.ColumnInfo{},
		OutFields: []Outcome{
			{
				Type:       "__download_cms_config",
				Method:     "EXECUTE",
				Attributes: map[string]interface{}{},
			},
		},
	},
	{
		Name:             "invoke_become_admin",
		Label:            "Become GoMS admin",
		InstanceOptional: true,
		OnType:           "world",
		InFields:         []api2go.ColumnInfo{},
		OutFields: []Outcome{
			{
				Type:   "__become_admin",
				Method: "EXECUTE",
				Attributes: map[string]interface{}{
					"user_id": "$user.id",
				},
			},
		},
	},
	{
		Name:             "signup",
		Label:            "Sign up on Goms",
		InstanceOptional: true,
		OnType:           "user",
		InFields: []api2go.ColumnInfo{
			{
				Name:       "name",
				ColumnName: "name",
				ColumnType: "label",
				IsNullable: false,
			},
			{
				Name:       "email",
				ColumnName: "email",
				ColumnType: "email",
				IsNullable: false,
			},
			{
				Name:       "password",
				ColumnName: "password",
				ColumnType: "password",
				IsNullable: false,
			},
			{
				Name:       "Password Confirm",
				ColumnName: "passwordConfirm",
				ColumnType: "password",
				IsNullable: false,
			},
		},
		Validations: []ColumnTag{
			{
				ColumnName: "email",
				Tags:       "email",
			},
			{
				ColumnName: "name",
				Tags:       "required",
			},
			{
				ColumnName: "password",
				Tags:       "eqfield=InnerStructField[passwordConfirm],min=8",
			},
		},
		Conformations: []ColumnTag{
			{
				ColumnName: "email",
				Tags:       "email",
			},
			{
				ColumnName: "name",
				Tags:       "trim",
			},
		},
		OutFields: []Outcome{
			{
				Type:      "user",
				Method:    "POST",
				Reference: "user",
				Attributes: map[string]interface{}{
					"name":     "~name",
					"email":    "~email",
					"password": "~password",
				},
			},
			{
				Type:      "usergroup",
				Method:    "POST",
				Reference: "usergroup",
				Attributes: map[string]interface{}{
					"name": "!'Home group for ' + user.name",
				},
			},
			{
				Type:      "user_user_id_has_usergroup_usergroup_id",
				Method:    "POST",
				Reference: "user_usergroup",
				Attributes: map[string]interface{}{
					"user_id":      "$user.reference_id",
					"usergroup_id": "$usergroup.reference_id",
				},
			},
			{
				Type:   "client.notify",
				Method: "ACTIONRESPONSE",
				Attributes: map[string]interface{}{
					"type":    "success",
					"message": "Signup Successful",
				},
			},
			{
				Type:   "client.redirect",
				Method: "ACTIONRESPONSE",
				Attributes: map[string]interface{}{
					"location": "/auth/signin",
					"window":   "self",
				},
			},
		},
	},
	{
		Name:             "signin",
		Label:            "Sign in to Goms",
		InstanceOptional: true,
		OnType:           "user",
		InFields: []api2go.ColumnInfo{
			{
				Name:       "email",
				ColumnName: "email",
				ColumnType: "email",
				IsNullable: false,
			},
			{
				Name:       "password",
				ColumnName: "password",
				ColumnType: "password",
				IsNullable: false,
			},
		},
		OutFields: []Outcome{
			{
				Type:   "jwt.token",
				Method: "EXECUTE",
				Attributes: map[string]interface{}{
					"email":    "~email",
					"password": "~password",
				},
			},
		},
	},
	{
		Name:     "oauth.login.begin",
		Label:    "Authenticate via OAuth",
		OnType:   "oauth_connect",
		InFields: []api2go.ColumnInfo{},
		OutFields: []Outcome{
			{
				Type:   "oauth.client.redirect",
				Method: "EXECUTE",
				Attributes: map[string]interface{}{
					"authenticator": "$.name",
					"scope":         "$.scope",
				},
			},
		},
	},
	{
		Name:             "oauth.login.response",
		Label:            "",
		InstanceOptional: true,
		OnType:           "oauth_token",
		InFields: []api2go.ColumnInfo{
			{
				Name:       "code",
				ColumnName: "code",
				ColumnType: "hidden",
				IsNullable: false,
			},
			{
				Name:       "state",
				ColumnName: "state",
				ColumnType: "hidden",
				IsNullable: false,
			},
			{
				Name:       "authenticator",
				ColumnName: "authenticator",
				ColumnType: "hidden",
				IsNullable: false,
			},
		},
		OutFields: []Outcome{
			{
				Type:   "oauth.login.response",
				Method: "EXECUTE",
				Attributes: map[string]interface{}{
					"authenticator": "~authenticator",
				},
			},
		},
	},
	{
		Name:             "add_exchange",
		Label:            "Add new data exchange",
		OnType:           "world",
		InstanceOptional: true,
		InFields: []api2go.ColumnInfo{
			{
				Name:       "name",
				ColumnName: "name",
				ColumnType: "name",
				IsNullable: false,
			},
			{
				Name:           "sheet_id",
				ColumnName:     "sheet_id",
				ColumnType:     "alias",
				IsForeignKey:   true,
				ForeignKeyData: api2go.ForeignKeyData{},
			},
		},
	},
}
View Source 
var SystemExchanges = []ExchangeContract{}
View Source 
var SystemSmds = []LoopbookFsmDescription{}

Functions

func BcryptCheckStringHash 

func BcryptCheckStringHash(newString, hash string) bool

func BcryptHashString 

func BcryptHashString(password string) (string, error)

func BuildOutcome 

func BuildOutcome(inFieldMap map[string]interface{}, outcome Outcome) (*api2go.Api2GoModel, api2go.Request, error)

func CheckAllTableStatus 

func CheckAllTableStatus(initConfig *CmsConfig, db *sqlx.DB)

func CheckAuditTables added in v0.2.1 

func CheckAuditTables(config *CmsConfig, db *sqlx.DB)

func CheckErr 

func CheckErr(err error, message string)

func CheckError 

func CheckError(err error, msg string)

func CheckRelations 

func CheckRelations(config *CmsConfig, db *sqlx.DB)

func CheckTable 

func CheckTable(tableInfo *TableInfo, db *sqlx.DB)

func CreateAMapOfColumnsWeWantInTheFinalTable 

func CreateAMapOfColumnsWeWantInTheFinalTable(tableInfo *TableInfo) (map[string]bool, map[string]api2go.ColumnInfo)

func CreateGetActionHandler 

func CreateGetActionHandler(initConfig *CmsConfig, configStore *ConfigStore, cruds map[string]*DbResource) func(*gin.Context)

func CreateGuestActionListHandler 

func CreateGuestActionListHandler(initConfig *CmsConfig, cruds map[string]*DbResource) func(*gin.Context)

func CreateIndexes 

func CreateIndexes(initConfig *CmsConfig, db *sqlx.DB)

func CreatePostActionHandler 

func CreatePostActionHandler(initConfig *CmsConfig, configStore *ConfigStore, cruds map[string]*DbResource, actionPerformers []ActionPerformerInterface) func(*gin.Context)

func CreateRelations 

func CreateRelations(initConfig *CmsConfig, db *sqlx.DB)

func CreateTable 

func CreateTable(tableInfo *TableInfo, db *sqlx.DB)

func CreateUniqueConstraints 

func CreateUniqueConstraints(initConfig *CmsConfig, db *sqlx.DB)

func Decrypt 

func Decrypt(key []byte, cryptoText string) (string, error)

Decrypt from base64 to decrypted string

func Encrypt 

func Encrypt(key []byte, text string) (string, error)

Encrypt string to base64 crypto using AES

func EndsWithCheck added in v0.2.1 

func EndsWithCheck(str string, endsWith string) bool

func GetActionMapByTypeName 

func GetActionMapByTypeName(db *sqlx.DB) (map[string]map[string]interface{}, error)

func GetAdminUserIdAndUserGroupId 

func GetAdminUserIdAndUserGroupId(db *sqlx.DB) (int64, int64)

func GetDataArray added in v0.2.1 

func GetDataArray(sheet *xlsx.Sheet) (dataMap []map[string]interface{}, columnNames []string, err error)

func GetMD5Hash 

func GetMD5Hash(text string) string

func GetOauthConnectionById 

func GetOauthConnectionById(authenticatorId int64, dbResource *DbResource) (*oauth2.Config, string, error)

func GetOauthConnectionDescription 

func GetOauthConnectionDescription(authenticator string, dbResource *DbResource) (*oauth2.Config, string, error)

func GetObjectByWhereClause 

func GetObjectByWhereClause(objType string, db *sqlx.DB, queries ...squirrel.Eq) ([]map[string]interface{}, error)

func GetValidatedInFields 

func GetValidatedInFields(actionRequest ActionRequest, action Action) (map[string]interface{}, error)

func GetWorldTableMapBy 

func GetWorldTableMapBy(col string, db *sqlx.DB) (map[string]map[string]interface{}, error)

func ImportDataFiles added in v0.2.1 

func ImportDataFiles(initConfig *CmsConfig, db *sqlx.DB, cruds map[string]*DbResource)

func InfoErr added in v0.2.1 

func InfoErr(err error, message string)

func InitialiseColumnManager added in v0.2.1 

func InitialiseColumnManager()

func IsReservedWord added in v0.2.1 

func IsReservedWord(w string) bool

func MakeCreateTableQuery 

func MakeCreateTableQuery(tableInfo *TableInfo, sqlDriverName string) string

func NewClientNotification 

func NewClientNotification(notificationType string, message string, title string) map[string]interface{}

func NewMapStringScan 

func NewMapStringScan(columnNames []string) *mapStringScan

func NewResponse 

func NewResponse(metadata map[string]interface{}, result interface{}, statusCode int, pagination *api2go.Pagination) api2go.Responder

func ReferenceIdToIntegerId 

func ReferenceIdToIntegerId(typeName string, referenceId string, db *sqlx.DB) (int64, error)

func RowsToMap 

func RowsToMap(rows *sqlx.Rows, typeName string) ([]map[string]interface{}, error)

func SmallSnakeCaseText added in v0.2.1 

func SmallSnakeCaseText(str string) string

func UpdateActionTable 

func UpdateActionTable(initConfig *CmsConfig, db *sqlx.DB) error

func UpdateExchanges 

func UpdateExchanges(initConfig *CmsConfig, db *sqlx.DB)

func UpdateStateMachineDescriptions 

func UpdateStateMachineDescriptions(initConfig *CmsConfig, db *sqlx.DB)

func UpdateWorldColumnTable 

func UpdateWorldColumnTable(initConfig *CmsConfig, db *sqlx.DB)

func UpdateWorldTable 

func UpdateWorldTable(initConfig *CmsConfig, db *sqlx.DB)

func ValueOf 

func ValueOf(x interface{}) interface{}

Types

type Action 

type Action struct {
	Name             string              `json:"name"`
	Label            string              `json:"label"`
	OnType           string              `json:"onType"`
	InstanceOptional bool                `json:"instanceOptional"`
	ReferenceId      string              `json:"reference_id"`
	InFields         []api2go.ColumnInfo `json:"fields"`
	OutFields        []Outcome           `json:"outcomes"`
	Validations      []ColumnTag         `json:"validations"`
	Conformations    []ColumnTag         `json:"conformations"`
}

type ActionPerformerInterface 

type ActionPerformerInterface interface {
	DoAction(request ActionRequest, inFields map[string]interface{}) ([]ActionResponse, []error)
	Name() string
}

func NewBecomeAdminPerformer 

func NewBecomeAdminPerformer(initConfig *CmsConfig, cruds map[string]*DbResource) (ActionPerformerInterface, error)

func NewDownloadCmsConfigPerformer 

func NewDownloadCmsConfigPerformer(initConfig *CmsConfig) (ActionPerformerInterface, error)

func NewExportDataPerformer added in v0.2.1 

func NewExportDataPerformer(initConfig *CmsConfig, cruds map[string]*DbResource) (ActionPerformerInterface, error)

func NewFileUploadActionPerformer added in v0.2.1 

func NewFileUploadActionPerformer(initConfig *CmsConfig, cruds map[string]*DbResource) (ActionPerformerInterface, error)

func NewGenerateJwtTokenPerformer 

func NewGenerateJwtTokenPerformer(configStore *ConfigStore, cruds map[string]*DbResource) (ActionPerformerInterface, error)

func NewImportDataPerformer added in v0.2.1 

func NewImportDataPerformer(initConfig *CmsConfig, cruds map[string]*DbResource) (ActionPerformerInterface, error)

func NewOauthLoginBeginActionPerformer 

func NewOauthLoginBeginActionPerformer(initConfig *CmsConfig, cruds map[string]*DbResource, configStore *ConfigStore) (ActionPerformerInterface, error)

func NewOauthLoginResponseActionPerformer 

func NewOauthLoginResponseActionPerformer(initConfig *CmsConfig, cruds map[string]*DbResource, configStore *ConfigStore) (ActionPerformerInterface, error)

func NewRestarSystemPerformer 

func NewRestarSystemPerformer(initConfig *CmsConfig) (ActionPerformerInterface, error)

func NewUploadFileToEntityPerformer added in v0.2.1 

func NewUploadFileToEntityPerformer(initConfig *CmsConfig, cruds map[string]*DbResource) (ActionPerformerInterface, error)

type ActionRequest 

type ActionRequest struct {
	Type       string
	Action     string
	Attributes map[string]interface{}
}

type ActionResponse 

type ActionResponse struct {
	ResponseType string
	Attributes   interface{}
}

func NewActionResponse 

func NewActionResponse(responseType string, attrs interface{}) ActionResponse

type ActionRow 

type ActionRow struct {
	Name             string `json:"name"`
	Label            string `json:"label"`
	OnType           string `json:"onType"`
	InstanceOptional bool   `db:"instance_optional",json:"instance_optional"`
	ReferenceId      string `json:"reference_id"`
	ActionSchema     string `db:"action_schema"`
}

type BecomeAdminActionPerformer 

type BecomeAdminActionPerformer struct {
	// contains filtered or unexported fields
}

func (*BecomeAdminActionPerformer) DoAction 

func (d *BecomeAdminActionPerformer) DoAction(request ActionRequest, inFieldMap map[string]interface{}) ([]ActionResponse, []error)

func (*BecomeAdminActionPerformer) Name 

func (d *BecomeAdminActionPerformer) Name() string

type Change 

type Change struct {
	ChangeType changeType
	OldValue   interface{}
	NewValue   interface{}
}

func Diff 

func Diff(a, b interface{}) (desc []Change)

Diff returns a slice where each element describes a difference between a and b.

func Fdiff 

func Fdiff(a, b interface{}) []Change

Fdiff writes to w a description of the differences between a and b.

type CloudStore added in v0.2.1 

type CloudStore struct {
	Id              int64
	RootPath        string `db:"root_path"`
	StoreParameters map[string]interface{}
	UserId          string
	OAutoTokenId    string
	Name            string
	StoreType       string
	StoreProvider   string
	Version         int
	CreatedAt       *time.Time
	UpdatedAt       *time.Time
	DeletedAt       *time.Time
	ReferenceId     string
	Permission      int
}

type CmsConfig 

type CmsConfig struct {
	Tables                   []TableInfo
	Imports                  []DataFileImport
	StateMachineDescriptions []LoopbookFsmDescription `json:"state_machine_descriptions"`
	Relations                []api2go.TableRelation
	Actions                  []Action           `json:"actions"`
	ExchangeContracts        []ExchangeContract `json:"exchanges"`
	Hostname                 string
	Validator                *validator.Validate
	SubSites                 map[string]SubSiteInformation
}

type ColumnMap 

type ColumnMap struct {
	SourceColumn     string
	SourceColumnType string
	TargetColumn     string
	TargetColumnType string
}

type ColumnMapping 

type ColumnMapping []ColumnMap

func (*ColumnMapping) UnmarshalJSON 

func (c *ColumnMapping) UnmarshalJSON(payload []byte) error

type ColumnTag added in v0.2.1 

type ColumnTag struct {
	ColumnName string
	Tags       string
}

type ColumnType added in v0.2.1 

type ColumnType struct {
	BlueprintType string
	Name          string
	Validations   []string
	Conformations []string
}

func (ColumnType) Fake added in v0.2.1 

func (ct ColumnType) Fake() interface{}

type ColumnTypeManager added in v0.2.1 

type ColumnTypeManager struct {
	ColumnMap map[string]ColumnType
}
var ColumnManager *ColumnTypeManager

func (*ColumnTypeManager) GetBlueprintType added in v0.2.1 

func (ctm *ColumnTypeManager) GetBlueprintType(colName string) string

func (*ColumnTypeManager) GetFakedata added in v0.2.1 

func (ctm *ColumnTypeManager) GetFakedata(colTypeName string) string

func (*ColumnTypeManager) IsValidValue added in v0.2.1 

func (ctm *ColumnTypeManager) IsValidValue(val string, colType string, validator *validator2.Validate) error

type Config 

type Config struct {
	Name          string
	ConfigType    string // web/backend/mobile
	ConfigState   string // enabled/disabled
	ConfigEnv     string // debug/test/release
	Value         string
	ValueType     string // number/string/byteslice
	PreviousValue string
	UpdatedAt     time.Time
}

type ConfigStore 

type ConfigStore struct {
	// contains filtered or unexported fields
}

func NewConfigStore 

func NewConfigStore(db *sqlx.DB) (*ConfigStore, error)

func (*ConfigStore) GetConfigValueFor 

func (c *ConfigStore) GetConfigValueFor(key string, configtype string) (string, error)

func (*ConfigStore) GetWebConfig 

func (c *ConfigStore) GetWebConfig() map[string]string

func (*ConfigStore) SetConfigValueFor 

func (c *ConfigStore) SetConfigValueFor(key string, val string, configtype string) error

func (*ConfigStore) SetDefaultEnv 

func (c *ConfigStore) SetDefaultEnv(env string)

type DataFileImport added in v0.2.1 

type DataFileImport struct {
	FilePath string
	Entity   string
	FileType string
}

func (DataFileImport) String added in v0.2.1 

func (s DataFileImport) String() string

type DataValidationMiddleware added in v0.2.1 

type DataValidationMiddleware struct {
	// contains filtered or unexported fields
}

func (*DataValidationMiddleware) InterceptAfter added in v0.2.1 

func (dvm *DataValidationMiddleware) InterceptAfter(dr *DbResource, req *api2go.Request, results []map[string]interface{}) ([]map[string]interface{}, error)

func (*DataValidationMiddleware) InterceptBefore added in v0.2.1 

func (dvm *DataValidationMiddleware) InterceptBefore(dr *DbResource, req *api2go.Request, objects []map[string]interface{}) ([]map[string]interface{}, error)

func (DataValidationMiddleware) String added in v0.2.1 

func (dvm DataValidationMiddleware) String() string

type DatabaseRequestInterceptor 

type DatabaseRequestInterceptor interface {
	InterceptBefore(*DbResource, *api2go.Request, []map[string]interface{}) ([]map[string]interface{}, error)
	InterceptAfter(*DbResource, *api2go.Request, []map[string]interface{}) ([]map[string]interface{}, error)
	fmt.Stringer
}

func NewCreateEventHandler 

func NewCreateEventHandler() DatabaseRequestInterceptor

func NewDataValidationMiddleware added in v0.2.1 

func NewDataValidationMiddleware(cmsConfig *CmsConfig, cruds *map[string]*DbResource) DatabaseRequestInterceptor

func NewDeleteEventHandler 

func NewDeleteEventHandler() DatabaseRequestInterceptor

func NewExchangeMiddleware 

func NewExchangeMiddleware(cmsConfig *CmsConfig, cruds *map[string]*DbResource) DatabaseRequestInterceptor

func NewFindOneEventHandler 

func NewFindOneEventHandler() DatabaseRequestInterceptor

func NewUpdateEventHandler 

func NewUpdateEventHandler() DatabaseRequestInterceptor

type DbResource 

type DbResource struct {
	// contains filtered or unexported fields
}

func NewDbResource 

func NewDbResource(model *api2go.Api2GoModel, db *sqlx.DB, ms *MiddlewareSet, cruds map[string]*DbResource, configStore *ConfigStore) *DbResource

func (*DbResource) BecomeAdmin 

func (dbResource *DbResource) BecomeAdmin(userId int64) bool

func (*DbResource) CanBecomeAdmin 

func (dbResource *DbResource) CanBecomeAdmin() bool

func (*DbResource) Create 

func (dr *DbResource) Create(obj interface{}, req api2go.Request) (api2go.Responder, error)

func (*DbResource) Delete 

func (dr *DbResource) Delete(id string, req api2go.Request) (api2go.Responder, error)

func (*DbResource) DirectInsert added in v0.2.1 

func (dr *DbResource) DirectInsert(typeName string, data map[string]interface{}) error

func (*DbResource) FindOne 

func (dr *DbResource) FindOne(referenceId string, req api2go.Request) (api2go.Responder, error)

FindOne returns an object by its ID Possible Responder success status code 200

func (*DbResource) GetActionByName 

func (dr *DbResource) GetActionByName(typeName string, actionName string) (Action, error)

func (*DbResource) GetActionPermissionByName 

func (dr *DbResource) GetActionPermissionByName(worldId int64, actionName string) (Permission, error)

func (*DbResource) GetActionsByType 

func (dr *DbResource) GetActionsByType(typeName string) ([]Action, error)

func (*DbResource) GetAllCloudStores added in v0.2.1 

func (resource *DbResource) GetAllCloudStores() ([]CloudStore, error)

func (*DbResource) GetAllObjects added in v0.2.1 

func (dr *DbResource) GetAllObjects(typeName string) ([]map[string]interface{}, error)

func (*DbResource) GetAllRawObjects added in v0.2.1 

func (dr *DbResource) GetAllRawObjects(typeName string) ([]map[string]interface{}, error)

func (*DbResource) GetAllSites added in v0.2.1 

func (resource *DbResource) GetAllSites() ([]SubSite, error)

func (*DbResource) GetContext 

func (dr *DbResource) GetContext(key string) interface{}

func (*DbResource) GetIdByWhereClause 

func (dr *DbResource) GetIdByWhereClause(typeName string, queries ...squirrel.Eq) ([]int64, error)

func (*DbResource) GetIdToObject 

func (dr *DbResource) GetIdToObject(typeName string, id int64) (map[string]interface{}, error)

func (*DbResource) GetIdToReferenceId 

func (dr *DbResource) GetIdToReferenceId(typeName string, id int64) (string, error)

func (*DbResource) GetOauthDescriptionByTokenId 

func (resource *DbResource) GetOauthDescriptionByTokenId(id int64) (*oauth2.Config, error)

func (*DbResource) GetOauthDescriptionByTokenReferenceId added in v0.2.1 

func (resource *DbResource) GetOauthDescriptionByTokenReferenceId(referenceId string) (*oauth2.Config, error)

func (*DbResource) GetObjectGroupsByObjectId 

func (dr *DbResource) GetObjectGroupsByObjectId(objType string, objectId int64) []auth.GroupPermission

func (*DbResource) GetObjectPermission 

func (dr *DbResource) GetObjectPermission(objectType string, referenceId string) Permission

func (*DbResource) GetObjectPermissionByWhereClause 

func (dr *DbResource) GetObjectPermissionByWhereClause(objectType string, colName string, colValue string) Permission

func (*DbResource) GetObjectUserGroupsByWhere 

func (dr *DbResource) GetObjectUserGroupsByWhere(objType string, colName string, colvalue string) []auth.GroupPermission

func (*DbResource) GetReferenceIdByWhereClause 

func (dr *DbResource) GetReferenceIdByWhereClause(typeName string, queries ...squirrel.Eq) ([]string, error)

func (*DbResource) GetReferenceIdToId 

func (dr *DbResource) GetReferenceIdToId(typeName string, referenceId string) (uint64, error)

func (*DbResource) GetReferenceIdToObject 

func (dr *DbResource) GetReferenceIdToObject(typeName string, referenceId string) (map[string]interface{}, error)

func (*DbResource) GetRowPermission 

func (dr *DbResource) GetRowPermission(row map[string]interface{}) Permission

func (*DbResource) GetRowsByWhereClause 

func (dr *DbResource) GetRowsByWhereClause(typeName string, where squirrel.Eq) ([]map[string]interface{}, [][]map[string]interface{}, error)

func (*DbResource) GetSingleColumnValueByReferenceId 

func (dr *DbResource) GetSingleColumnValueByReferenceId(typeName string, selectColumn, matchColumn string, values []string) ([]interface{}, error)

func (*DbResource) GetSingleRowByReferenceId 

func (dr *DbResource) GetSingleRowByReferenceId(typeName string, referenceId string) (map[string]interface{}, []map[string]interface{}, error)

func (*DbResource) GetTokenByTokenId added in v0.2.1 

func (resource *DbResource) GetTokenByTokenId(id int64) (*oauth2.Token, error)

func (*DbResource) GetTokenByTokenReferenceId added in v0.2.1 

func (resource *DbResource) GetTokenByTokenReferenceId(referenceId string) (*oauth2.Token, error)

func (*DbResource) GetTotalCount 

func (dr *DbResource) GetTotalCount() uint64

func (*DbResource) GetUserGroupIdByUserId 

func (dr *DbResource) GetUserGroupIdByUserId(userId uint64) uint64

func (*DbResource) IsUserActionAllowed 

func (dr *DbResource) IsUserActionAllowed(userReferenceId string, userGroups []auth.GroupPermission, typeName string, actionName string) bool

func (*DbResource) PaginatedFindAll 

func (dr *DbResource) PaginatedFindAll(req api2go.Request) (totalCount uint, response api2go.Responder, err error)

PaginatedFindAll(req Request) (totalCount uint, response Responder, err error)

func (*DbResource) PutContext 

func (dr *DbResource) PutContext(key string, val interface{})

func (*DbResource) ResultToArrayOfMap 

func (dr *DbResource) ResultToArrayOfMap(rows *sqlx.Rows, columnMap map[string]api2go.ColumnInfo, includeNextLevel bool) ([]map[string]interface{}, [][]map[string]interface{}, error)

func (*DbResource) ResultToArrayOfMapRaw added in v0.2.1 

func (dr *DbResource) ResultToArrayOfMapRaw(rows *sqlx.Rows, columnMap map[string]api2go.ColumnInfo) ([]map[string]interface{}, error)

func (*DbResource) TruncateTable added in v0.2.1 

func (dr *DbResource) TruncateTable(typeName string) error

func (*DbResource) Update 

func (dr *DbResource) Update(obj interface{}, req api2go.Request) (api2go.Responder, error)

Update an object Possible Responder status codes are: - 200 OK: Update successful, however some field(s) were changed, returns updates source - 202 Accepted: Processing is delayed, return nothing - 204 No Content: Update was successful, no fields were changed by the server, return nothing

func (*DbResource) UpdateAccessTokenByTokenId added in v0.2.1 

func (resource *DbResource) UpdateAccessTokenByTokenId(id int64, accessToken string, expiresIn int64) error

func (*DbResource) UpdateAccessTokenByTokenReferenceId added in v0.2.1 

func (resource *DbResource) UpdateAccessTokenByTokenReferenceId(referenceId string, accessToken string, expiresIn int64) error

type DownloadCmsConfigActionPerformer 

type DownloadCmsConfigActionPerformer struct {
	// contains filtered or unexported fields
}

func (*DownloadCmsConfigActionPerformer) DoAction 

func (d *DownloadCmsConfigActionPerformer) DoAction(request ActionRequest, inFields map[string]interface{}) ([]ActionResponse, []error)

func (*DownloadCmsConfigActionPerformer) Name 

func (d *DownloadCmsConfigActionPerformer) Name() string

type ExchangeContract 

type ExchangeContract struct {
	Name             string
	SourceAttributes map[string]interface{} `db:"source_attributes",json:"source_attributes"`
	SourceType       string                 `db:"source_type",json:"source_type"`
	TargetAttributes map[string]interface{} `db:"target_attributes",json:"target_attributes"`
	TargetType       string                 `db:"target_type",json:"target_type"`
	Attributes       []ColumnMap            `db:"attributes",json:"attributes"`
	Options          map[string]interface{}
	ReferenceId      string `db:"reference_id",json:"reference_id"`
	OauthTokenId     *int64 `db:"oauth_token_id",json:"oauth_token_id"`
}

type ExchangeExecution 

type ExchangeExecution struct {
	ExchangeContract ExchangeContract
	// contains filtered or unexported fields
}

func NewExchangeExecution 

func NewExchangeExecution(exchange ExchangeContract, oauthToken *oauth2.Token, oauthConfig *oauth2.Config) *ExchangeExecution

func (*ExchangeExecution) Execute 

func (ec *ExchangeExecution) Execute(inFields map[string]interface{}, data []map[string]interface{}) (err error)

type ExchangeInterface 

type ExchangeInterface interface {
	Update(target string, data []map[string]interface{}) error
}

type ExchangeMiddleware 

type ExchangeMiddleware struct {
	// contains filtered or unexported fields
}

func (*ExchangeMiddleware) InterceptAfter 

func (em *ExchangeMiddleware) InterceptAfter(dr *DbResource, req *api2go.Request, results []map[string]interface{}) ([]map[string]interface{}, error)

func (*ExchangeMiddleware) InterceptBefore 

func (em *ExchangeMiddleware) InterceptBefore(dr *DbResource, req *api2go.Request, objects []map[string]interface{}) ([]map[string]interface{}, error)

func (*ExchangeMiddleware) String 

func (em *ExchangeMiddleware) String() string

type ExportDataPerformer added in v0.2.1 

type ExportDataPerformer struct {
	// contains filtered or unexported fields
}

func (*ExportDataPerformer) DoAction added in v0.2.1 

func (d *ExportDataPerformer) DoAction(request ActionRequest, inFields map[string]interface{}) ([]ActionResponse, []error)

func (*ExportDataPerformer) Name added in v0.2.1 

func (d *ExportDataPerformer) Name() string

type ExternalExchange 

type ExternalExchange interface {
	ExecuteTarget(row map[string]interface{}, inFieldMap map[string]interface{}) error
}

func NewRestExchangeHandler 

func NewRestExchangeHandler(exchangeContext ExchangeContract, oauthToken *oauth2.Token, oauthConfig *oauth2.Config) (ExternalExchange, error)

type Faker added in v0.2.1 

type Faker interface {
	Fake() string
}

type FileUploadActionPerformer added in v0.2.1 

type FileUploadActionPerformer struct {
	// contains filtered or unexported fields
}

func (*FileUploadActionPerformer) DoAction added in v0.2.1 

func (d *FileUploadActionPerformer) DoAction(request ActionRequest, inFields map[string]interface{}) ([]ActionResponse, []error)

func (*FileUploadActionPerformer) Name added in v0.2.1 

func (d *FileUploadActionPerformer) Name() string

type FsmManager 

type FsmManager interface {
	ApplyEvent(subject map[string]interface{}, stateMachineEvent StateMachineEvent) (string, error)
}

func NewFsmManager 

func NewFsmManager(db *sqlx.DB, cruds map[string]*DbResource) FsmManager

type GenerateJwtTokenActionPerformer 

type GenerateJwtTokenActionPerformer struct {
	// contains filtered or unexported fields
}

func (*GenerateJwtTokenActionPerformer) DoAction 

func (d *GenerateJwtTokenActionPerformer) DoAction(request ActionRequest, inFieldMap map[string]interface{}) ([]ActionResponse, []error)

func (*GenerateJwtTokenActionPerformer) Name 

func (d *GenerateJwtTokenActionPerformer) Name() string

type GomsError added in v0.2.1 

type GomsError struct {
	Message string
	Code    string
}

func NewGomsError added in v0.2.1 

func NewGomsError(str string, code string) GomsError

type ImportDataPerformer added in v0.2.1 

type ImportDataPerformer struct {
	// contains filtered or unexported fields
}

func (*ImportDataPerformer) DoAction added in v0.2.1 

func (d *ImportDataPerformer) DoAction(request ActionRequest, inFields map[string]interface{}) ([]ActionResponse, []error)

func (*ImportDataPerformer) Name added in v0.2.1 

func (d *ImportDataPerformer) Name() string

type LoopbackEventDesc 

type LoopbackEventDesc struct {
	// Name is the event name used when calling for a transition.
	Name  string
	Label string
	Color string

	// Src is a slice of source states that the FSM must be in to perform a
	// state transition.
	Src []string

	// Dst is the destination state that the FSM will be in if the transition
	// succeds.
	Dst string
}

type LoopbookFsmDescription 

type LoopbookFsmDescription struct {
	InitialState string `json:"initial_state"`
	Name         string
	Label        string
	Events       []LoopbackEventDesc `json:"events"`
}

type MiddlewareSet 

type MiddlewareSet struct {
	BeforeCreate  []DatabaseRequestInterceptor
	BeforeFindAll []DatabaseRequestInterceptor
	BeforeFindOne []DatabaseRequestInterceptor
	BeforeUpdate  []DatabaseRequestInterceptor
	BeforeDelete  []DatabaseRequestInterceptor

	AfterCreate  []DatabaseRequestInterceptor
	AfterFindAll []DatabaseRequestInterceptor
	AfterFindOne []DatabaseRequestInterceptor
	AfterUpdate  []DatabaseRequestInterceptor
	AfterDelete  []DatabaseRequestInterceptor
}

type OauthLoginBeginActionPerformer 

type OauthLoginBeginActionPerformer struct {
	// contains filtered or unexported fields
}

func (*OauthLoginBeginActionPerformer) DoAction 

func (d *OauthLoginBeginActionPerformer) DoAction(request ActionRequest, inFieldMap map[string]interface{}) ([]ActionResponse, []error)

func (*OauthLoginBeginActionPerformer) Name 

func (d *OauthLoginBeginActionPerformer) Name() string

type OauthLoginResponseActionPerformer 

type OauthLoginResponseActionPerformer struct {
	// contains filtered or unexported fields
}

func (*OauthLoginResponseActionPerformer) DoAction 

func (d *OauthLoginResponseActionPerformer) DoAction(request ActionRequest, inFieldMap map[string]interface{}) ([]ActionResponse, []error)

func (*OauthLoginResponseActionPerformer) Name 

func (d *OauthLoginResponseActionPerformer) Name() string

type ObjectAccessPermissionChecker added in v0.2.1 

type ObjectAccessPermissionChecker struct {
}

func (*ObjectAccessPermissionChecker) InterceptAfter added in v0.2.1 

func (pc *ObjectAccessPermissionChecker) InterceptAfter(dr *DbResource, req *api2go.Request, results []map[string]interface{}) ([]map[string]interface{}, error)

func (*ObjectAccessPermissionChecker) InterceptBefore added in v0.2.1 

func (pc *ObjectAccessPermissionChecker) InterceptBefore(dr *DbResource, req *api2go.Request, results []map[string]interface{}) ([]map[string]interface{}, error)

func (*ObjectAccessPermissionChecker) String added in v0.2.1 

func (pc *ObjectAccessPermissionChecker) String() string

type ObjectModificationAuditMiddleware added in v0.2.1 

type ObjectModificationAuditMiddleware struct {
}

func (*ObjectModificationAuditMiddleware) InterceptAfter added in v0.2.1 

func (omam *ObjectModificationAuditMiddleware) InterceptAfter(dr *DbResource, req *api2go.Request, results []map[string]interface{}) ([]map[string]interface{}, error)

func (*ObjectModificationAuditMiddleware) InterceptBefore added in v0.2.1 

func (omam *ObjectModificationAuditMiddleware) InterceptBefore(dr *DbResource, req *api2go.Request, results []map[string]interface{}) ([]map[string]interface{}, error)

func (*ObjectModificationAuditMiddleware) String added in v0.2.1 

func (omam *ObjectModificationAuditMiddleware) String() string

type Outcome 

type Outcome struct {
	Type       string `json:"type"`
	Method     string `json:"method"`
	Reference  string
	Attributes map[string]interface{} `json:"attributes"`
}

type Permission 

type Permission struct {
	UserId      string                 `json:"user_id"`
	UserGroupId []auth.GroupPermission `json:"usergroup_id"`
	Permission  int64                  `json:"permission"`
}

func (Permission) CanExecute 

func (p Permission) CanExecute(userId string, usergroupId []auth.GroupPermission) bool

func (Permission) CanRead 

func (p Permission) CanRead(userId string, usergroupId []auth.GroupPermission) bool

func (Permission) CanWrite 

func (p Permission) CanWrite(userId string, usergroupId []auth.GroupPermission) bool

func (Permission) CheckBit 

func (p1 Permission) CheckBit(userId string, usergroupId []auth.GroupPermission, bit int64) bool

type RestExchange 

type RestExchange struct {
	Name        string
	Method      string
	Url         string
	Headers     map[string]interface{}
	Body        map[string]interface{}
	QueryParams map[string]interface{}
}

type RestExternalExchange 

type RestExternalExchange struct {
	// contains filtered or unexported fields
}

func (*RestExternalExchange) ExecuteTarget 

func (g *RestExternalExchange) ExecuteTarget(row map[string]interface{}, inFieldMap map[string]interface{}) error

type RestartSystemActionPerformer 

type RestartSystemActionPerformer struct {
	// contains filtered or unexported fields
}

func (*RestartSystemActionPerformer) DoAction 

func (d *RestartSystemActionPerformer) DoAction(request ActionRequest, inFields map[string]interface{}) ([]ActionResponse, []error)

func (*RestartSystemActionPerformer) Name 

func (d *RestartSystemActionPerformer) Name() string

type StateMachineEvent 

type StateMachineEvent interface {
	GetStateMachineInstanceId() string
	GetEventName() string
}

func NewStateMachineEvent added in v0.2.1 

func NewStateMachineEvent(machineId string, eventName string) StateMachineEvent

type StateMachineInstance 

type StateMachineInstance struct {
	CurrestState   string
	StateMachineId int64
	ObjectId       int64
}

type StatusResponse 

type StatusResponse struct {
	Message string
}

type SubSite added in v0.2.1 

type SubSite struct {
	Name         string
	Hostname     string
	Path         string
	CloudStoreId int64 `db:"cloud_store_id"`
	Permission   int
	UserId       int64 `db:"user_id"`
}

type SubSiteInformation added in v0.2.1 

type SubSiteInformation struct {
	SubSite    SubSite
	CloudStore CloudStore
	SourceRoot string
}

type TableAccessPermissionChecker 

type TableAccessPermissionChecker struct {
}

func (*TableAccessPermissionChecker) InterceptAfter 

func (pc *TableAccessPermissionChecker) InterceptAfter(dr *DbResource, req *api2go.Request, results []map[string]interface{}) ([]map[string]interface{}, error)

func (*TableAccessPermissionChecker) InterceptBefore 

func (pc *TableAccessPermissionChecker) InterceptBefore(dr *DbResource, req *api2go.Request, results []map[string]interface{}) ([]map[string]interface{}, error)

func (*TableAccessPermissionChecker) String 

func (pc *TableAccessPermissionChecker) String() string

type TableInfo 

type TableInfo struct {
	TableName              string `db:"table_name"`
	TableId                int
	DefaultPermission      int64 `db:"default_permission"`
	Columns                []api2go.ColumnInfo
	StateMachines          []LoopbookFsmDescription
	Relations              []api2go.TableRelation
	IsTopLevel             bool `db:"is_top_level"`
	Permission             int64
	UserId                 uint64 `db:"user_id"`
	IsHidden               bool   `db:"is_hidden"`
	IsJoinTable            bool   `db:"is_join_table"`
	IsStateTrackingEnabled bool   `db:"is_state_tracking_enabled"`
	IsAuditEnabled         bool   `db:"is_audit_enabled"`
	Validations            []ColumnTag
	Conformations          []ColumnTag
}

type UploadFileToEntityPerformer added in v0.2.1 

type UploadFileToEntityPerformer struct {
	// contains filtered or unexported fields
}

func (*UploadFileToEntityPerformer) DoAction added in v0.2.1 

func (d *UploadFileToEntityPerformer) DoAction(request ActionRequest, inFields map[string]interface{}) ([]ActionResponse, []error)

func (*UploadFileToEntityPerformer) Name added in v0.2.1 

func (d *UploadFileToEntityPerformer) Name() string

type User 

type User struct {
	Name       string
	Email      string
	Password   string
	Id         uint64
	CreatedAt  time.Time
	UpdatedAt  time.Time
	Permission int
	Status     string
	DeletedAt  *time.Time `sql:"index"`
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.