github.com/cs3org/reva/v2@v2.27.7/pkg/events/files.go (about)

     1  // Copyright 2018-2022 CERN
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  //
    15  // In applying this license, CERN does not waive the privileges and immunities
    16  // granted to it by virtue of its status as an Intergovernmental Organization
    17  // or submit itself to any jurisdiction.
    18  
    19  package events
    20  
    21  import (
    22  	"encoding/json"
    23  
    24  	user "github.com/cs3org/go-cs3apis/cs3/identity/user/v1beta1"
    25  	provider "github.com/cs3org/go-cs3apis/cs3/storage/provider/v1beta1"
    26  	types "github.com/cs3org/go-cs3apis/cs3/types/v1beta1"
    27  )
    28  
    29  // ContainerCreated is emitted when a directory has been created
    30  type ContainerCreated struct {
    31  	SpaceOwner        *user.UserId
    32  	Executant         *user.UserId
    33  	Ref               *provider.Reference
    34  	Owner             *user.UserId
    35  	Timestamp         *types.Timestamp
    36  	ImpersonatingUser *user.User
    37  }
    38  
    39  // Unmarshal to fulfill umarshaller interface
    40  func (ContainerCreated) Unmarshal(v []byte) (interface{}, error) {
    41  	e := ContainerCreated{}
    42  	err := json.Unmarshal(v, &e)
    43  	return e, err
    44  }
    45  
    46  // FileUploaded is emitted when a file is uploaded
    47  type FileUploaded struct {
    48  	SpaceOwner        *user.UserId
    49  	Executant         *user.UserId
    50  	Ref               *provider.Reference
    51  	Owner             *user.UserId
    52  	Timestamp         *types.Timestamp
    53  	ImpersonatingUser *user.User
    54  }
    55  
    56  // Unmarshal to fulfill umarshaller interface
    57  func (FileUploaded) Unmarshal(v []byte) (interface{}, error) {
    58  	e := FileUploaded{}
    59  	err := json.Unmarshal(v, &e)
    60  	return e, err
    61  }
    62  
    63  // FileTouched is emitted when a file is uploaded
    64  type FileTouched struct {
    65  	SpaceOwner        *user.UserId
    66  	Executant         *user.UserId
    67  	Ref               *provider.Reference
    68  	Timestamp         *types.Timestamp
    69  	ImpersonatingUser *user.User
    70  }
    71  
    72  // Unmarshal to fulfill umarshaller interface
    73  func (FileTouched) Unmarshal(v []byte) (interface{}, error) {
    74  	e := FileTouched{}
    75  	err := json.Unmarshal(v, &e)
    76  	return e, err
    77  }
    78  
    79  // FileDownloaded is emitted when a file is downloaded
    80  type FileDownloaded struct {
    81  	Executant         *user.UserId
    82  	Ref               *provider.Reference
    83  	Owner             *user.UserId
    84  	Timestamp         *types.Timestamp
    85  	ImpersonatingUser *user.User
    86  }
    87  
    88  // Unmarshal to fulfill umarshaller interface
    89  func (FileDownloaded) Unmarshal(v []byte) (interface{}, error) {
    90  	e := FileDownloaded{}
    91  	err := json.Unmarshal(v, &e)
    92  	return e, err
    93  }
    94  
    95  // FileLocked is emitted when a file is locked
    96  type FileLocked struct {
    97  	Executant         *user.UserId
    98  	Ref               *provider.Reference
    99  	Owner             *user.UserId
   100  	Timestamp         *types.Timestamp
   101  	ImpersonatingUser *user.User
   102  }
   103  
   104  // Unmarshal to fulfill umarshaller interface
   105  func (FileLocked) Unmarshal(v []byte) (interface{}, error) {
   106  	e := FileLocked{}
   107  	err := json.Unmarshal(v, &e)
   108  	return e, err
   109  }
   110  
   111  // FileUnlocked is emitted when a file is unlocked
   112  type FileUnlocked struct {
   113  	Executant         *user.UserId
   114  	Ref               *provider.Reference
   115  	Owner             *user.UserId
   116  	Timestamp         *types.Timestamp
   117  	ImpersonatingUser *user.User
   118  }
   119  
   120  // Unmarshal to fulfill umarshaller interface
   121  func (FileUnlocked) Unmarshal(v []byte) (interface{}, error) {
   122  	e := FileUnlocked{}
   123  	err := json.Unmarshal(v, &e)
   124  	return e, err
   125  }
   126  
   127  // ItemTrashed is emitted when a file or folder is trashed
   128  type ItemTrashed struct {
   129  	SpaceOwner        *user.UserId
   130  	Executant         *user.UserId
   131  	ID                *provider.ResourceId
   132  	Ref               *provider.Reference
   133  	Owner             *user.UserId
   134  	Timestamp         *types.Timestamp
   135  	ImpersonatingUser *user.User
   136  }
   137  
   138  // Unmarshal to fulfill umarshaller interface
   139  func (ItemTrashed) Unmarshal(v []byte) (interface{}, error) {
   140  	e := ItemTrashed{}
   141  	err := json.Unmarshal(v, &e)
   142  	return e, err
   143  }
   144  
   145  // ItemMoved is emitted when a file or folder is moved
   146  type ItemMoved struct {
   147  	SpaceOwner        *user.UserId
   148  	Executant         *user.UserId
   149  	Ref               *provider.Reference
   150  	Owner             *user.UserId
   151  	OldReference      *provider.Reference
   152  	Timestamp         *types.Timestamp
   153  	ImpersonatingUser *user.User
   154  }
   155  
   156  // Unmarshal to fulfill umarshaller interface
   157  func (ItemMoved) Unmarshal(v []byte) (interface{}, error) {
   158  	e := ItemMoved{}
   159  	err := json.Unmarshal(v, &e)
   160  	return e, err
   161  }
   162  
   163  // ItemPurged is emitted when a file or folder is removed from trashbin
   164  type ItemPurged struct {
   165  	Executant         *user.UserId
   166  	ID                *provider.ResourceId
   167  	Ref               *provider.Reference
   168  	Owner             *user.UserId
   169  	Timestamp         *types.Timestamp
   170  	ImpersonatingUser *user.User
   171  }
   172  
   173  // Unmarshal to fulfill umarshaller interface
   174  func (ItemPurged) Unmarshal(v []byte) (interface{}, error) {
   175  	e := ItemPurged{}
   176  	err := json.Unmarshal(v, &e)
   177  	return e, err
   178  }
   179  
   180  // ItemRestored is emitted when a file or folder is restored from trashbin
   181  type ItemRestored struct {
   182  	SpaceOwner        *user.UserId
   183  	Executant         *user.UserId
   184  	ID                *provider.ResourceId
   185  	Ref               *provider.Reference
   186  	Owner             *user.UserId
   187  	OldReference      *provider.Reference
   188  	Key               string
   189  	Timestamp         *types.Timestamp
   190  	ImpersonatingUser *user.User
   191  }
   192  
   193  // Unmarshal to fulfill umarshaller interface
   194  func (ItemRestored) Unmarshal(v []byte) (interface{}, error) {
   195  	e := ItemRestored{}
   196  	err := json.Unmarshal(v, &e)
   197  	return e, err
   198  }
   199  
   200  // FileVersionRestored is emitted when a file version is restored
   201  type FileVersionRestored struct {
   202  	SpaceOwner        *user.UserId
   203  	Executant         *user.UserId
   204  	Ref               *provider.Reference
   205  	Owner             *user.UserId
   206  	Key               string
   207  	Timestamp         *types.Timestamp
   208  	ImpersonatingUser *user.User
   209  }
   210  
   211  // Unmarshal to fulfill umarshaller interface
   212  func (FileVersionRestored) Unmarshal(v []byte) (interface{}, error) {
   213  	e := FileVersionRestored{}
   214  	err := json.Unmarshal(v, &e)
   215  	return e, err
   216  }