handler

type AssetUploadHandler ¶

type AssetUploadHandler struct {
	AssetStore  skyAsset.Store   `inject:"AssetStore"`
	AccessKey   router.Processor `preprocessor:"accesskey"`
	DBConn      router.Processor `preprocessor:"dbconn"`
	PluginReady router.Processor `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

AssetUploadHandler models the handler for asset upload request

func (h *AssetUploadHandler) GetPreprocessors() []router.Processor

func (h *AssetUploadHandler) Handle(
	payload *router.Payload,
	response *router.Response,
)

func (h *AssetUploadHandler) Setup()

type AssetUploadResponse ¶

type AssetUploadResponse struct {
	PostRequest *skyAsset.PostFileRequest `json:"post-request"`
	Asset       *map[string]interface{}   `json:"asset"`
}

AssetUploadResponse models the response of asset upload request

type AuthResponse ¶

type AuthResponse struct {
	UserID      string     `json:"user_id,omitempty"`
	Username    string     `json:"username,omitempty"`
	Email       string     `json:"email,omitempty"`
	Roles       []string   `json:"roles,omitempty"`
	AccessToken string     `json:"access_token,omitempty"`
	LastLoginAt *time.Time `json:"last_login_at,omitempty"`
	LastSeenAt  *time.Time `json:"last_seen_at,omitempty"`
}

AuthResponse is the unify way of returing a UserInfo to SDK

func NewAuthResponse(info skydb.UserInfo, accessToken string) AuthResponse

type DeviceRegisterHandler ¶

type DeviceRegisterHandler struct {
	Authenticator router.Processor `preprocessor:"authenticator"`
	DBConn        router.Processor `preprocessor:"dbconn"`
	InjectUser    router.Processor `preprocessor:"inject_user"`
	InjectDB      router.Processor `preprocessor:"inject_db"`
	RequireUser   router.Processor `preprocessor:"require_user"`
	PluginReady   router.Processor `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

DeviceRegisterHandler creates or updates a device and associates it to a user

Example to create a new device:

curl -X POST -H "Content-Type: application/json" \
  -d @- http://localhost:3000/ <<EOF
{
	"action": "device:register",
	"access_token": "some-access-token",
	"type": "ios",
	"topic": "io.skygear.sample.topic",
	"device_token": "some-device-token"
}
EOF

Example to update an existing device:

curl -X POST -H "Content-Type: application/json" \
  -d @- http://localhost:3000/ <<EOF
{
	"action": "device:register",
	"access_token": "some-access-token",
	"id": "existing-device-id",
	"type": "ios",
	"device_token": "new-device-token"
}
EOF

func (h *DeviceRegisterHandler) GetPreprocessors() []router.Processor

func (h *DeviceRegisterHandler) Handle(rpayload *router.Payload, response *router.Response)

func (h *DeviceRegisterHandler) Setup()

type DeviceReigsterResult ¶

type DeviceReigsterResult struct {
	ID string `json:"id"`
}

DeviceReigsterResult is the result put onto response.Result on successful call of DeviceRegisterHandler

type DeviceUnregisterHandler ¶ added in v0.20.0

type DeviceUnregisterHandler struct {
	Authenticator router.Processor `preprocessor:"authenticator"`
	DBConn        router.Processor `preprocessor:"dbconn"`
	InjectUser    router.Processor `preprocessor:"inject_user"`
	InjectDB      router.Processor `preprocessor:"inject_db"`
	RequireUser   router.Processor `preprocessor:"require_user"`
	PluginReady   router.Processor `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

DeviceUnregisterHandler removes user id from a device

Example to unregister a device:

curl -X POST -H "Content-Type: application/json" \
  -d @- http://localhost:3000/ <<EOF
{
	"action": "device:unregister",
	"access_token": "some-access-token",
	"type": "ios",
	"device_token": "some-device-token"
}
EOF

func (h *DeviceUnregisterHandler) GetPreprocessors() []router.Processor

func (h *DeviceUnregisterHandler) Handle(rpayload *router.Payload, response *router.Response)

func (h *DeviceUnregisterHandler) Setup()

type GetFileHandler ¶

type GetFileHandler struct {
	AssetStore skyAsset.Store   `inject:"AssetStore"`
	DBConn     router.Processor `preprocessor:"dbconn"`
	// contains filtered or unexported fields
}

GetFileHandler models the handler for getting asset file

func (h *GetFileHandler) GetPreprocessors() []router.Processor

func (h *GetFileHandler) Handle(payload *router.Payload, response *router.Response)

func (h *GetFileHandler) Setup()

type HealthzHandler ¶ added in v0.21.1

type HealthzHandler struct {
	PluginReady router.Processor `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

func (h *HealthzHandler) GetPreprocessors() []router.Processor

func (h *HealthzHandler) Handle(playload *router.Payload, response *router.Response)

func (h *HealthzHandler) Setup()

type HomeHandler ¶

type HomeHandler struct {
}

HomeHandler temp landing. FIXME

func (h *HomeHandler) GetPreprocessors() []router.Processor

func (h *HomeHandler) Handle(playload *router.Payload, response *router.Response)

func (h *HomeHandler) Setup()

type LoginHandler ¶

type LoginHandler struct {
	TokenStore       authtoken.Store    `inject:"TokenStore"`
	ProviderRegistry *provider.Registry `inject:"ProviderRegistry"`
	HookRegistry     *hook.Registry     `inject:"HookRegistry"`
	AssetStore       asset.Store        `inject:"AssetStore"`
	AccessKey        router.Processor   `preprocessor:"accesskey"`
	DBConn           router.Processor   `preprocessor:"dbconn"`
	InjectPublicDB   router.Processor   `preprocessor:"inject_public_db"`
	PluginReady      router.Processor   `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

LoginHandler authenticate user with password

The user can be either identified by username or password.

curl -X POST -H "Content-Type: application/json" \
  -d @- http://localhost:3000/ <<EOF

{
    "action": "auth:login",
    "username": "rickmak",
    "email": "rick.mak@gmail.com",
    "password": "123456"
}

EOF

func (h *LoginHandler) GetPreprocessors() []router.Processor

func (h *LoginHandler) Handle(payload *router.Payload, response *router.Response)

func (h *LoginHandler) Setup()

type LogoutHandler ¶

type LogoutHandler struct {
	TokenStore    authtoken.Store  `inject:"TokenStore"`
	Authenticator router.Processor `preprocessor:"authenticator"`
	PluginReady   router.Processor `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

LogoutHandler receives an access token and invalidates it

func (h *LogoutHandler) GetPreprocessors() []router.Processor

func (h *LogoutHandler) Handle(payload *router.Payload, response *router.Response)

func (h *LogoutHandler) Setup()

type MeHandler ¶

type MeHandler struct {
	TokenStore    authtoken.Store  `inject:"TokenStore"`
	Authenticator router.Processor `preprocessor:"authenticator"`
	DBConn        router.Processor `preprocessor:"dbconn"`
	InjectUser    router.Processor `preprocessor:"inject_user"`
	PluginReady   router.Processor `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

MeHandler handles the me request

func (h *MeHandler) GetPreprocessors() []router.Processor

func (h *MeHandler) Handle(payload *router.Payload, response *router.Response)

curl -X POST -H "Content-Type: application/json" \
  -d @- http://localhost:3000/ <<EOF
{
    "action": "me"
}
EOF

{
  "user_id": "3df4b52b-bd58-4fa2-8aee-3d44fd7f974d",
  "username": "user1",
  "last_login_at": "2016-09-08T06:42:59.871181Z",
  "last_seen_at": "2016-09-08T07:15:18.026567355Z",
  "roles": []
}

func (h *MeHandler) Setup()

type PasswordHandler ¶

type PasswordHandler struct {
	TokenStore    authtoken.Store  `inject:"TokenStore"`
	Authenticator router.Processor `preprocessor:"authenticator"`
	DBConn        router.Processor `preprocessor:"dbconn"`
	InjectUser    router.Processor `preprocessor:"inject_user"`
	InjectDB      router.Processor `preprocessor:"inject_db"`
	PluginReady   router.Processor `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

PasswordHandler change the current user password

PasswordHandler receives three parameters:

* old_password (string, required) * password (string, required)

If user is not logged in, an 404 not found will return.

Current implementation
curl -X POST -H "Content-Type: application/json" \
  -d @- http://localhost:3000/ <<EOF
{
    "action": "auth:password",
    "old_password": "rick.mak@gmail.com",
    "password": "123456"
}
EOF

Response return existing access toektn if not invalidate

TODO: Input accept `user_id` and `invalidate`. If `user_id` is supplied, will check authorization policy and see if existing accept `invalidate` and invaldate all existing access token. Return userInfoID with new AccessToken if the invalidate is true

func (h *PasswordHandler) GetPreprocessors() []router.Processor

func (h *PasswordHandler) Handle(payload *router.Payload, response *router.Response)

func (h *PasswordHandler) Setup()

type PubSubHandler ¶

type PubSubHandler struct {
	WebSocket *pubsub.WsPubSub
	AccessKey router.Processor `preprocessor:"accesskey"`
	// contains filtered or unexported fields
}

func (h *PubSubHandler) GetPreprocessors() []router.Processor

func (h *PubSubHandler) Handle(payload *router.Payload, response *router.Response)

func (h *PubSubHandler) Setup()

type PushToDeviceHandler ¶

type PushToDeviceHandler struct {
	NotificationSender push.Sender      `inject:"PushSender"`
	AccessKey          router.Processor `preprocessor:"accesskey"`
	DBConn             router.Processor `preprocessor:"dbconn"`
	InjectDB           router.Processor `preprocessor:"inject_db"`
	Notification       router.Processor `preprocessor:"notification"`
	PluginReady        router.Processor `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

func (h *PushToDeviceHandler) GetPreprocessors() []router.Processor

func (h *PushToDeviceHandler) Handle(rpayload *router.Payload, response *router.Response)

func (h *PushToDeviceHandler) Setup()

type PushToUserHandler ¶

type PushToUserHandler struct {
	NotificationSender push.Sender      `inject:"PushSender"`
	AccessKey          router.Processor `preprocessor:"accesskey"`
	DBConn             router.Processor `preprocessor:"dbconn"`
	InjectDB           router.Processor `preprocessor:"inject_db"`
	Notification       router.Processor `preprocessor:"notification"`
	PluginReady        router.Processor `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

func (h *PushToUserHandler) GetPreprocessors() []router.Processor

func (h *PushToUserHandler) Handle(rpayload *router.Payload, response *router.Response)

func (h *PushToUserHandler) Setup()

type QueryParser ¶

type QueryParser struct {
	UserID string
}

QueryParser is a context for parsing raw query to skydb.Query

type RecordDeleteHandler ¶

type RecordDeleteHandler struct {
	HookRegistry  *hook.Registry    `inject:"HookRegistry"`
	AccessModel   skydb.AccessModel `inject:"AccessModel"`
	Authenticator router.Processor  `preprocessor:"authenticator"`
	DBConn        router.Processor  `preprocessor:"dbconn"`
	InjectUser    router.Processor  `preprocessor:"inject_user"`
	InjectDB      router.Processor  `preprocessor:"inject_db"`
	RequireUser   router.Processor  `preprocessor:"require_user"`
	PluginReady   router.Processor  `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

RecordDeleteHandler is dummy implementation on delete Records

curl -X POST -H "Content-Type: application/json" \
  -d @- http://localhost:3000/ <<EOF

{
    "action": "record:delete",
    "access_token": "validToken",
    "database_id": "_private",
    "ids": ["note/EA6A3E68-90F3-49B5-B470-5FFDB7A0D4E8"]
}

EOF

func (h *RecordDeleteHandler) GetPreprocessors() []router.Processor

func (h *RecordDeleteHandler) Handle(payload *router.Payload, response *router.Response)

func (h *RecordDeleteHandler) Setup()

type RecordFetchHandler ¶

type RecordFetchHandler struct {
	AssetStore    asset.Store       `inject:"AssetStore"`
	AccessModel   skydb.AccessModel `inject:"AccessModel"`
	Authenticator router.Processor  `preprocessor:"authenticator"`
	DBConn        router.Processor  `preprocessor:"dbconn"`
	InjectUser    router.Processor  `preprocessor:"inject_user"`
	InjectDB      router.Processor  `preprocessor:"inject_db"`
	PluginReady   router.Processor  `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

RecordFetchHandler is dummy implementation on fetching Records

curl -X POST -H "Content-Type: application/json" \
  -d @- http://localhost:3000/ <<EOF

{
    "action": "record:fetch",
    "access_token": "validToken",
    "database_id": "_private",
    "ids": ["note/1004", "note/1005"]
}

EOF

func (h *RecordFetchHandler) GetPreprocessors() []router.Processor

func (h *RecordFetchHandler) Handle(payload *router.Payload, response *router.Response)

func (h *RecordFetchHandler) Setup()

type RecordQueryHandler ¶

type RecordQueryHandler struct {
	AssetStore    asset.Store       `inject:"AssetStore"`
	AccessModel   skydb.AccessModel `inject:"AccessModel"`
	Authenticator router.Processor  `preprocessor:"authenticator"`
	DBConn        router.Processor  `preprocessor:"dbconn"`
	InjectUser    router.Processor  `preprocessor:"inject_user"`
	InjectDB      router.Processor  `preprocessor:"inject_db"`
	PluginReady   router.Processor  `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

RecordQueryHandler is dummy implementation on fetching Records

curl -X POST -H "Content-Type: application/json" \
  -d @- http://localhost:3000/ <<EOF

{
    "action": "record:query",
    "access_token": "validToken",
    "database_id": "_private",
    "record_type": "note",
    "sort": [
        [{"$val": "noteOrder", "$type": "desc"}, "asc"]
    ]
}

EOF

func (h *RecordQueryHandler) GetPreprocessors() []router.Processor

func (h *RecordQueryHandler) Handle(payload *router.Payload, response *router.Response)

func (h *RecordQueryHandler) Setup()

type RecordSaveHandler ¶

type RecordSaveHandler struct {
	HookRegistry  *hook.Registry     `inject:"HookRegistry"`
	AssetStore    asset.Store        `inject:"AssetStore"`
	AccessModel   skydb.AccessModel  `inject:"AccessModel"`
	EventSender   pluginEvent.Sender `inject:"PluginEventSender"`
	Authenticator router.Processor   `preprocessor:"authenticator"`
	DBConn        router.Processor   `preprocessor:"dbconn"`
	InjectUser    router.Processor   `preprocessor:"inject_user"`
	InjectDB      router.Processor   `preprocessor:"inject_db"`
	RequireUser   router.Processor   `preprocessor:"require_user"`
	PluginReady   router.Processor   `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

RecordSaveHandler is dummy implementation on save/modify Records

curl -X POST -H "Content-Type: application/json" \
  -d @- http://localhost:3000/ <<EOF

{
    "action": "record:save",
    "access_token": "validToken",
    "database_id": "_public",
    "records": [{
        "_id": "note/EA6A3E68-90F3-49B5-B470-5FFDB7A0D4E8",
        "content": "ewdsa",
        "_access": [{
            "role": "admin",
            "level": "write"
        }]
    }]
}

EOF

Save with reference

curl -X POST -H "Content-Type: application/json" \
  -d @- http://localhost:3000/ <<EOF

{
  "action": "record:save",
  "database_id": "_public",
  "access_token": "986bee3b-8dd9-45c2-b40c-8b6ef274cf12",
  "records": [
    {
      "collection": {
        "$type": "ref",
        "$id": "collection/10"
      },
      "noteOrder": 1,
      "content": "hi",
      "_id": "note/71BAE736-E9C5-43CB-ADD1-D8633B80CAFA",
      "_type": "record",
      "_access": [{
          "role": "admin",
          "level": "write"
      }]
    }
  ]
}

EOF

func (h *RecordSaveHandler) GetPreprocessors() []router.Processor

func (h *RecordSaveHandler) Handle(payload *router.Payload, response *router.Response)

func (h *RecordSaveHandler) Setup()

type RelationAddHandler ¶

type RelationAddHandler struct {
	Authenticator router.Processor `preprocessor:"authenticator"`
	DBConn        router.Processor `preprocessor:"dbconn"`
	InjectUser    router.Processor `preprocessor:"inject_user"`
	InjectDB      router.Processor `preprocessor:"inject_db"`
	PluginReady   router.Processor `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

RelationAddHandler add current user relation

curl -X POST -H "Content-Type: application/json" \
  -d @- http://localhost:3000/ <<EOF

{
    "action": "relation:add",
    "access_token": "ACCESS_TOKEN",
    "name": "follow",
    "targets": [
        "1001",
        "1002"
    ]
}

EOF

{
    "request_id": "REQUEST_ID",
    "result": [
        {
            "id": "1001",
            "type": "user",
            "data": {
                "_id": "1001",
                "username": "user1001",
                "email": "user1001@skygear.io"
            }
        },
        {
            "id": "1002",
            "type": "error",
            "data": {
                "type": "ResourceFetchFailure",
                "code": 101,
                "message": "failed to fetch user id = 1002"
            }
        }
    ]
}

func (h *RelationAddHandler) GetPreprocessors() []router.Processor

func (h *RelationAddHandler) Handle(rpayload *router.Payload, response *router.Response)

func (h *RelationAddHandler) Setup()

type RelationQueryHandler ¶

type RelationQueryHandler struct {
	Authenticator router.Processor `preprocessor:"authenticator"`
	DBConn        router.Processor `preprocessor:"dbconn"`
	InjectUser    router.Processor `preprocessor:"inject_user"`
	InjectDB      router.Processor `preprocessor:"inject_db"`
	PluginReady   router.Processor `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

RelationQueryHandler query user from current users' relation

curl -X POST -H "Content-Type: application/json" \
  -d @- http://localhost:3000/ <<EOF

{
    "action": "relation:query",
    "access_token": "ACCESS_TOKEN",
    "name": "follow",
    "direction": "outward"
	   "limit": 2
	   "offset": 0
}

EOF

{
    "request_id": "REQUEST_ID",
    "result": [
        {
            "id": "1001",
            "type": "user",
            "data": {
                "_id": "1001",
                "username": "user1001",
                "email": "user1001@skygear.io"
            }
        },
        {
            "id": "1002",
            "type": "user",
            "data": {
                "_id": "1002",
                "username": "user1002",
                "email": "user1001@skygear.io"
            }
        }
    ],
    "info": {
        "count": 2
    }
}

func (h *RelationQueryHandler) GetPreprocessors() []router.Processor

func (h *RelationQueryHandler) Handle(rpayload *router.Payload, response *router.Response)

func (h *RelationQueryHandler) Setup()

type RelationRemoveHandler ¶

type RelationRemoveHandler struct {
	Authenticator router.Processor `preprocessor:"authenticator"`
	DBConn        router.Processor `preprocessor:"dbconn"`
	InjectUser    router.Processor `preprocessor:"inject_user"`
	InjectDB      router.Processor `preprocessor:"inject_db"`
	PluginReady   router.Processor `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

RelationRemoveHandler remove a users' relation to other users

curl -X POST -H "Content-Type: application/json" \
  -d @- http://localhost:3000/ <<EOF

{
    "action": "relation:remove",
    "access_token": "ACCESS_TOKEN",
    "name": "follow",
    "targets": [
        "1001",
        "1002"
    ]
}

EOF

func (h *RelationRemoveHandler) GetPreprocessors() []router.Processor

func (h *RelationRemoveHandler) Handle(rpayload *router.Payload, response *router.Response)

func (h *RelationRemoveHandler) Setup()

type RoleAdminHandler ¶

type RoleAdminHandler struct {
	AccessKey   router.Processor `preprocessor:"accesskey"`
	DevOnly     router.Processor `preprocessor:"dev_only"`
	DBConn      router.Processor `preprocessor:"dbconn"`
	PluginReady router.Processor `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

RoleAdminHandler enable system administrator to set which roles can perform administrative action, like change others user role.

curl -X POST -H "Content-Type: application/json" \
  -d @- http://localhost:3000/ <<EOF

{
    "action": "role:default",
    "master_key": "MASTER_KEY",
    "access_token": "ACCESS_TOKEN",
    "roles": [
       "admin",
       "moderator"
    ]
}

EOF

{
    "result": [
       "admin",
       "moderator"
    ]
}

func (h *RoleAdminHandler) GetPreprocessors() []router.Processor

func (h *RoleAdminHandler) Handle(rpayload *router.Payload, response *router.Response)

func (h *RoleAdminHandler) Setup()

type RoleDefaultHandler ¶

type RoleDefaultHandler struct {
	AccessKey   router.Processor `preprocessor:"accesskey"`
	DevOnly     router.Processor `preprocessor:"dev_only"`
	DBConn      router.Processor `preprocessor:"dbconn"`
	PluginReady router.Processor `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

RoleDefaultHandler enable system administrator to set default user role

curl -X POST -H "Content-Type: application/json" \
  -d @- http://localhost:3000/ <<EOF

{
    "action": "role:default",
    "master_key": "MASTER_KEY",
    "access_token": "ACCESS_TOKEN",
    "roles": [
       "writer",
       "user"
    ]
}

EOF

{
    "result": [
       "writer",
       "user"
    ]
}

func (h *RoleDefaultHandler) GetPreprocessors() []router.Processor

func (h *RoleDefaultHandler) Handle(rpayload *router.Payload, response *router.Response)

func (h *RoleDefaultHandler) Setup()

type SchemaAccessHandler ¶

type SchemaAccessHandler struct {
	AccessKey   router.Processor `preprocessor:"accesskey"`
	DevOnly     router.Processor `preprocessor:"dev_only"`
	DBConn      router.Processor `preprocessor:"dbconn"`
	InjectDB    router.Processor `preprocessor:"inject_db"`
	PluginReady router.Processor `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

SchemaAccessHandler handles the update of creation access of record

curl -X POST -H "Content-Type: application/json" \
  -d @- http://localhost:3000/schema/access <<EOF

{
	"master_key": "MASTER_KEY",
	"action": "schema:access",
	"type": "note",
	"create_roles": [
		"admin",
		"writer"
	]
}

EOF

func (h *SchemaAccessHandler) GetPreprocessors() []router.Processor

func (h *SchemaAccessHandler) Handle(rpayload *router.Payload, response *router.Response)

func (h *SchemaAccessHandler) Setup()

type SchemaCreateHandler ¶

type SchemaCreateHandler struct {
	EventSender pluginEvent.Sender `inject:"PluginEventSender"`
	AccessKey   router.Processor   `preprocessor:"accesskey"`
	DevOnly     router.Processor   `preprocessor:"dev_only"`
	DBConn      router.Processor   `preprocessor:"dbconn"`
	InjectDB    router.Processor   `preprocessor:"inject_db"`
	PluginReady router.Processor   `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

SchemaCreateHandler handles the action of creating new columns

curl -X POST -H "Content-Type: application/json" \
  -d @- http://localhost:3000/schema/create <<EOF

{
	"master_key": "MASTER_KEY",
	"action": "schema:create",
	"record_types":{
		"student": {
			"fields":[
				{"name": "age", "type": "number"},
				{"name": "nickname" "type": "string"}
			]
		}
	}
}

EOF

func (h *SchemaCreateHandler) GetPreprocessors() []router.Processor

func (h *SchemaCreateHandler) Handle(rpayload *router.Payload, response *router.Response)

func (h *SchemaCreateHandler) Setup()

type SchemaDeleteHandler ¶

type SchemaDeleteHandler struct {
	EventSender pluginEvent.Sender `inject:"PluginEventSender"`
	AccessKey   router.Processor   `preprocessor:"accesskey"`
	DevOnly     router.Processor   `preprocessor:"dev_only"`
	DBConn      router.Processor   `preprocessor:"dbconn"`
	InjectDB    router.Processor   `preprocessor:"inject_db"`
	PluginReady router.Processor   `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

SchemaDeleteHandler handles the action of deleting column

curl -X POST -H "Content-Type: application/json" \
  -d @- http://localhost:3000/schema/delete <<EOF

{
	"master_key": "MASTER_KEY",
	"action": "schema:delete",
	"record_type": "student",
	"item_name": "score"
}

EOF

func (h *SchemaDeleteHandler) GetPreprocessors() []router.Processor

func (h *SchemaDeleteHandler) Handle(rpayload *router.Payload, response *router.Response)

func (h *SchemaDeleteHandler) Setup()

type SchemaFetchHandler ¶

type SchemaFetchHandler struct {
	AccessKey   router.Processor `preprocessor:"accesskey"`
	DevOnly     router.Processor `preprocessor:"dev_only"`
	DBConn      router.Processor `preprocessor:"dbconn"`
	InjectDB    router.Processor `preprocessor:"inject_db"`
	PluginReady router.Processor `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

SchemaFetchHandler handles the action of returing information of record schema

curl -X POST -H "Content-Type: application/json" \
  -d @- http://localhost:3000/schema/fetch <<EOF

{
	"master_key": "MASTER_KEY",
	"action": "schema:fetch"
}

EOF

func (h *SchemaFetchHandler) GetPreprocessors() []router.Processor

func (h *SchemaFetchHandler) Handle(rpayload *router.Payload, response *router.Response)

func (h *SchemaFetchHandler) Setup()

type SchemaRenameHandler ¶

type SchemaRenameHandler struct {
	EventSender pluginEvent.Sender `inject:"PluginEventSender"`
	AccessKey   router.Processor   `preprocessor:"accesskey"`
	DevOnly     router.Processor   `preprocessor:"dev_only"`
	DBConn      router.Processor   `preprocessor:"dbconn"`
	InjectDB    router.Processor   `preprocessor:"inject_db"`
	PluginReady router.Processor   `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

SchemaRenameHandler handles the action of renaming column

curl -X POST -H "Content-Type: application/json" \
  -d @- http://localhost:3000/schema/rename <<EOF

{
	"master_key": "MASTER_KEY",
	"action": "schema:rename",
	"record_type": "student",
	"item_type": "field",
	"item_name": "score",
	"new_name": "exam_score"
}

EOF

func (h *SchemaRenameHandler) GetPreprocessors() []router.Processor

func (h *SchemaRenameHandler) Handle(rpayload *router.Payload, response *router.Response)

func (h *SchemaRenameHandler) Setup()

type SignupHandler ¶

type SignupHandler struct {
	TokenStore       authtoken.Store    `inject:"TokenStore"`
	ProviderRegistry *provider.Registry `inject:"ProviderRegistry"`
	HookRegistry     *hook.Registry     `inject:"HookRegistry"`
	AssetStore       asset.Store        `inject:"AssetStore"`
	AccessModel      skydb.AccessModel  `inject:"AccessModel"`
	AccessKey        router.Processor   `preprocessor:"accesskey"`
	DBConn           router.Processor   `preprocessor:"dbconn"`
	InjectPublicDB   router.Processor   `preprocessor:"inject_public_db"`
	PluginReady      router.Processor   `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

SignupHandler creates an UserInfo with the supplied information.

SignupHandler receives three parameters:

* username (string, unique, optional) * email (string, unqiue, optional) * password (string, optional)

If both username and email is not supplied, an anonymous user is created and have user_id auto-generated. SignupHandler writes an error to response.Result if the supplied username or email collides with an existing username.

curl -X POST -H "Content-Type: application/json" \
  -d @- http://localhost:3000/ <<EOF
{
    "action": "auth:signup",
    "username": "rickmak",
    "email": "rick.mak@gmail.com",
    "password": "123456"
}
EOF

func (h *SignupHandler) GetPreprocessors() []router.Processor

func (h *SignupHandler) Handle(payload *router.Payload, response *router.Response)

func (h *SignupHandler) Setup()

type SubscriptionDeleteHandler ¶

type SubscriptionDeleteHandler struct {
	Authenticator router.Processor `preprocessor:"authenticator"`
	DBConn        router.Processor `preprocessor:"dbconn"`
	InjectUser    router.Processor `preprocessor:"inject_user"`
	InjectDB      router.Processor `preprocessor:"inject_db"`
	RequireUser   router.Processor `preprocessor:"require_user"`
	PluginReady   router.Processor `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

SubscriptionDeleteHandler deletes subscriptions from the specified Database.

Example curl:

curl -X POST -H "Content-Type: application/json" \
  -d @- http://localhost:3000/ <<EOF
{
    "action": "subscription:delete",
    "access_token": "ACCESS_TOKEN",
    "database_id": "_private",
    "subscription_ids": ["SUBSCRIPTION_ID"]
}
EOF

func (h *SubscriptionDeleteHandler) GetPreprocessors() []router.Processor

func (h *SubscriptionDeleteHandler) Handle(rpayload *router.Payload, response *router.Response)

func (h *SubscriptionDeleteHandler) Setup()

type SubscriptionFetchAllHandler ¶

type SubscriptionFetchAllHandler struct {
	Authenticator router.Processor `preprocessor:"authenticator"`
	DBConn        router.Processor `preprocessor:"dbconn"`
	InjectUser    router.Processor `preprocessor:"inject_user"`
	InjectDB      router.Processor `preprocessor:"inject_db"`
	RequireUser   router.Processor `preprocessor:"require_user"`
	PluginReady   router.Processor `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

SubscriptionFetchAllHandler fetches all subscriptions of a device

curl -X POST -H "Content-Type: application/json" \
  -d @- http://localhost:3000/ <<EOF
{
    "action": "subscription:fetch_all",
    "access_token": "ACCESS_TOKEN",
    "database_id": "_private",
    "device_id": "DEVICE_ID"
}
EOF

func (h *SubscriptionFetchAllHandler) GetPreprocessors() []router.Processor

func (h *SubscriptionFetchAllHandler) Handle(rpayload *router.Payload, response *router.Response)

func (h *SubscriptionFetchAllHandler) Setup()

type SubscriptionFetchHandler ¶

type SubscriptionFetchHandler struct {
	Authenticator router.Processor `preprocessor:"authenticator"`
	DBConn        router.Processor `preprocessor:"dbconn"`
	InjectUser    router.Processor `preprocessor:"inject_user"`
	InjectDB      router.Processor `preprocessor:"inject_db"`
	RequireUser   router.Processor `preprocessor:"require_user"`
	PluginReady   router.Processor `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

SubscriptionFetchHandler fetches subscriptions from the specified Database.

Example curl:

curl -X POST -H "Content-Type: application/json" \
  -d @- http://localhost:3000/ <<EOF
{
    "action": "subscription:fetch",
    "access_token": "ACCESS_TOKEN",
    "database_id": "_private",
    "device_id": "DEVICE_ID",
    "subscription_ids": ["SUBSCRIPTION_ID"]
}
EOF

func (h *SubscriptionFetchHandler) GetPreprocessors() []router.Processor

func (h *SubscriptionFetchHandler) Handle(rpayload *router.Payload, response *router.Response)

func (h *SubscriptionFetchHandler) Setup()

type SubscriptionSaveHandler ¶

type SubscriptionSaveHandler struct {
	Authenticator router.Processor `preprocessor:"authenticator"`
	DBConn        router.Processor `preprocessor:"dbconn"`
	InjectUser    router.Processor `preprocessor:"inject_user"`
	InjectDB      router.Processor `preprocessor:"inject_db"`
	RequireUser   router.Processor `preprocessor:"require_user"`
	PluginReady   router.Processor `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

SubscriptionSaveHandler saves one or more subscriptions associate with a database.

Example curl:

curl -X POST -H "Content-Type: application/json" \
  -d @- http://localhost:3000/ <<EOF
{
    "action": "subscription:save",
    "access_token": "ACCESS_TOKEN",
    "database_id": "_private",
    "device_id": "DEVICE_ID",
    "subscriptions": [
        {
            "id": "SUBSCRIPTION_ID",
            "notification_info": {
                "aps": {
                    "alert": {
                        "body": "BODY_TEXT",
                        "action-loc-key": "ACTION_LOC_KEY",
                        "loc-key": "LOC_KEY",
                        "loc-args": ["LOC_ARGS"],
                        "launch-image": "LAUNCH_IMAGE"
                    },
                    "sound": "SOUND_NAME",
                    "should-badge": true,
                    "should-send-content-available": true
                }
            },
            "type": "query",
            "query": {
                "record_type": "RECORD_TYPE",
                "predicate": {}
            }
        }
    ]
}
EOF

func (h *SubscriptionSaveHandler) GetPreprocessors() []router.Processor

func (h *SubscriptionSaveHandler) Handle(rpayload *router.Payload, response *router.Response)

func (h *SubscriptionSaveHandler) Setup()

type UploadFileHandler ¶

type UploadFileHandler struct {
	AssetStore skyAsset.Store   `inject:"AssetStore"`
	AccessKey  router.Processor `preprocessor:"accesskey"`
	DBConn     router.Processor `preprocessor:"dbconn"`
	// contains filtered or unexported fields
}

UploadFileHandler receives and persists a file to be associated by Record.

Example curl (PUT):

curl -XPUT \
	-H 'X-Skygear-API-Key: apiKey' \
	-H 'Content-Type: text/plain' \
	--data-binary '@file.txt' \
	http://localhost:3000/files/filename

Example curl (POST):

	curl -XPOST \
   -H "X-Skygear-API-Key: apiKey" \
   -F 'file=@file.txt' \
   http://localhost:3000/files/filename

func (h *UploadFileHandler) GetPreprocessors() []router.Processor

func (h *UploadFileHandler) Handle(
	payload *router.Payload,
	response *router.Response,
)

func (h *UploadFileHandler) Setup()

type UserLinkHandler ¶

type UserLinkHandler struct {
	ProviderRegistry *provider.Registry `inject:"ProviderRegistry"`
	Authenticator    router.Processor   `preprocessor:"authenticator"`
	DBConn           router.Processor   `preprocessor:"dbconn"`
	InjectUser       router.Processor   `preprocessor:"inject_user"`
	InjectDB         router.Processor   `preprocessor:"inject_db"`
	RequireUser      router.Processor   `preprocessor:"require_user"`
	PluginReady      router.Processor   `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

UserLinkHandler lets user associate third-party accounts with the user, with third-party authentication handled by plugin.

func (h *UserLinkHandler) GetPreprocessors() []router.Processor

func (h *UserLinkHandler) Handle(payload *router.Payload, response *router.Response)

func (h *UserLinkHandler) Setup()

type UserQueryHandler ¶

type UserQueryHandler struct {
	Authenticator router.Processor `preprocessor:"authenticator"`
	DBConn        router.Processor `preprocessor:"dbconn"`
	InjectUser    router.Processor `preprocessor:"inject_user"`
	InjectDB      router.Processor `preprocessor:"inject_db"`
	PluginReady   router.Processor `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

func (h *UserQueryHandler) GetPreprocessors() []router.Processor

func (h *UserQueryHandler) Handle(payload *router.Payload, response *router.Response)

func (h *UserQueryHandler) Setup()

type UserUpdateHandler ¶

type UserUpdateHandler struct {
	AccessModel   skydb.AccessModel `inject:"AccessModel"`
	Authenticator router.Processor  `preprocessor:"authenticator"`
	DBConn        router.Processor  `preprocessor:"dbconn"`
	InjectUser    router.Processor  `preprocessor:"inject_user"`
	InjectDB      router.Processor  `preprocessor:"inject_db"`
	RequireUser   router.Processor  `preprocessor:"require_user"`
	PluginReady   router.Processor  `preprocessor:"plugin_ready"`
	// contains filtered or unexported fields
}

func (h *UserUpdateHandler) GetPreprocessors() []router.Processor

func (h *UserUpdateHandler) Handle(payload *router.Payload, response *router.Response)

func (h *UserUpdateHandler) Setup()