2 ==================================================================================
3 Copyright (c) 2021 Samsung
5 Licensed under the Apache License, Version 2.0 (the "License");
6 you may not use this file except in compliance with the License.
7 You may obtain a copy of the License at
9 http://www.apache.org/licenses/LICENSE-2.0
11 Unless required by applicable law or agreed to in writing, software
12 distributed under the License is distributed on an "AS IS" BASIS,
13 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 See the License for the specific language governing permissions and
15 limitations under the License.
17 This source code is part of the near-RT RIC (RAN Intelligent Controller)
18 platform project (RICP).
19 ==================================================================================
31 "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/a1"
32 "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/models"
33 "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/policy"
34 "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/restapi/operations/a1_mediator"
35 "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/rmr"
36 "gerrit.o-ran-sc.org/r/ric-plt/sdlgo"
37 "github.com/santhosh-tekuri/jsonschema/v5"
42 a1PolicyPrefix = "a1.policy_type."
43 a1MediatorNs = "A1m_ns"
44 a1InstancePrefix = "a1.policy_instance."
45 a1InstanceMetadataPrefix = "a1.policy_inst_metadata."
46 a1HandlerPrefix = "a1.policy_handler."
47 a1PolicyRequest = 20010
48 a1EIDataDelivery = 20017
51 var typeAlreadyError = errors.New("Policy Type already exists")
52 var InstanceAlreadyError = errors.New("Policy Instance already exists")
53 var typeMismatchError = errors.New("Policytype Mismatch")
54 var invalidJsonSchema = errors.New("Invalid Json ")
55 var policyInstanceNotFoundError = errors.New("Policy Instance Not Found")
56 var policyTypeNotFoundError = errors.New("Policy Type Not Found")
57 var policyTypeCanNotBeDeletedError = errors.New("tried to delete a type that isn't empty")
58 var policyInstanceCanNotBeDeletedError = errors.New("tried to delete a Instance that isn't empty")
60 func (rh *Resthook) CanPolicyInstanceBeDeleted(err error) bool {
61 return err == policyInstanceCanNotBeDeletedError
64 func (rh *Resthook) CanPolicyTypeBeDeleted(err error) bool {
65 return err == policyTypeCanNotBeDeletedError
68 func (rh *Resthook) IsPolicyTypePresent(err error) bool {
69 return err == policyTypeNotFoundError
72 func (rh *Resthook) IsPolicyInstanceNotFound(err error) bool {
73 return err == policyInstanceNotFoundError
76 func (rh *Resthook) IsTypeAlready(err error) bool {
77 return err == typeAlreadyError
79 func (rh *Resthook) IsInstanceAlready(err error) bool {
80 return err == InstanceAlreadyError
82 func (rh *Resthook) IsTypeMismatch(err error) bool {
83 return err == typeMismatchError
86 func (rh *Resthook) IsValidJson(err error) bool {
87 return err == invalidJsonSchema
89 func NewResthook() *Resthook {
90 sdl := sdlgo.NewSyncStorage()
91 policyManager := policy.NewPolicyManager(sdl)
92 return createResthook(sdl, rmr.NewRMRSender(policyManager))
95 func createResthook(sdlInst iSdl, rmrSenderInst rmr.IRmrSender) *Resthook {
98 iRmrSenderInst: rmrSenderInst,
104 func (rh *Resthook) GetA1Health() bool {
105 data, _ := rh.db.GetAll(a1MediatorNs)
107 a1.Logger.Debug("Database connected and A1 is healthy")
113 func (rh *Resthook) GetAllPolicyType() []models.PolicyTypeID {
115 var policyTypeIDs []models.PolicyTypeID
117 keys, err := rh.db.GetAll("A1m_ns")
120 a1.Logger.Error("error in retrieving policy. err: %v", err)
123 a1.Logger.Debug("keys : %+v", keys)
125 for _, key := range keys {
126 if strings.HasPrefix(strings.TrimLeft(key, " "), a1PolicyPrefix) {
127 pti := strings.Split(strings.Trim(key, " "), a1PolicyPrefix)[1]
128 ptii, _ := strconv.ParseInt(pti, 10, 64)
129 policyTypeIDs = append(policyTypeIDs, models.PolicyTypeID(ptii))
133 a1.Logger.Debug("return : %+v", policyTypeIDs)
137 func (rh *Resthook) GetPolicyType(policyTypeId models.PolicyTypeID) *models.PolicyTypeSchema {
138 a1.Logger.Debug("GetPolicyType1")
140 var policytypeschema *models.PolicyTypeSchema
143 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
146 a1.Logger.Debug("key : %+v", key)
148 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
150 a1.Logger.Debug("policytype map : %+v", valmap)
152 if len(valmap) == 0 {
153 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
154 return policytypeschema
158 a1.Logger.Error("error in retrieving policy type. err: %v", err)
162 if valmap[key] == nil {
163 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
164 return policytypeschema
167 a1.Logger.Debug("keysmap : %+v", valmap[key])
169 var item models.PolicyTypeSchema
170 valStr := fmt.Sprint(valmap[key])
172 a1.Logger.Debug("Policy type for %+v : %+v", key, valStr)
173 valkey := "`" + valStr + "`"
174 valToUnmarshall, err := strconv.Unquote(valkey)
176 a1.Logger.Error("unquote error : %+v", err)
180 a1.Logger.Debug("Policy type for %+v : %+v", key, string(valToUnmarshall))
182 errunm := json.Unmarshal([]byte(valToUnmarshall), &item)
184 a1.Logger.Debug(" Unmarshalled json : %+v", (errunm))
185 a1.Logger.Debug("Policy type Name : %v", (item.Name))
190 func (rh *Resthook) CreatePolicyType(policyTypeId models.PolicyTypeID, httprequest models.PolicyTypeSchema) error {
191 a1.Logger.Debug("CreatePolicyType function")
192 if policyTypeId != models.PolicyTypeID(*httprequest.PolicyTypeID) {
194 a1.Logger.Debug("Policytype Mismatch")
195 return typeMismatchError
197 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
198 a1.Logger.Debug("key %+v ", key)
199 if data, err := httprequest.MarshalBinary(); err == nil {
200 a1.Logger.Debug("Marshaled String : %+v", string(data))
201 success, err1 := rh.db.SetIfNotExists(a1MediatorNs, key, string(data))
202 a1.Logger.Info("success:%+v", success)
204 a1.Logger.Error("error :%+v", err1)
208 a1.Logger.Debug("Policy type %+v already exist", policyTypeId)
209 return typeAlreadyError
215 func toStringKeys(val interface{}) (interface{}, error) {
217 switch val := val.(type) {
218 case map[interface{}]interface{}:
219 m := make(map[string]interface{})
220 for k, v := range val {
223 return nil, errors.New("found non-string key")
225 m[k], err = toStringKeys(v)
232 var l = make([]interface{}, len(val))
233 for i, v := range val {
234 l[i], err = toStringKeys(v)
245 func validate(httpBodyString string, schemaString string) bool {
247 err := yaml.Unmarshal([]byte(httpBodyString), &m)
249 a1.Logger.Error("Unmarshal error : %+v", err)
251 m, err = toStringKeys(m)
253 a1.Logger.Error("Conversion to string error : %+v", err)
256 compiler := jsonschema.NewCompiler()
257 if err := compiler.AddResource("schema.json", strings.NewReader(schemaString)); err != nil {
258 a1.Logger.Error("string reader error : %+v", err)
261 schema, err := compiler.Compile("schema.json")
263 a1.Logger.Error("schema json compile error : %+v", err)
266 if err := schema.Validate(m); err != nil {
267 a1.Logger.Error("schema validation error : %+v", err)
270 a1.Logger.Debug("validation successfull")
274 func (rh *Resthook) storePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, httpBody interface{}) (string, error) {
276 operation := "CREATE"
277 typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
280 a1.Logger.Debug("key1 : %+v", typekey)
282 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
284 a1.Logger.Error("policy type error : %+v", err)
286 a1.Logger.Debug("policytype map : %+v", valmap)
287 if valmap[typekey] == nil {
288 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
289 return operation, policyTypeNotFoundError
291 // TODO : rmr creation_timestamp := time.Now() // will be needed for rmr to notify the creation of instance
293 instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
295 instanceMap, err := rh.db.Get(a1MediatorNs, keys[:])
297 a1.Logger.Error("policy type error : %v", err)
299 a1.Logger.Debug("policyinstancetype map : %+v", instanceMap)
301 if instanceMap[instancekey] != nil {
303 a1.Logger.Debug("UPDATE")
304 data, _ := json.Marshal(httpBody)
305 a1.Logger.Debug("Marshaled String : %+v", string(data))
306 a1.Logger.Debug("key : %+v", instancekey)
307 success, err1 := rh.db.SetIf(a1MediatorNs, instancekey, instanceMap[instancekey], string(data))
309 a1.Logger.Error("error2 :%+v", err1)
310 return operation, err1
313 a1.Logger.Debug("Policy instance %+v already exist", policyInstanceID)
314 return operation, InstanceAlreadyError
317 data, _ := json.Marshal(httpBody)
318 a1.Logger.Debug("Marshaled String : %+v", string(data))
319 a1.Logger.Debug("key : %+v", instancekey)
321 var instance_map []interface{}
322 instance_map = append(instance_map, instancekey, string(data))
323 a1.Logger.Debug("policyinstancetype map : %+v", instance_map[1])
324 a1.Logger.Debug("policyinstancetype to create : %+v", instance_map)
326 err1 := rh.db.Set(a1MediatorNs, instancekey, string(data))
328 a1.Logger.Error("error1 :%+v", err1)
329 return operation, err1
332 a1.Logger.Debug("Policy Instance created ")
333 return operation, nil
336 func (rh *Resthook) storePolicyInstanceMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (bool, error) {
338 creation_timestamp := time.Now()
339 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
341 a1.Logger.Debug("key : %+v", instanceMetadataKey)
343 var metadatajson []interface{}
344 metadatajson = append(metadatajson, map[string]string{"created_at": creation_timestamp.Format("2006-01-02 15:04:05"), "has_been_deleted": "False"})
345 metadata, _ := json.Marshal(metadatajson)
347 a1.Logger.Debug("policyinstanceMetaData to create : %+v", string(metadata))
349 err := rh.db.Set(a1MediatorNs, instanceMetadataKey, string(metadata))
352 a1.Logger.Error("error :%+v", err)
356 a1.Logger.Debug("Policy Instance Meta Data created at :%+v", creation_timestamp)
361 func (rh *Resthook) CreatePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, httpBody interface{}) error {
362 a1.Logger.Debug("CreatePolicyInstance function")
363 // validate the PUT against the schema
364 var policyTypeSchema *models.PolicyTypeSchema
365 policyTypeSchema = rh.GetPolicyType(policyTypeId)
366 schemaStr, err := json.Marshal(policyTypeSchema.CreateSchema)
368 a1.Logger.Error("Json Marshal error : %+v", err)
371 a1.Logger.Debug("schema to validate %+v", string(schemaStr))
372 a1.Logger.Debug("httpbody to validate %+v", httpBody)
373 schemaString := fmt.Sprint(string(schemaStr))
374 httpBodyMarshal, err := json.Marshal(httpBody)
375 httpBodyString := string((httpBodyMarshal))
376 a1.Logger.Debug("schema to validate sprint %+v", (schemaString))
377 a1.Logger.Debug("httpbody to validate sprint %+v", httpBodyString)
378 isvalid := validate(httpBodyString, schemaString)
381 operation, err = rh.storePolicyInstance(policyTypeId, policyInstanceID, httpBody)
383 a1.Logger.Error("error :%+v", err)
386 a1.Logger.Debug("policy instance :%+v", operation)
387 iscreated, errmetadata := rh.storePolicyInstanceMetadata(policyTypeId, policyInstanceID)
388 if errmetadata != nil {
389 a1.Logger.Error("error :%+v", errmetadata)
393 a1.Logger.Debug("policy instance metadata created")
396 message := rmr.Message{}
397 rmrMessage, err = message.PolicyMessage(strconv.FormatInt((int64(policyTypeId)), 10), string(policyInstanceID), httpBodyString, operation)
399 a1.Logger.Error("error : %v", err)
402 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1PolicyRequest)
404 a1.Logger.Debug("rmrSendToXapp : message sent")
406 a1.Logger.Debug("rmrSendToXapp : message not sent")
410 a1.Logger.Error("%+v", invalidJsonSchema)
411 return invalidJsonSchema
417 func (rh *Resthook) GetPolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (interface{}, error) {
418 a1.Logger.Debug("GetPolicyInstance1")
422 typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
425 a1.Logger.Debug("key1 : %+v", typekey)
427 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
428 if len(valmap) == 0 {
429 a1.Logger.Debug("policy type Not Present for policyid : %v", policyTypeId)
430 return "{}", policyTypeNotFoundError
434 a1.Logger.Error("error in retrieving policy type. err: %v", err)
438 if valmap[typekey] == nil {
439 a1.Logger.Debug("policy type Not Present for policyid : %v", policyTypeId)
440 return "{}", policyTypeNotFoundError
443 a1.Logger.Debug("keysmap : %+v", valmap[typekey])
445 instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
446 a1.Logger.Debug("key2 : %+v", instancekey)
447 keys[0] = instancekey
448 instanceMap, err := rh.db.Get(a1MediatorNs, keys[:])
450 a1.Logger.Error("policy instance error : %v", err)
452 a1.Logger.Debug("policyinstancetype map : %+v", instanceMap)
454 if instanceMap[instancekey] == nil {
455 a1.Logger.Debug("policy instance Not Present for policyinstaneid : %v", policyInstanceID)
456 return "{}", policyInstanceNotFoundError
459 valStr := fmt.Sprint(instanceMap[instancekey])
463 func (rh *Resthook) GetAllPolicyInstance(policyTypeId models.PolicyTypeID) ([]models.PolicyInstanceID, error) {
464 a1.Logger.Debug("GetAllPolicyInstance")
465 var policyTypeInstances = []models.PolicyInstanceID{}
467 keys, err := rh.db.GetAll("A1m_ns")
470 a1.Logger.Error("error in retrieving policy. err: %v", err)
471 return policyTypeInstances, err
473 a1.Logger.Debug("keys : %+v", keys)
474 typekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "."
476 for _, key := range keys {
477 if strings.HasPrefix(strings.TrimLeft(key, " "), typekey) {
478 pti := strings.Split(strings.Trim(key, " "), typekey)[1]
479 a1.Logger.Debug("pti %+v", pti)
480 policyTypeInstances = append(policyTypeInstances, models.PolicyInstanceID(pti))
484 if len(policyTypeInstances) == 0 {
485 a1.Logger.Debug("policy instance Not Present ")
488 a1.Logger.Debug("return : %+v", policyTypeInstances)
489 return policyTypeInstances, nil
492 func (rh *Resthook) DeletePolicyType(policyTypeId models.PolicyTypeID) error {
493 a1.Logger.Debug("DeletePolicyType")
495 policyinstances, err := rh.GetAllPolicyInstance(policyTypeId)
497 a1.Logger.Error("error in retrieving policy. err: %v", err)
502 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
504 if len(policyinstances) == 0 {
505 err := rh.db.Remove(a1MediatorNs, keys[:])
507 a1.Logger.Error("error in deleting policy type err: %v", err)
511 a1.Logger.Error("tried to delete a type that isn't empty")
512 return policyTypeCanNotBeDeletedError
517 func (rh *Resthook) typeValidity(policyTypeId models.PolicyTypeID) error {
520 typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
523 a1.Logger.Debug("key1 : %+v", typekey)
524 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
526 a1.Logger.Error("error in retrieving policytype err: %v", err)
529 if len(valmap) == 0 {
530 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
531 return policyTypeNotFoundError
535 func (rh *Resthook) instanceValidity(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
536 err := rh.typeValidity(policyTypeId)
540 policyTypeInstances, err := rh.GetPolicyInstance(policyTypeId, policyInstanceID)
542 a1.Logger.Error("policy instance error : %v", err)
545 if len(policyTypeInstances.(string)) == 0 {
546 a1.Logger.Debug("policy instance Not Present ")
547 return policyInstanceNotFoundError
551 func (rh *Resthook) getMetaData(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (map[string]interface{}, error) {
552 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
553 a1.Logger.Debug("instanceMetadata key : %+v", instanceMetadataKey)
555 keys[0] = instanceMetadataKey
556 instanceMetadataMap, err := rh.db.Get(a1MediatorNs, keys[:])
558 a1.Logger.Error("policy instance error : %v", err)
560 a1.Logger.Debug("instanceMetadata map : %+v", instanceMetadataMap)
561 if instanceMetadataMap[instanceMetadataKey] == nil {
562 a1.Logger.Error("policy instance Not Present for policyinstaneid : %v", policyInstanceID)
563 return map[string]interface{}{}, policyInstanceNotFoundError
565 return instanceMetadataMap, nil
568 func (rh *Resthook) GetPolicyInstanceStatus(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (*a1_mediator.A1ControllerGetPolicyInstanceStatusOKBody, error) {
569 err := rh.instanceValidity(policyTypeId, policyInstanceID)
570 if err != nil && err == policyInstanceNotFoundError || err == policyTypeNotFoundError {
571 policyInstanceStatus.InstanceStatus = "NOT IN EFFECT"
572 return &policyInstanceStatus, err
574 policyInstanceStatus := a1_mediator.A1ControllerGetPolicyInstanceStatusOKBody{}
575 metadata, err := rh.getMetaData(policyTypeId, policyInstanceID)
576 a1.Logger.Debug(" metadata %v", metadata)
578 a1.Logger.Error("policy instance error : %v", err)
579 policyInstanceStatus.InstanceStatus = "NOT IN EFFECT"
580 return &policyInstanceStatus, err
582 jsonbody, err := json.Marshal(metadata)
584 a1.Logger.Error("marshal error : %v", err)
585 return &policyInstanceStatus, err
588 if err := json.Unmarshal(jsonbody, &policyInstanceStatus); err != nil {
589 a1.Logger.Error("unmarshal error : %v", err)
590 //this error maps to 503 error but can be mapped to 500: internal error
591 return &policyInstanceStatus, err
593 if policyInstanceStatus.HasBeenDeleted == false {
594 policyInstanceStatus.InstanceStatus = "IN EFFECT"
596 policyInstanceStatus.InstanceStatus = "NOT IN EFFECT"
598 return &policyInstanceStatus, nil
601 func (rh *Resthook) storeDeletedPolicyInstanceMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, creation_timestamp string) error {
602 deleted_timestamp := time.Now()
604 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
606 a1.Logger.Debug("instanceMetadata Key : %+v", instanceMetadataKey)
608 var metadatajson interface{}
609 metadatajson = map[string]string{"created_at": creation_timestamp, "has_been_deleted": "True", "deleted_at": deleted_timestamp.Format("2006-01-02 15:04:05")}
610 a1.Logger.Debug("metadatajson to create : %+v", metadatajson)
611 deletedmetadata, err := json.Marshal(metadatajson)
613 a1.Logger.Debug("policyinstanceMetaData to create : %+v", string(deletedmetadata))
615 err = rh.db.Set(a1MediatorNs, instanceMetadataKey, string(deletedmetadata))
616 a1.Logger.Debug("deletemetadatacreated")
618 a1.Logger.Error("error :%+v", err)
622 a1.Logger.Error("Policy Instance Meta Data deleted at :%+v", creation_timestamp)
627 func (rh *Resthook) deleteInstancedata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
629 instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
630 keys[0] = instancekey
631 err := rh.db.Remove(a1MediatorNs, keys[:])
633 a1.Logger.Error("error in deleting policy type err: %v", err)
639 func (rh *Resthook) deleteMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
641 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
643 a1.Logger.Debug("instanceMetadata Key : %+v", instanceMetadataKey)
644 keys[0] = instanceMetadataKey
645 err := rh.db.Remove(a1MediatorNs, keys[:])
647 a1.Logger.Error("error in deleting policy metadata err: %v", err)
653 func (rh *Resthook) DeletePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
654 err := rh.instanceValidity(policyTypeId, policyInstanceID)
656 a1.Logger.Error("policy instance error : %v", err)
657 if err == policyInstanceNotFoundError || err == policyTypeNotFoundError {
662 createdmetadata, err := rh.getMetaData(policyTypeId, policyInstanceID)
664 a1.Logger.Error("error : %v", err)
667 a1.Logger.Debug(" created metadata %v", createdmetadata)
668 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
669 creation_metadata := createdmetadata[instanceMetadataKey]
670 var metadata map[string]interface{}
671 if err = json.Unmarshal([]byte(creation_metadata.(string)), &metadata); err != nil {
672 a1.Logger.Error("unmarshal error : %v", err)
676 a1.Logger.Debug(" created metadata created_at %v", metadata["created_at"])
677 creation_timestamp := metadata["created_at"]
679 rh.deleteMetadata(policyTypeId, policyInstanceID)
681 rh.deleteInstancedata(policyTypeId, policyInstanceID)
683 rh.storeDeletedPolicyInstanceMetadata(policyTypeId, policyInstanceID, creation_timestamp.(string))
685 message := rmr.Message{}
686 rmrMessage, err = message.PolicyMessage(strconv.FormatInt((int64(policyTypeId)), 10), string(policyInstanceID), "", "DELETE")
688 a1.Logger.Error("error : %v", err)
691 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1PolicyRequest)
693 a1.Logger.Debug("rmrSendToXapp : message sent")
695 //TODO:if message not sent need to return error or just log it or retry sending
696 a1.Logger.Error("rmrSendToXapp : message not sent")
702 func (rh *Resthook) DataDelivery(httpBody interface{}) error {
703 a1.Logger.Debug("httpbody : %+v", httpBody)
704 mymap := httpBody.(map[string]interface{})
705 message := rmr.Message{}
706 rmrMessage, err := message.A1EIMessage(mymap["job"].(string), mymap["payload"].(string))
708 a1.Logger.Error("error : %v", err)
711 a1.Logger.Debug("rmrSendToXapp :rmrMessage %+v", rmrMessage)
712 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1EIDataDelivery)
714 a1.Logger.Debug("rmrSendToXapp : message sent")
716 a1.Logger.Error("rmrSendToXapp : message not sent")