// Return an existing device client given a deviceId
func NewDeviceClient(c *api.Client, deviceId string) (*DeviceClient, error) {
body, _, err := c.GetDeviceMetadata(deviceId)
if err != nil {
return nil, err
}
device := Device{}
err = json.Unmarshal(body, &device)
return &DeviceClient{c, device}, err
}
// Retrieve a list of SharedFolder member descriptors
// TODO : Should an Etag be return for each one?
func ListSharedFolders(c *api.Client, sid string, etags []string) ([]SharedFolder, error) {
body, _, err := c.ListSharedFolders(sid, etags)
if err != nil {
return nil, err
}
sfs := []SharedFolder{}
err = json.Unmarshal(body, &sfs)
if err != nil {
return nil, errors.New("Unable to demarshal the list of retrieved SharedFolders")
}
return sfs, nil
}
// List all groups
func ListGroups(c *api.Client, offset, results int) (*[]Group, error) {
body, _, err := c.ListGroups(offset, results)
if err != nil {
return nil, err
}
groups := []Group{}
err = json.Unmarshal(body, &groups)
if err != nil {
return nil, errors.New("Unable to unmarshal list of groups")
}
return &groups, nil
}
// Return an existing SFMemberClient given its shared folder and user email
func GetSFMemberClient(c *api.Client, sid, email string, etags []string) (*SFMemberClient, error) {
body, header, err := c.GetSFMember(sid, email, etags)
if err != nil {
return nil, err
}
sfmClient := SFMemberClient{APIClient: c, Etag: header.Get("ETag"), Desc: SFMember{Sid: sid, Email: email}}
err = json.Unmarshal(body, &sfmClient.Desc)
if err != nil {
return nil, errors.New("Unable to unmarshal retrieved SFMember")
}
return &sfmClient, nil
}
// Retrieve a list of existing Device descriptors
func ListDevices(c *api.Client, email string) ([]Device, error) {
body, _, err := c.ListDevices(email)
if err != nil {
return nil, err
}
devices := []Device{}
err = json.Unmarshal(body, &devices)
if err != nil {
return nil, errors.New("Unable to demarshal list of devices")
}
return devices, err
}
// Retrieve an existing shared folder
func GetSharedFolderClient(c *api.Client, sid string, etags []string) (*SharedFolderClient, error) {
body, header, err := c.ListSharedFolderMetadata(sid, etags)
if err != nil {
return nil, err
}
sfClient := SharedFolderClient{APIClient: c}
err = json.Unmarshal(body, &sfClient.Desc)
if err != nil {
return nil, errors.New("Unable to unmarshal retrieved Shared Folder")
}
sfClient.Etag = header.Get("ETag")
return &sfClient, nil
}
// Get a list of existing user descriptors
func ListUsers(client *api.Client, limit int) (*[]User, error) {
body, _, err := client.ListUsers(limit, nil, nil)
if err != nil {
return nil, err
}
userResp := userListResponse{}
err = json.Unmarshal(body, &userResp)
if err != nil {
return nil, errors.New("Unable to unmarshal a retrieved list of users")
}
return &userResp.Users, nil
}
// Create a group
func CreateGroupClient(c *api.Client, groupName string) (*GroupClient, error) {
body, _, err := c.CreateGroup(groupName)
if err != nil {
return nil, err
}
g := GroupClient{APIClient: c}
err = json.Unmarshal(body, &g.Desc)
if err != nil {
return nil, errors.New("Unable to unmarshal created group")
}
return &g, nil
}
// Retrieve an existing group
func NewGroupClient(c *api.Client, groupId string) (*GroupClient, error) {
body, _, err := c.GetGroup(groupId)
if err != nil {
return nil, err
}
g := GroupClient{APIClient: c}
err = json.Unmarshal(body, &g.Desc)
if err != nil {
return nil, errors.New("Unable to unmarshal existing group")
}
return &g, nil
}
// Create a new shared folder and return a client associated with it
func CreateSharedFolderClient(c *api.Client, name string) (*SharedFolderClient, error) {
body, _, err := c.CreateSharedFolder(name)
if err != nil {
return nil, err
}
sfClient := SharedFolderClient{APIClient: c}
err = json.Unmarshal(body, &sfClient.Desc)
if err != nil {
return nil, errors.New("Unable to unmarshal retrieved SharedFolder")
}
return &sfClient, nil
}
// Create a new user and return a UserClient tied to the APIClient argument
func CreateUserClient(client *api.Client, email, firstName, lastName string) (*UserClient, error) {
body, _, err := client.CreateUser(email, firstName, lastName)
if err != nil {
return nil, err
}
u := User{}
err = json.Unmarshal(body, &u)
if err != nil {
return nil, errors.New("Unable to unmarshal new User")
}
return &UserClient{client, u}, nil
}
// Retrieve a list of SharedFolder member descriptors
// TOD : Should an Etag be return for each one?
func ListSFMember(c *api.Client, sid string, etags []string) ([]SFMember, error) {
body, _, err := c.ListSFMembers(sid, etags)
if err != nil {
return nil, err
}
sfmembers := []SFMember{}
err = json.Unmarshal(body, &sfmembers)
if err != nil {
return nil, errors.New("Unable to demarshal the list of retrieved SharedFolder members")
}
for _, v := range sfmembers {
v.Sid = sid
}
return sfmembers, nil
}
// Construct a FileClient given a file identifier and APIClient
func NewFileClient(c *api.Client, fileId string, fields []string) (*FileClient, error) {
body, header, err := c.GetFileMetadata(fileId, fields)
if err != nil {
return nil, err
}
f := FileClient{APIClient: c, OnDemand: fields}
err = json.Unmarshal(body, &f.Desc)
if err != nil {
return nil, errors.New("Unable to unmarshal existing File")
}
f.Desc.Etag = header.Get("ETag")
return &f, nil
}
// Given an existing user's email, return a client for said user
func GetUserClient(client *api.Client, email string) (*UserClient, error) {
body, _, err := client.GetUser(email)
if err != nil {
return nil, err
}
u := UserClient{APIClient: client}
err = json.Unmarshal(body, &u.Desc)
if err != nil {
fmt.Println(err)
return nil, errors.New("Unable to unmarshal new User")
}
return &u, nil
}
