test
This commit is contained in:
+217
-35
@@ -37,37 +37,49 @@ type DynamicResource struct {
|
||||
WatchedDynamicResource []string `bson:"watched_dynamic_resource,omitempty" json:"watched_dynamic_resource,omitempty"`
|
||||
}
|
||||
|
||||
// WorkspaceCandidatesProvider can be set by the workspace package to supply
|
||||
// contextual workspace resources for a given DataType and request without
|
||||
// creating a circular import (workspace → resources → workspace).
|
||||
// When set, SetAllowedInstances uses workspace-scoped resources instead of
|
||||
// the full catalog for requests that carry a username.
|
||||
var WorkspaceCandidatesProvider func(dt tools.DataType, request *tools.APIRequest) []ResourceInterface
|
||||
|
||||
func (d *DynamicResource) GetAccessor(request *tools.APIRequest) utils.Accessor {
|
||||
return nil
|
||||
}
|
||||
|
||||
func (d *DynamicResource) SetAllowedInstances(request *tools.APIRequest, instance_id ...string) []ResourceInstanceITF {
|
||||
if WorkspaceCandidatesProvider != nil {
|
||||
candidates := WorkspaceCandidatesProvider(d.Type, request)
|
||||
return d.SetAllowedInstancesFromSet(candidates, request, instance_id...)
|
||||
}
|
||||
d.Instances = []ResourceInstanceITF{}
|
||||
for k, v := range map[tools.DataType]ResourceInterface{
|
||||
tools.COMPUTE_RESOURCE: &ComputeResource{},
|
||||
tools.DATA_RESOURCE: &DataResource{},
|
||||
tools.STORAGE_RESOURCE: &StorageResource{},
|
||||
tools.PROCESSING_RESOURCE: &ProcessingResource{},
|
||||
tools.WORKFLOW_RESOURCE: &WorkflowResource{}} {
|
||||
if d.Type != k {
|
||||
d.sortAndResetInstances()
|
||||
return d.Instances
|
||||
}
|
||||
|
||||
// SetAllowedInstancesFromSet fills d.Instances from a pre-loaded workspace resource set
|
||||
// instead of querying the catalog. Filters are applied in-memory against the candidates.
|
||||
// Called by WorkspaceResourceSet.Fill so dynamic resources only see workspace-scoped resources.
|
||||
func (d *DynamicResource) SetAllowedInstancesFromSet(candidates []ResourceInterface, request *tools.APIRequest, instance_id ...string) []ResourceInstanceITF {
|
||||
d.Instances = []ResourceInstanceITF{}
|
||||
d.PeerIds = map[int]string{}
|
||||
d.ResourceIds = map[int]string{}
|
||||
for _, res := range candidates {
|
||||
if !d.matchesFilters(res) {
|
||||
continue
|
||||
}
|
||||
access := d.getResAccessor(k, request)
|
||||
m := map[string]interface{}{}
|
||||
b, _ := json.Marshal(d.Filters)
|
||||
json.Unmarshal(b, &m)
|
||||
a, _, _ := access.Search(dbs.FiltersFromFlatMap(m, v), "", false, 0, 100000)
|
||||
d.PeerIds = map[int]string{}
|
||||
d.ResourceIds = map[int]string{}
|
||||
for _, res := range a {
|
||||
for _, i := range res.(ResourceInterface).SetAllowedInstances(request, instance_id...) {
|
||||
d.PeerIds[len(d.Instances)] = res.GetCreatorID()
|
||||
d.ResourceIds[len(d.Instances)] = res.GetID()
|
||||
d.Instances = append(d.Instances, i)
|
||||
}
|
||||
for _, i := range res.SetAllowedInstances(request, instance_id...) {
|
||||
d.PeerIds[len(d.Instances)] = res.GetCreatorID()
|
||||
d.ResourceIds[len(d.Instances)] = res.GetID()
|
||||
d.Instances = append(d.Instances, i)
|
||||
}
|
||||
break
|
||||
}
|
||||
d.sortAndResetInstances()
|
||||
return d.Instances
|
||||
}
|
||||
|
||||
func (d *DynamicResource) sortAndResetInstances() {
|
||||
if d.SortRules != nil {
|
||||
sorted := make([]ResourceInstanceITF, len(d.Instances))
|
||||
copy(sorted, d.Instances)
|
||||
@@ -77,27 +89,197 @@ func (d *DynamicResource) SetAllowedInstances(request *tools.APIRequest, instanc
|
||||
})
|
||||
d.Instances = sorted
|
||||
}
|
||||
|
||||
d.WatchedDynamicResource = []string{}
|
||||
return d.Instances
|
||||
}
|
||||
|
||||
func (d *DynamicResource) getResAccessor(dt tools.DataType, request *tools.APIRequest) utils.Accessor {
|
||||
switch dt {
|
||||
case tools.COMPUTE_RESOURCE:
|
||||
return NewAccessor[*ComputeResource](dt, request)
|
||||
case tools.PROCESSING_RESOURCE:
|
||||
return NewAccessor[*ProcessingResource](dt, request)
|
||||
case tools.DATA_RESOURCE:
|
||||
return NewAccessor[*DataResource](dt, request)
|
||||
case tools.STORAGE_RESOURCE:
|
||||
return NewAccessor[*ServiceResource](dt, request)
|
||||
case tools.WORKFLOW_RESOURCE:
|
||||
return NewAccessor[*WorkflowResource](dt, request)
|
||||
// matchesFilters applies d.Filters in-memory against a serialized resource.
|
||||
// Keys in d.Filters are JSON tag names; Serialize returns JSON tag names — no bson conversion needed.
|
||||
func (d *DynamicResource) matchesFilters(res ResourceInterface) bool {
|
||||
if len(d.Filters.And) == 0 && len(d.Filters.Or) == 0 {
|
||||
return true
|
||||
}
|
||||
m := res.Serialize(res)
|
||||
for field, fs := range d.Filters.And {
|
||||
vals := nestedVals(m, strings.Split(field, "."))
|
||||
for _, f := range fs {
|
||||
if !anyMatchesOp(vals, f) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
}
|
||||
if len(d.Filters.Or) > 0 {
|
||||
matched := false
|
||||
for field, fs := range d.Filters.Or {
|
||||
vals := nestedVals(m, strings.Split(field, "."))
|
||||
for _, f := range fs {
|
||||
if anyMatchesOp(vals, f) {
|
||||
matched = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if matched {
|
||||
break
|
||||
}
|
||||
}
|
||||
if !matched {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// nestedVals navigates a dot-path into m and collects all leaf values.
|
||||
// Arrays at any level are expanded: each element is recursed into.
|
||||
func nestedVals(m map[string]interface{}, path []string) []interface{} {
|
||||
if len(path) == 0 || m == nil {
|
||||
return nil
|
||||
}
|
||||
val, ok := m[path[0]]
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
if len(path) == 1 {
|
||||
if arr, ok := val.([]interface{}); ok {
|
||||
return arr
|
||||
}
|
||||
return []interface{}{val}
|
||||
}
|
||||
rest := path[1:]
|
||||
switch v := val.(type) {
|
||||
case map[string]interface{}:
|
||||
return nestedVals(v, rest)
|
||||
case []interface{}:
|
||||
var out []interface{}
|
||||
for _, elem := range v {
|
||||
if em, ok := elem.(map[string]interface{}); ok {
|
||||
out = append(out, nestedVals(em, rest)...)
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// anyMatchesOp returns true if at least one value in vals satisfies filter f.
|
||||
func anyMatchesOp(vals []interface{}, f dbs.Filter) bool {
|
||||
if f.Operator == dbs.EXISTS.String() {
|
||||
exists := len(vals) > 0 && vals[0] != nil
|
||||
want := true
|
||||
if b, ok := f.Value.(bool); ok {
|
||||
want = b
|
||||
}
|
||||
return exists == want
|
||||
}
|
||||
if f.Operator == dbs.IN.String() {
|
||||
list, ok := f.Value.([]interface{})
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
for _, v := range vals {
|
||||
sv := fmt.Sprintf("%v", v)
|
||||
for _, item := range list {
|
||||
if sv == fmt.Sprintf("%v", item) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
for _, v := range vals {
|
||||
if opMatches(v, f) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func opMatches(val interface{}, f dbs.Filter) bool {
|
||||
switch f.Operator {
|
||||
case dbs.EQUAL.String():
|
||||
return fmt.Sprintf("%v", val) == fmt.Sprintf("%v", f.Value)
|
||||
case dbs.NOT.String():
|
||||
return fmt.Sprintf("%v", val) != fmt.Sprintf("%v", f.Value)
|
||||
case dbs.LIKE.String():
|
||||
return strings.Contains(strings.ToLower(fmt.Sprintf("%v", val)), strings.ToLower(fmt.Sprintf("%v", f.Value)))
|
||||
case dbs.GT.String(), dbs.GTE.String(), dbs.LT.String(), dbs.LTE.String():
|
||||
return numericCmp(val, f.Value, f.Operator)
|
||||
case dbs.ELEMMATCH.String():
|
||||
arr, ok := val.([]interface{})
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
sub, ok := f.Value.(map[string]interface{})
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
for _, elem := range arr {
|
||||
em, ok := elem.(map[string]interface{})
|
||||
if !ok {
|
||||
continue
|
||||
}
|
||||
allOk := true
|
||||
for k, sv := range sub {
|
||||
if fmt.Sprintf("%v", em[k]) != fmt.Sprintf("%v", sv) {
|
||||
allOk = false
|
||||
break
|
||||
}
|
||||
}
|
||||
if allOk {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func numericCmp(a, b interface{}, op string) bool {
|
||||
fa, aOk := toFloat64(a)
|
||||
fb, bOk := toFloat64(b)
|
||||
if !aOk || !bOk {
|
||||
sa, sb := fmt.Sprintf("%v", a), fmt.Sprintf("%v", b)
|
||||
switch op {
|
||||
case dbs.GT.String():
|
||||
return sa > sb
|
||||
case dbs.GTE.String():
|
||||
return sa >= sb
|
||||
case dbs.LT.String():
|
||||
return sa < sb
|
||||
case dbs.LTE.String():
|
||||
return sa <= sb
|
||||
}
|
||||
return false
|
||||
}
|
||||
switch op {
|
||||
case dbs.GT.String():
|
||||
return fa > fb
|
||||
case dbs.GTE.String():
|
||||
return fa >= fb
|
||||
case dbs.LT.String():
|
||||
return fa < fb
|
||||
case dbs.LTE.String():
|
||||
return fa <= fb
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func toFloat64(v interface{}) (float64, bool) {
|
||||
switch n := v.(type) {
|
||||
case float64:
|
||||
return n, true
|
||||
case float32:
|
||||
return float64(n), true
|
||||
case int:
|
||||
return float64(n), true
|
||||
case int32:
|
||||
return float64(n), true
|
||||
case int64:
|
||||
return float64(n), true
|
||||
}
|
||||
return 0, false
|
||||
}
|
||||
|
||||
|
||||
func (d *DynamicResource) AddInstances(instance ResourceInstanceITF) {
|
||||
d.Instances = append(d.Instances, instance)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user