func newDirCaptchas() dirCaptchas {
r := dirCaptchas{}
r.methods = map[string]func(he.Request) he.Response{
"POST": func(req he.Request) he.Response {
db := req.Things["db"].(*periwinkle.Tx)
return rfc7231.StatusCreated(r, backend.NewCaptcha(db).ID, req)
},
}
return r
}
func (usr *userSubscriptions) Methods() map[string]func(he.Request) he.Response {
return map[string]func(he.Request) he.Response{
"GET": func(req he.Request) he.Response {
db := req.Things["db"].(*periwinkle.Tx)
usr.groupID = req.URL.Query().Get("group_id")
usr.values = usr.backend().GetFrontEndSubscriptions(db)
return rfc7231.StatusOK(usr)
},
"POST": func(req he.Request) he.Response {
db := req.Things["db"].(*periwinkle.Tx)
sess := req.Things["session"].(*backend.Session)
type postfmt struct {
GroupID string `json:"group_id"`
Medium string `json:"medium,omitempty"`
Address string `json:"address,omitempty"`
}
var entity postfmt
httperr := safeDecodeJSON(req.Entity, &entity)
if httperr != nil {
return *httperr
}
entity.GroupID = strings.ToLower(entity.GroupID)
var address *backend.UserAddress
if entity.Medium == "" && entity.Address == "" {
address = &usr.Addresses[0]
for _, addr := range usr.Addresses {
if addr.SortOrder < address.SortOrder {
address = &addr
}
}
} else {
for _, addr := range usr.Addresses {
if addr.Medium == entity.Medium && addr.Address == entity.Address {
address = &addr
break
}
}
}
if address == nil {
return rfc7231.StatusConflict(he.NetPrintf("You don't have that address"))
}
backend.NewSubscription(db, address.ID, entity.GroupID, sess != nil && sess.UserID == usr.ID)
return rfc7231.StatusCreated(usr, entity.GroupID+":"+address.Medium+":"+address.Address, req)
},
}
}
func newDirUsers() dirUsers {
r := dirUsers{}
r.methods = map[string]func(he.Request) he.Response{
"POST": func(req he.Request) he.Response {
db := req.Things["db"].(*periwinkle.Tx)
type postfmt struct {
Username string `json:"username"`
Email string `json:"email"`
Password string `json:"password"`
PasswordVerification string `json:"password_verification,omitempty"`
}
var entity postfmt
httperr := safeDecodeJSON(req.Entity, &entity)
if httperr != nil {
return *httperr
}
if entity.Username == "" || entity.Email == "" || entity.Password == "" {
return rfc7231.StatusUnsupportedMediaType(he.NetPrintf("username, email, and password can't be emtpy"))
}
if entity.PasswordVerification != "" {
if entity.Password != entity.PasswordVerification {
// Passwords don't match
return rfc7231.StatusConflict(he.NetPrintf("password and password_verification don't match"))
}
}
usr := backend.NewUser(db, entity.Username, entity.Password, entity.Email)
backend.NewUserAddress(db, usr.ID, "noop", backend.RandomString(20), true)
backend.NewUserAddress(db, usr.ID, "admin", backend.RandomString(20), true)
req.Things["user"] = usr
return rfc7231.StatusCreated(r, usr.ID, req)
},
}
return r
}
func newDirGroups() dirGroups {
r := dirGroups{}
r.methods = map[string]func(he.Request) he.Response{
"GET": func(req he.Request) he.Response {
db := req.Things["db"].(*periwinkle.Tx)
sess := req.Things["session"].(*backend.Session)
var groups []backend.Group
type getfmt struct {
visibility string
}
var entity getfmt
httperr := safeDecodeJSON(req.Entity, &entity)
if httperr != nil {
entity.visibility = "subscribed"
}
if sess == nil {
groups = []backend.Group{}
} else if entity.visibility == "subscribed" {
groups = backend.GetGroupsByMember(db, *backend.GetUserByID(db, sess.UserID))
} else {
//groups = GetAllGroups(db)
groups = backend.GetPublicAndSubscribedGroups(db, *backend.GetUserByID(db, sess.UserID))
}
type EnumerateGroup struct {
Groupname string `json:"groupname"`
Post map[string]string `json:"post"`
Join map[string]string `json:"join"`
Read map[string]string `json:"read"`
Existence map[string]string `json:"existence"`
Subscriptions []backend.Subscription `json:"subscriptions"`
}
data := make([]EnumerateGroup, len(groups))
for i, grp := range groups {
var enum EnumerateGroup
enum.Groupname = grp.ID
exist := [...]int{grp.ExistencePublic, grp.ExistenceConfirmed}
enum.Existence = backend.ReadExist(exist)
read := [...]int{grp.ReadPublic, grp.ReadConfirmed}
enum.Read = backend.ReadExist(read)
post := [...]int{grp.PostPublic, grp.PostConfirmed, grp.PostMember}
enum.Post = backend.PostJoin(post)
join := [...]int{grp.JoinPublic, grp.JoinConfirmed, grp.JoinMember}
enum.Join = backend.PostJoin(join)
enum.Subscriptions = grp.Subscriptions
data[i] = enum
}
return rfc7231.StatusOK(he.NetJSON{Data: data})
},
"POST": func(req he.Request) he.Response {
db := req.Things["db"].(*periwinkle.Tx)
type Response1 struct {
Groupname string `json:"groupname"`
Post map[string]string `json:"post"`
Join map[string]string `json:"join"`
Read map[string]string `json:"read"`
Existence map[string]string `json:"existence"`
}
var entity Response1
httperr := safeDecodeJSON(req.Entity, &entity)
if httperr != nil {
return *httperr
}
if entity.Groupname == "" {
return rfc7231.StatusUnsupportedMediaType(he.NetPrintf("groupname can't be emtpy"))
}
grp := backend.NewGroup(
db,
entity.Groupname,
backend.Reverse(entity.Existence),
backend.Reverse(entity.Read),
backend.Reverse(entity.Post),
backend.Reverse(entity.Join),
)
sess := req.Things["session"].(*backend.Session)
address := backend.GetAddressesByUserAndMedium(db, sess.UserID, "noop")[0]
backend.NewSubscription(db, address.ID, grp.ID, true)
if grp == nil {
return rfc7231.StatusConflict(he.NetPrintf("a group with that name already exists"))
} else {
return rfc7231.StatusCreated(r, grp.ID, req)
}
},
}
return r
}