244 lines
7.9 KiB
Go
244 lines
7.9 KiB
Go
package controllers
|
|
|
|
import (
|
|
oclib "cloud.o-forge.io/core/oc-lib"
|
|
"cloud.o-forge.io/core/oc-lib/dbs"
|
|
"cloud.o-forge.io/core/oc-lib/models/peer"
|
|
"cloud.o-forge.io/core/oc-lib/tools"
|
|
beego "github.com/beego/beego/v2/server/web"
|
|
)
|
|
|
|
// Operations about workflow
|
|
type PeerController struct {
|
|
beego.Controller
|
|
}
|
|
|
|
// @Title Search
|
|
// @Description search workspace
|
|
// @Param search path string true "the word search you want to get"
|
|
// @Param is_draft query string false
|
|
// @Success 200 {workspace} models.workspace
|
|
// @router /search/:search [get]
|
|
func (o *PeerController) Search() {
|
|
user, peerID, groups := oclib.ExtractTokenInfo(*o.Ctx.Request)
|
|
// store and return Id or post with UUIDLibDataEnum
|
|
search := o.Ctx.Input.Param(":search")
|
|
isDraft := o.Ctx.Input.Query("is_draft")
|
|
o.Data["json"] = oclib.NewRequest(oclib.LibDataEnum(oclib.PEER), user, peerID, groups, nil).Search(nil, search, isDraft == "true")
|
|
o.ServeJSON()
|
|
}
|
|
|
|
// @Title GetAll
|
|
// @Description find all peer
|
|
// @Param is_draft query string false
|
|
// @Success 200 {peer} models.peer
|
|
// @router / [get]
|
|
func (o *PeerController) GetAll() {
|
|
user, peerID, groups := oclib.ExtractTokenInfo(*o.Ctx.Request)
|
|
isDraft := o.Ctx.Input.Query("is_draft")
|
|
verify := o.Ctx.Input.Query("verify")
|
|
if verify == "true" {
|
|
o.Data["json"] = oclib.NewRequest(oclib.LibDataEnum(oclib.PEER), user, peerID, groups, nil).Search(&dbs.Filters{
|
|
And: map[string][]dbs.Filter{
|
|
"verify": {{Operator: dbs.EQUAL.String(), Value: true}},
|
|
},
|
|
}, "", false)
|
|
} else {
|
|
o.Data["json"] = oclib.NewRequest(oclib.LibDataEnum(oclib.PEER), user, peerID, groups, nil).LoadAll(isDraft == "true")
|
|
}
|
|
o.ServeJSON()
|
|
}
|
|
|
|
// @Title Get
|
|
// @Description find peer by peerid
|
|
// @Param id path string true "the peer id you want to get"
|
|
// @Success 200 {peer} models.peer
|
|
// @router /:id [get]
|
|
func (o *PeerController) Get() {
|
|
user, peerID, groups := oclib.ExtractTokenInfo(*o.Ctx.Request)
|
|
id := o.Ctx.Input.Param(":id")
|
|
o.Data["json"] = oclib.NewRequest(oclib.LibDataEnum(oclib.PEER), user, peerID, groups, nil).LoadOne(id)
|
|
o.ServeJSON()
|
|
}
|
|
|
|
// @Title Link
|
|
// @Description find peer by peerid
|
|
// @Param id path string true "the peer id you want to get"
|
|
// @Success 200 {peer} models.peer
|
|
// @router /:from/link/:relation [get]
|
|
func (o *PeerController) Link() {
|
|
_, peerID, _ := oclib.ExtractTokenInfo(*o.Ctx.Request)
|
|
id := o.Ctx.Input.Param(":from")
|
|
if ok, _ := oclib.IsMySelf(peerID); ok {
|
|
o.Data["json"] = map[string]interface{}{
|
|
"data": nil,
|
|
"code": 400,
|
|
"error": "can't link relation by ourself",
|
|
}
|
|
o.ServeJSON()
|
|
return
|
|
}
|
|
if ok, _ := oclib.IsMySelf(id); !ok {
|
|
o.Data["json"] = map[string]interface{}{
|
|
"data": nil,
|
|
"code": 400,
|
|
"error": "can't link relation to an other peer",
|
|
}
|
|
o.ServeJSON()
|
|
return
|
|
}
|
|
relation := o.Ctx.Input.Param(":relation") // as partner, blacklist, unknown
|
|
req := oclib.NewRequestAdmin(oclib.LibDataEnum(oclib.PEER), nil)
|
|
l := req.LoadOne(id)
|
|
if p := l.ToPeer(); p != nil {
|
|
if peer.GetRelationPath(relation) != -1 {
|
|
o.Data["json"] = req.UpdateOne(map[string]interface{}{
|
|
"relation": peer.GetRelationPath(relation),
|
|
"verify": !(p.Relation == peer.PENDING_PARTNER || relation == peer.NONE.Path()),
|
|
}, p.GetID())
|
|
return
|
|
}
|
|
o.Data["json"] = map[string]interface{}{
|
|
"data": nil,
|
|
"code": 400,
|
|
"error": "relation unavailable",
|
|
}
|
|
o.ServeJSON()
|
|
return
|
|
}
|
|
o.Data["json"] = map[string]interface{}{
|
|
"data": nil,
|
|
"code": 404,
|
|
"error": "peer not found",
|
|
}
|
|
o.ServeJSON()
|
|
}
|
|
|
|
// @Title unknown
|
|
// @Description add unknown peer by peerid
|
|
// @Param id path string true "the peer id you want to blacklist"
|
|
// @Success 200 {peer} models.peer
|
|
// @router /:id/unknown [post]
|
|
func (o *PeerController) Unknown() {
|
|
//user, peerID, groups := oclib.ExtractTokenInfo(*o.Ctx.Request)
|
|
id := o.Ctx.Input.Param(":id")
|
|
req := oclib.NewRequestAdmin(oclib.LibDataEnum(oclib.PEER), nil)
|
|
data := req.LoadOne(id)
|
|
o.changeRelation(data.ToPeer(), peer.NONE, req)
|
|
}
|
|
|
|
// @Title Partner
|
|
// @Description add partner peer by peerid
|
|
// @Param id path string true "the peer id you want to blacklist"
|
|
// @Success 200 {peer} models.peer
|
|
// @router /:id/partner [post]
|
|
func (o *PeerController) Partner() {
|
|
// user, peerID, groups := oclib.ExtractTokenInfo(*o.Ctx.Request)
|
|
id := o.Ctx.Input.Param(":id")
|
|
req := oclib.NewRequestAdmin(oclib.LibDataEnum(oclib.PEER), nil)
|
|
data := req.LoadOne(id)
|
|
o.changeRelation(data.ToPeer(), peer.PARTNER, req)
|
|
}
|
|
|
|
// @Title Blacklist
|
|
// @Description add blacklist peer by peerid
|
|
// @Param id path string true "the peer id you want to blacklist"
|
|
// @Success 200 {peer} models.peer
|
|
// @router /:id/blacklist [post]
|
|
func (o *PeerController) Blacklist() {
|
|
// user, peerID, groups := oclib.ExtractTokenInfo(*o.Ctx.Request)
|
|
id := o.Ctx.Input.Param(":id")
|
|
req := oclib.NewRequestAdmin(oclib.LibDataEnum(oclib.PEER), nil)
|
|
data := req.LoadOne(id)
|
|
o.changeRelation(data.ToPeer(), peer.BLACKLIST, req)
|
|
}
|
|
|
|
// used from : peer ask, or response, only from peer origin is authorized to change...
|
|
func (o *PeerController) changeRelation(dest *peer.Peer, relation peer.PeerRelation, request *oclib.Request) {
|
|
if ok, _ := oclib.IsMySelf(request.PeerID); !ok {
|
|
o.Data["json"] = map[string]interface{}{
|
|
"data": nil,
|
|
"code": 400,
|
|
"error": "can't change relation",
|
|
}
|
|
o.ServeJSON()
|
|
return
|
|
}
|
|
if ok, _ := oclib.IsMySelf(dest.GetID()); ok {
|
|
o.Data["json"] = map[string]interface{}{
|
|
"data": nil,
|
|
"code": 400,
|
|
"error": "can't change ourself",
|
|
}
|
|
o.ServeJSON()
|
|
return
|
|
}
|
|
// store and return Id or post with UUID
|
|
if dest != nil {
|
|
if !dest.Verify {
|
|
switch relation {
|
|
case peer.PARTNER:
|
|
relation = peer.PENDING_PARTNER
|
|
case peer.BLACKLIST:
|
|
relation = peer.NONE
|
|
}
|
|
if _, err := tools.NewHTTPCaller(map[tools.DataType]map[tools.METHOD]string{}).CallGet(
|
|
dest.Url, "/"+request.PeerID+"/link/"+relation.Path()); err != nil {
|
|
o.Data["json"] = map[string]interface{}{
|
|
"data": nil,
|
|
"code": 400,
|
|
"error": err.Error(),
|
|
}
|
|
o.ServeJSON()
|
|
}
|
|
}
|
|
if dest.Verify && relation == peer.PENDING_PARTNER {
|
|
relation = peer.PARTNER
|
|
}
|
|
data := request.UpdateOne(map[string]interface{}{
|
|
"relation": relation,
|
|
}, dest.GetID())
|
|
|
|
o.Data["json"] = data
|
|
o.ServeJSON()
|
|
return
|
|
}
|
|
o.Data["json"] = map[string]interface{}{
|
|
"data": nil,
|
|
"code": 400,
|
|
"error": "peer not found.",
|
|
}
|
|
o.ServeJSON()
|
|
}
|
|
|
|
// @Title DeleteState
|
|
// @Description delete state peer by peerid
|
|
// @Param id path string true "the peer id you want to delete state"
|
|
// @Success 200 {peer} models.peer
|
|
// @router /:id/undo_state [post]
|
|
func (o *PeerController) DeleteState() {
|
|
user, peerID, groups := oclib.ExtractTokenInfo(*o.Ctx.Request)
|
|
id := o.Ctx.Input.Param(":id")
|
|
o.Data["json"] = oclib.NewRequest(oclib.LibDataEnum(oclib.PEER), user, peerID, groups, nil).UpdateOne(map[string]interface{}{
|
|
"state": peer.NONE,
|
|
}, id)
|
|
o.ServeJSON()
|
|
}
|
|
|
|
/*
|
|
Un pair change le statut d'un autre pair, alors ce dernier est joins automatiquement, on ne peut pas s'auto lié seul un externe peut faire ce processus de demande.
|
|
On change le pair pour pouvoir le mettre à jour, alors, le lien se met à jour automatiquement. p1 -> update status -> link (p2) -> p2 response -> update status -> link (p1)
|
|
|
|
Que définit le partnership de type : Partner, Blacklist et None.
|
|
|
|
BlackList : implique qu'on ne peut pas "voir" un pair et ses ressources, d'un coté comme de l'autre. Il suffit qu'un pair définisse la Blacklist, le pair opposant ne peut plus le voir.
|
|
(DHT allons plus loin)
|
|
|
|
Partner : Donne accès à des ressources non publique duquel un partnership à été modélisé, de type * ou dédié.
|
|
|
|
None : Est visible, et ne donne accès qu'au ressources publique et aux profiles all. Les profiles dédiés ne s'appliquent que si on est dans une situation de partenariat.
|
|
|
|
|
|
Note: L'état PENDING revient à dire qu'une relation est à l'état None,... si il y a une vérification on considère tout status à None. C'est une vérification importante.
|
|
*/
|