Merge pull request #236 from rruckley/bug-events-235

Bug: Events

src/common/event.rs

@@ -3,7 +3,6 @@
 use serde::{Deserialize, Serialize};
 use crate::{
     HasId,
-    HasName,
     TMFEvent
 };
 
@@ -59,7 +58,7 @@ impl<T,U> Event<T,U> {
 /// Trait for types that can generate an event
 pub trait EventPayload<T> {
     /// Object the event pertains to
-    type Subject : HasId + HasName + TMFEvent<T>;
+    type Subject : HasId + TMFEvent<T>;
     /// Type of event generated
     type EventType;
     /// Convert the item into an event

src/lib.rs

@@ -354,7 +354,7 @@ pub trait HasRelatedParty : HasId {
 }
 
 /// Trait for generating an event
-pub trait TMFEvent<T> : HasId + HasName {
+pub trait TMFEvent<T> : HasId {
     /// Geneate container for an TMF payload to be used in an event
     fn event(&self) -> T;
 }

src/tmf620/catalog.rs

@@ -79,39 +79,6 @@ pub struct Catalog {
     r#type : Option<String>,
 }
 
-// impl HasRelatedParty for Catalog {
-//     fn add_party(&mut self, party : RelatedParty) {
-//         match self.related_party.as_mut() {
-//             Some(v) => v.push(party),
-//             None => self.related_party = Some(vec![party]),
-//         }    
-//     }
-//     fn get_by_role(&self, role : String) -> Option<Vec<&RelatedParty>> {
-//         match &self.related_party {
-//             Some(rp) => {
-//                 let out = rp.iter()
-//                     .filter(|p| p.role.is_some())
-//                     .filter(|p| p.role.clone().unwrap() == role)
-//                     .collect();
-//                 Some(out)
-//             },
-//             None => None,
-//         }    
-//     }
-//     fn get_party(&self, idx : usize ) -> Option<&RelatedParty> {
-//         match self.related_party.as_ref() {
-//             Some(rp) => {
-//                 // Simple return results of get()
-//                 rp.get(idx)
-//             },
-//             None => None,
-//         }    
-//     }
-//     fn remove_party(&mut self, idx : usize) -> Result<RelatedParty,String> {
-//         Ok(self.related_party.as_mut().unwrap().remove(idx))    
-//     }
-// }
-
 impl Catalog {
     /// Create a new instance of catalog struct
     pub fn new(name : impl Into<String>) -> Catalog {
@@ -160,9 +127,10 @@ impl EventPayload<CatalogEvent> for Catalog {
     fn to_event(&self,event_type : CatalogEventType) -> Event<CatalogEvent,CatalogEventType> {       
         let now = Utc::now();
         let event_time = chrono::DateTime::from_timestamp(now.timestamp(),0).unwrap();
+        let desc = format!("{:?} for {}",event_type,self.get_name());
         Event {
             correlation_id: None,
-            description: None,
+            description: Some(desc),
             domain: Some(Catalog::get_class()),
             event_id: Uuid::new_v4().to_string(),
             field_path: None,
@@ -190,14 +158,6 @@ pub enum CatalogEventType {
     CatalogBatchEvent,
 }
 
-// Notifications
-/// Catalog created Event
-pub struct CatalogCreateEvent {}
-/// Catalog Deteted Event
-pub struct CatalogDeleteEvent {}
-/// Catalog Batch Event
-pub struct CatalogBatchEvent {}
-
 #[cfg(test)]
 mod tests {
 

src/tmf620/category.rs

@@ -5,7 +5,9 @@ use crate::tmf620::product_offering::ProductOfferingRef;
 #[cfg(all(feature = "tmf620",feature = "build-V5"))]
 use crate::tmf620::product_offering_v5::ProductOfferingRef;
 
+use chrono::Utc;
 use serde::{Deserialize, Serialize};
+use uuid::Uuid;
 
 use super::MOD_PATH;
 use crate::{
@@ -17,8 +19,10 @@ use crate::{
     HasDescription,
     TimePeriod,
     LIB_PATH,
+    TMFEvent,
     Uri,
 };
+use crate::common::event::{Event,EventPayload};
 use tmflib_derive::{
     HasDescription,
     HasId,
@@ -151,6 +155,52 @@ impl Category {
     }
 }
 
+/// Container for the payload that generated the event
+#[derive(Clone,Debug,Default,Deserialize,Serialize)]
+pub struct CategoryEvent {
+    /// Impacted Category
+    pub category: Category,
+}
+
+impl TMFEvent<CategoryEvent> for Category {
+    fn event(&self) -> CategoryEvent {
+        CategoryEvent {
+            category: self.clone(),
+        }
+    }
+}
+
+impl EventPayload<CategoryEvent> for Category {
+    type Subject = Category;
+    type EventType = CategoryEventType;
+
+    fn to_event(&self,event_type : Self::EventType) -> Event<CategoryEvent,Self::EventType> {
+        let now = Utc::now();
+        let event_time = chrono::DateTime::from_timestamp(now.timestamp(),0).unwrap();
+        Event {
+            domain: Some(Category::get_class()),
+            event_id: Uuid::new_v4().to_string(),
+            href: self.href.clone(),
+            id: self.id.clone(),
+            title: self.name.clone(),
+            event_time: event_time.to_string(),
+            event_type,
+            event: self.event(),
+            ..Event::default()
+        }        
+    }
+}
+
+/// Category Event Type
+#[derive(Clone,Default,Debug)]
+pub enum CategoryEventType {
+    /// Category Created
+    #[default]
+    CategoryCreateEvent,
+    /// Category Deleted
+    CategoryDeleteEvent,
+}
+
 #[cfg(test)]
 mod tests {
     use super::Category;

src/tmf620/product_offering.rs

@@ -21,16 +21,19 @@ use crate::{
     TimePeriod, 
     DateTime,
     Uri,
+    TMFEvent,
     vec_insert,
     LIB_PATH,
 };
 
 use super::product_offering_price::ProductOfferingPriceRef;
+use chrono::Utc;
 use serde::{Deserialize, Serialize};
+use uuid::Uuid;
 
 use super::{ChannelRef,MarketSegmentRef,PlaceRef,SLARef};
 use crate::tmf651::agreement::AgreementRef;
-
+use crate::common::event::{Event,EventPayload};
 use tmflib_derive::{
     HasId,
     HasDescription,
@@ -269,6 +272,57 @@ impl ProductOffering {
     }
 }
 
+// Events
+/// Product Specification Event Container
+#[derive(Clone,Debug,Default,Deserialize,Serialize)]
+pub struct ProductOfferingEvent {
+    product_specification: ProductOffering,
+}
+
+impl TMFEvent<ProductOfferingEvent> for ProductOffering {
+    fn event(&self) -> ProductOfferingEvent {
+        ProductOfferingEvent {
+            product_specification: self.clone(),
+        }
+    }
+}
+
+impl EventPayload<ProductOfferingEvent> for ProductOffering {
+    type Subject = ProductOffering;
+    type EventType = ProductOfferingEvent;
+    fn to_event(&self,event_type : Self::EventType) -> Event<ProductOfferingEvent,Self::EventType> {
+        let now = Utc::now();
+        let event_time = chrono::DateTime::from_timestamp(now.timestamp(),0).unwrap();
+        let desc = format!("{:?} for {}",event_type,self.get_name());
+        Event {
+            description: Some(desc),
+            domain: Some(ProductOffering::get_class()),
+            event_id: Uuid::new_v4().to_string(),
+            href: self.href.clone(),
+            id: self.id.clone(),
+            title: self.name.clone(),
+            event_time: event_time.to_string(),
+            event_type,
+            event: self.event(),
+            ..Event::default()
+        }    
+    }
+}
+
+/// Product Offering Event Type
+#[derive(Clone,Default,Debug)]
+pub enum ProductOfferingEventType {
+    /// Product Offering Created
+    #[default]
+    ProductOfferingCreateEvent,
+    /// Product Offering Attributed Changed
+    ProductOfferingAttributeValueChangeEvent,
+    /// Product Offering Status Changed
+    ProductOfferingStateChangeEvent,
+    /// Product Offering Deleted
+    ProductOfferingDeleteEvent,
+}
+
 #[cfg(test)]
 mod test {
     use super::*;

src/tmf620/product_offering_price.rs

@@ -1,11 +1,14 @@
 //! Product Offering Price Module
 
-use serde::{Deserialize,Serialize};
+use chrono::Utc;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
 
 use super::MOD_PATH;
-use crate::{HasId,HasName, HasLastUpdate, LIB_PATH, HasValidity, TimePeriod};
+use crate::{HasId,HasName, HasLastUpdate, LIB_PATH,TMFEvent,HasValidity, TimePeriod};
 use crate::common::money::Money;
 use crate::common::tax_item::TaxItem;
+use crate::common::event::{Event,EventPayload};
 use tmflib_derive::{HasId,HasLastUpdate,HasName, HasValidity};
 
 const CLASS_PATH : &str = "productOfferingPrice";
@@ -106,6 +109,60 @@ impl ProductOfferingPrice {
     }
 }
 
+/// Container for the payload that generated the event
+#[derive(Clone,Debug,Default,Deserialize,Serialize)]
+pub struct ProductOfferingPriceEvent {
+    /// Struct that this event relates to
+    pub pop: ProductOfferingPrice,
+}
+
+impl TMFEvent<ProductOfferingPriceEvent> for ProductOfferingPrice {
+    fn event(&self) -> ProductOfferingPriceEvent {
+        ProductOfferingPriceEvent {
+            pop : self.clone(),
+        }
+    }
+}
+
+impl EventPayload<ProductOfferingPriceEvent> for ProductOfferingPrice {
+    type Subject = ProductOfferingPrice;
+    type EventType = ProductOfferingPriceEventType;
+    fn to_event(&self,event_type : ProductOfferingPriceEventType) -> Event<ProductOfferingPriceEvent,ProductOfferingPriceEventType> {       
+        let now = Utc::now();
+        let event_time = chrono::DateTime::from_timestamp(now.timestamp(),0).unwrap();
+        let desc = format!("{:?} for {}",event_type,self.get_name());
+        Event {
+            correlation_id: None,
+            description: Some(desc),
+            domain: Some(ProductOfferingPrice::get_class()),
+            event_id: Uuid::new_v4().to_string(),
+            field_path: None,
+            href: self.href.clone(),
+            id: self.id.clone(),
+            title: self.name.clone(),
+            event_time: event_time.to_string(),
+            priority: None,
+            time_occurred: None,
+            event_type,
+            event: self.event(),
+        }
+    }
+}
+
+/// Product Offering Price Event Type
+#[derive(Clone,Default,Debug,Deserialize,PartialEq, Serialize)]
+pub enum ProductOfferingPriceEventType {
+    /// POP Created
+    #[default]
+    ProductOfferingPriceCreateEvent,
+    /// POP Attribute Value Changed
+    ProductOfferingPriceAttributeValueChangeEvent,
+    /// POP State Changed
+    ProductOfferingPriceStateChangeEvent,
+    /// POP Deleted
+    ProductOfferingPriceDeleteEvent,
+}
+
 #[cfg(test)]
 mod test {
 

src/tmf620/product_specification.rs

@@ -1,7 +1,9 @@
 //! Product Specification Module
 //!
 
+use chrono::Utc;
 use serde::{Deserialize, Serialize};
+use uuid::Uuid;
 
 use super::MOD_PATH;
 
@@ -13,8 +15,10 @@ use crate::{
     HasValidity, 
     TimePeriod, 
     HasLastUpdate,
+    TMFEvent,
     Cardinality
 };
+use crate::common::event::{Event,EventPayload};
 use tmflib_derive::{
     HasDescription,
     HasId,
@@ -276,6 +280,53 @@ impl From<&ServiceSpecification> for ProductSpecification {
     }
 }
 
+// Events
+/// Product Specification Event Container
+#[derive(Clone,Debug,Default,Deserialize,Serialize)]
+pub struct ProductSpecificationEvent {
+    product_specification: ProductSpecification,
+}
+
+impl TMFEvent<ProductSpecificationEvent> for ProductSpecification {
+    fn event(&self) -> ProductSpecificationEvent {
+        ProductSpecificationEvent {
+            product_specification: self.clone(),
+        }
+    }
+}
+
+impl EventPayload<ProductSpecificationEvent> for ProductSpecification {
+    type Subject = ProductSpecification;
+    type EventType = ProductSpecificationEventType;
+    fn to_event(&self,event_type : Self::EventType) -> Event<ProductSpecificationEvent,Self::EventType> {
+        let now = Utc::now();
+        let event_time = chrono::DateTime::from_timestamp(now.timestamp(),0).unwrap();
+        let desc = format!("{:?} for {}",event_type,self.get_name());
+        Event {
+            description: Some(desc),
+            domain: Some(ProductSpecification::get_class()),
+            event_id: Uuid::new_v4().to_string(),
+            href: self.href.clone(),
+            id: self.id.clone(),
+            title: self.name.clone(),
+            event_time: event_time.to_string(),
+            event_type,
+            event: self.event(),
+            ..Event::default()
+        }    
+    }
+}
+
+/// Product Specification Event Type
+#[derive(Clone,Default,Debug)]
+pub enum ProductSpecificationEventType {
+    /// Product Specification Created
+    #[default]
+    ProductSpecificationCreateEvent,
+    /// Product Specification Deleted
+    ProductSpecificationDeleteEvent,
+}
+
 /// Enum to cover value with many types
 #[derive(Clone, Default, Debug, Deserialize, Serialize)]
 #[serde(untagged)]