/******************************************************************************/
private void updateSelectedEvent(ListViewItem lvi)
{
oadrDistributeEventTypeOadrEvent oadrEvent = m_lviToEvent[lvi];
// event descriptor
tbEventID.TextBoxText = oadrEvent.eiEvent.eventDescriptor.eventID;
tbModificationNumber.TextBoxText = oadrEvent.eiEvent.eventDescriptor.modificationNumber.ToString();
tbPriority.TextBoxText = oadrEvent.eiEvent.eventDescriptor.priority.ToString();
tbMarketContext.TextBoxText = oadrEvent.eiEvent.eventDescriptor.eiMarketContext.marketContext;
// oadrEvent.eiEvent.eventDescriptor.createdDateTime.Kind = DateTimeKind.Utc;
tbCreatedDate.TextBoxText = oadrEvent.eiEvent.eventDescriptor.createdDateTime.ToLocalTime().ToString();
tbEventStatus.TextBoxText = oadrEvent.eiEvent.eventDescriptor.eventStatus.ToString();
tbTestEvent.TextBoxText = oadrEvent.eiEvent.eventDescriptor.testEvent;
tbVtnComment.TextBoxText = oadrEvent.eiEvent.eventDescriptor.vtnComment;
// active period
tbDTStart.TextBoxText = oadrEvent.eiEvent.eiActivePeriod.properties.dtstart.datetime.ToLocalTime().ToString();
tbDuration.TextBoxText = oadrEvent.eiEvent.eiActivePeriod.properties.duration.duration;
// FIXME: these are all optional. need a better way to reference the object w/o worrying
// about exceptions
try
{
tbTolerance.TextBoxText = oadrEvent.eiEvent.eiActivePeriod.properties.tolerance.tolerate.startafter;
}
catch { }
try
{
tbNotification.TextBoxText = oadrEvent.eiEvent.eiActivePeriod.properties.xeiNotification.duration;
}
catch { }
try
{
tbRampup.TextBoxText = oadrEvent.eiEvent.eiActivePeriod.properties.xeiRampUp.duration;
}
catch { }
try
{
tbRecovery.TextBoxText = oadrEvent.eiEvent.eiActivePeriod.properties.xeiRecovery.duration;
}
catch { }
// targets
updateTarget(oadrEvent.eiEvent.eiTarget.groupID, lstGroups);
updateTarget(oadrEvent.eiEvent.eiTarget.resourceID, lstResources);
updateTarget(oadrEvent.eiEvent.eiTarget.venID, lstVENs);
updateTarget(oadrEvent.eiEvent.eiTarget.partyID, lstParty);
// signals
lstSignals.Items.Clear();
foreach (eiEventSignalType signal in oadrEvent.eiEvent.eiEventSignals.eiEventSignal)
{
addSignal(signal);
}
}
/**********************************************************/
private bool signalsValid(oadrDistributeEventTypeOadrEvent evt)
{
if (evt.eiEvent.eiEventSignals.eiEventSignal == null)
{
return(true);
}
try
{
for (int index = 0; index < evt.eiEvent.eiEventSignals.eiEventSignal.Length; index++)
{
eiEventSignalType signal = evt.eiEvent.eiEventSignals.eiEventSignal[index];
if (!m_customSignals.Contains(signal.signalName))
{
OadrSignals.Instance.validateSignal(signal);
}
}
}
catch (ExceptionInvalidSignal ex)
{
m_callbacks.logSystemMessage("Invalid signal found: " + ex.Message, UserControls.Log.WebLogView.eWebLogMessageStatus.WARNING);
return(false);
}
return(true);
}
/**********************************************************/
private bool eventValid(oadrDistributeEventTypeOadrEvent evt, VEN2b ven, string requestID, CreatedEventHelper createdEventHelper)
{
// TODO: log event message when these checks fail
if (!targetMatches(evt, ven))
{
m_callbacks.logSystemMessage("Invalid target in event " + evt.eiEvent.eventDescriptor.eventID, UserControls.Log.WebLogView.eWebLogMessageStatus.WARNING);
createdEventHelper.addEvent(evt, requestID, OptTypeType.optOut, 452, "Invalid ID");
return(false);
}
if (!m_marketContexts.Contains(evt.eiEvent.eventDescriptor.eiMarketContext.marketContext))
{
m_callbacks.logSystemMessage("Invalid Market Context in event " + evt.eiEvent.eventDescriptor.eventID + ", " + evt.eiEvent.eventDescriptor.eiMarketContext.marketContext, UserControls.Log.WebLogView.eWebLogMessageStatus.WARNING);
createdEventHelper.addEvent(evt, requestID, OptTypeType.optOut, 453, "Not Recognized");
return(false);
}
if (!signalsValid(evt))
{
createdEventHelper.addEvent(evt, requestID, OptTypeType.optOut, 460, "");
return(false);
}
return(true);
}
/******************************************************************************/
private void updateEvent(oadrDistributeEventTypeOadrEvent oadrEvent, string eventID)
{
ListViewItem lvi = m_idToLvi[eventID];
// lvi.SubItems[1].Text = oadrEvent.eiEvent.eiActivePeriod.properties.duration.duration;
lvi.SubItems[IND_STARTTIME].Text = oadrEvent.eiEvent.eiActivePeriod.properties.dtstart.datetime.ToLocalTime().ToString();
lvi.SubItems[IND_DURATION].Text = oadrEvent.eiEvent.eiActivePeriod.properties.duration.duration;
Color color;
if (oadrEvent.eiEvent.eventDescriptor.eventStatus == EventStatusEnumeratedType.active)
{
color = COL_GREEN;
}
else if (oadrEvent.eiEvent.eventDescriptor.eventStatus == EventStatusEnumeratedType.near)
{
color = COL_YELLOW;
}
else
{
color = lvi.SubItems[0].BackColor;
}
lvi.SubItems[IND_STATUS].BackColor = color;
lvi.SubItems[IND_STATUS].Text = oadrEvent.eiEvent.eventDescriptor.eventStatus.ToString();
lvi.SubItems[IND_MARKETCONTEXT].Text = oadrEvent.eiEvent.eventDescriptor.eiMarketContext.marketContext;
lvi.SubItems[IND_SIGNALTYPE].Text = oadrEvent.eiEvent.eiEventSignals.eiEventSignal[0].signalType.ToString();
float value = oadrEvent.eiEvent.eiEventSignals.eiEventSignal[0].currentValue.Item.value;
string payload = convertPayloadType(value);
lvi.SubItems[IND_CURRENTVALUE].Text = payload;
lvi.SubItems[IND_VTNCOMMENT].Text = oadrEvent.eiEvent.eventDescriptor.vtnComment;
lvi.SubItems[IND_TESTEVENT].Text = oadrEvent.eiEvent.eventDescriptor.testEvent;
lvi.SubItems[IND_RESPONSEREQUIRED].Text = oadrEvent.oadrResponseRequired.ToString();
m_idToEvent[eventID] = oadrEvent;
m_lviToEvent[lvi] = oadrEvent;
if (listView1.SelectedItems.Count != 0)
{
if (listView1.SelectedItems[0] == lvi)
{
updateSelectedEvent(lvi);
}
}
}
public OadrEventWrapper(oadrDistributeEventTypeOadrEvent oadrEvent, OptTypeType optType)
{
m_oadrEvent = oadrEvent;
OptType = optType;
RandomizedMinutes = 0;
DelayCancel = false;
setStartAfter();
}
/******************************************************************************/
private List <oadrDistributeEventTypeOadrEvent> getSelectedEvents()
{
List <oadrDistributeEventTypeOadrEvent> evts = new List <oadrDistributeEventTypeOadrEvent>();
foreach (ListViewItem lvi in listView1.SelectedItems)
{
oadrDistributeEventTypeOadrEvent evt = m_lviToEvent[lvi];
evts.Add(evt);
}
return(evts);
}
/**********************************************************/
public CreateOpt createOptEvent(string requestID, string optID, oadrDistributeEventTypeOadrEvent evt, OptTypeType optType, OptReasonEnumeratedType optReason, string resourceID = null)
{
CreateOpt request = new CreateOpt();
string requestBody = request.createOptEvent(requestID, optID, evt, optType, optReason, VENID, resourceID);
if ((request.response = (oadrCreatedOptType)postRequest(requestBody, "/EiOpt", request)) != null)
{
request.setEiResponse(request.response.eiResponse);
}
return(request);
}
/******************************************************************************/
/*
* set removeMissingEvents to true when this function is called with the entire list
* of events, ie, when requestEvents is called on the VTN
* set removeMissingEvents to false if the incoming distributeEvent updates or adds
* a limited set of events
*/
// public void updateEvents(oadrDistributeEventType distributeEvent)
public void updateEvents(Dictionary <string, OadrEventWrapper> activeEvents, string requestID)
{
List <string> eventIDs = new List <string>();
m_requestID = requestID;
MethodInvoker mi = new MethodInvoker(delegate
{
lock (this)
{
if (activeEvents.Count() == 0)
{
removeAllEventsInterval();
return;
}
foreach (OadrEventWrapper oadrEventWrapper in activeEvents.Values)
{
oadrDistributeEventTypeOadrEvent oadrEvent = oadrEventWrapper.OadrEvent;
string eventID = oadrEvent.eiEvent.eventDescriptor.eventID;
if (!m_idToEvent.ContainsKey(eventID))
{
addNewEvent(oadrEvent, eventID);
}
else
{
updateEvent(oadrEvent, eventID);
}
eventIDs.Add(eventID);
}
// remove events from UI that are no longer in the list
checkForRemovedEvents(eventIDs);
}
});
// BeginInvoke only needs to be called if we're tyring to update the UI from
// a thread that did not create it
if (this.InvokeRequired)
{
this.BeginInvoke(mi);
}
else
{
mi.Invoke();
}
}
/**********************************************************/
public string createOptEvent(string requestID, string optID, oadrDistributeEventTypeOadrEvent evt, OptTypeType optType, OptReasonEnumeratedType optReason, string venID, string resourceID = null)
{
initOpt(requestID, optID, optType, optReason, venID);
request.qualifiedEventID = new QualifiedEventIDType();
request.qualifiedEventID.eventID = evt.eiEvent.eventDescriptor.eventID;
request.qualifiedEventID.modificationNumber = evt.eiEvent.eventDescriptor.modificationNumber;
if (resourceID != null)
{
request.eiTarget = new EiTargetType();
request.eiTarget.resourceID = new string[1];
request.eiTarget.resourceID[0] = resourceID;
}
return(serializeObject(request));
}
public void addEvent(oadrDistributeEventTypeOadrEvent oadrEvent, string requestID, OptTypeType optType, int responseCode = 200, string responseDescription = "OK")
{
eventResponsesEventResponse eventResponse = new eventResponsesEventResponse();
eventResponse.optType = optType;
eventResponse.qualifiedEventID = new QualifiedEventIDType();
eventResponse.qualifiedEventID.eventID = oadrEvent.eiEvent.eventDescriptor.eventID;
eventResponse.qualifiedEventID.modificationNumber = oadrEvent.eiEvent.eventDescriptor.modificationNumber;
eventResponse.requestID = requestID;
eventResponse.responseCode = responseCode.ToString();
eventResponse.responseDescription = responseDescription;
m_eventResponses.Add(eventResponse);
}
/******************************************************************************/
private void addNewEvent(oadrDistributeEventTypeOadrEvent oadrEvent, string eventID)
{
ListViewItem lvi = new ListViewItem(eventID);
lvi.UseItemStyleForSubItems = false;
for (int x = 0; x < listView1.Columns.Count - 1; x++)
{
lvi.SubItems.Add("");
}
m_idToEvent.Add(eventID, oadrEvent);
m_lviToEvent.Add(lvi, oadrEvent);
m_idToLvi.Add(eventID, lvi);
listView1.Items.Add(lvi);
updateEvent(oadrEvent, eventID);
// insert database
using (var db = new DataModels.VenDB())
{
var newEvent = new DataModels.Event();
newEvent.IDEvent = lvi.Text;
newEvent.CurrentValue = lvi.SubItems[IND_CURRENTVALUE].Text;
newEvent.DateCreated = DateTime.Now;
newEvent.StartTime = DateTime.Now;
newEvent.SignalType = lvi.SubItems[IND_SIGNALTYPE].Text;
newEvent.MarketContext = lvi.SubItems[IND_MARKETCONTEXT].Text;
newEvent.VTNComment = lvi.SubItems[IND_VTNCOMMENT].Text;
newEvent.TestEvent = lvi.SubItems[IND_TESTEVENT].Text;
newEvent.ResponseRequired = lvi.SubItems[IND_RESPONSEREQUIRED].Text;
newEvent.Status = lvi.SubItems[IND_STATUS].Text;
newEvent.Duration = lvi.SubItems[IND_DURATION].Text;
newEvent.VenID = VenID;
newEvent.VenName = VenName;
newEvent.VenNum = VenNum;
db.InsertWithIdentity(newEvent);
}
}
/******************************************************************************/
private void addNewEvent(oadrDistributeEventTypeOadrEvent oadrEvent, string eventID)
{
ListViewItem lvi = new ListViewItem(eventID);
lvi.UseItemStyleForSubItems = false;
for (int x = 0; x < listView1.Columns.Count - 1; x++)
{
lvi.SubItems.Add("");
}
m_idToEvent.Add(eventID, oadrEvent);
m_lviToEvent.Add(lvi, oadrEvent);
m_idToLvi.Add(eventID, lvi);
listView1.Items.Add(lvi);
updateEvent(oadrEvent, eventID);
}
/**********************************************************/
private bool targetMatches(oadrDistributeEventTypeOadrEvent evt, VEN2b ven)
{
try
{
if (evt.eiEvent.eiTarget.venID != null)
{
if (evt.eiEvent.eiTarget.venID[0] != ven.VENID)
{
return(false);
}
}
}
catch (Exception ex)
{
oadrlib.lib.helper.Logger.logException(ex);
return(false);
}
return(true);
}
/**********************************************************/
public List <oadrDistributeEventTypeOadrEvent> checkEventStatusChanges(int serverOffsetSeconds)
{
var result = new List <oadrDistributeEventTypeOadrEvent>();
foreach (KeyValuePair <string, OadrEventWrapper> eventKeyValue in m_idToEvent)
{
oadrDistributeEventTypeOadrEvent oadrEvent = eventKeyValue.Value.OadrEvent;
if (oadrEvent.eiEvent.eventDescriptor.eventStatus == EventStatusEnumeratedType.cancelled)
{
continue;
}
DateTime now = DateTime.Now.AddSeconds(serverOffsetSeconds);
DateTime dtstart = oadrEvent.eiEvent.eiActivePeriod.properties.dtstart.datetime.ToLocalTime();
TimeSpan duration = XmlConvert.ToTimeSpan(oadrEvent.eiEvent.eiActivePeriod.properties.duration.duration);
TimeSpan rampUpDuration = new TimeSpan(0);
if (oadrEvent.eiEvent.eiActivePeriod.properties.xeiRampUp != null)
{
rampUpDuration = XmlConvert.ToTimeSpan(oadrEvent.eiEvent.eiActivePeriod.properties.xeiRampUp.duration);
}
EventStatusEnumeratedType oldEventStatus = oadrEvent.eiEvent.eventDescriptor.eventStatus;
EventStatusEnumeratedType newEventStatus;
if (now < dtstart)
{
newEventStatus = (now + rampUpDuration >= dtstart) ? EventStatusEnumeratedType.near
: EventStatusEnumeratedType.far;
}
// duration of 0 indicates an open ended event (no scheduled end time)
else if (now >= dtstart && (now < dtstart + duration || duration.TotalSeconds == 0))
{
newEventStatus = EventStatusEnumeratedType.active;
}
else
{
newEventStatus = EventStatusEnumeratedType.completed;
}
// if an active event is cancelled and the event has the start after parameter set
// the event will remain active for a random number of minutes before cancelling
if (eventKeyValue.Value.DelayCancel)
{
if (now >= eventKeyValue.Value.DelayCanceledEndTime)
{
newEventStatus = EventStatusEnumeratedType.cancelled;
m_callbacks.logSystemMessage("Cancelling active event after waiting a randomized minutes", UserControls.Log.WebLogView.eWebLogMessageStatus.INFO);
}
}
if (newEventStatus != oldEventStatus)
{
oadrEvent.eiEvent.eventDescriptor.eventStatus = newEventStatus;
m_callbacks.logSystemMessage("Event status changed: " + oadrEvent.eiEvent.eventDescriptor.eventID + ", old=" + oldEventStatus.ToString() + ", new=" + newEventStatus.ToString(), UserControls.Log.WebLogView.eWebLogMessageStatus.INFO);
//oadrlib.lib.helper.Logger.logMessage(String.Format("event {0} status change: {1} to {2}",
// eventKeyValue.Key, oldEventStatus, newEventStatus));
result.Add(oadrEvent);
}
}
return(result);
}
/**********************************************************/
private void processExistingEvent(string requestID, CreatedEventHelper createdEventHelper, oadrDistributeEventTypeOadrEvent evt)
{
string eventID = evt.eiEvent.eventDescriptor.eventID;
OadrEventWrapper existingEvent = m_idToEvent[eventID];
if (existingEvent.OadrEvent.eiEvent.eventDescriptor.modificationNumber > evt.eiEvent.eventDescriptor.modificationNumber)
{
// the incoming event has an old modification number; keep tracking the old event
// and report an error to the VTN
m_callbacks.logSystemMessage("Event update received out of sequence and will be ignored: " + eventID + ", current=" + existingEvent.OadrEvent.eiEvent.eventDescriptor.modificationNumber.ToString() + ", incoming=" + evt.eiEvent.eventDescriptor.modificationNumber.ToString(), UserControls.Log.WebLogView.eWebLogMessageStatus.WARNING);
createdEventHelper.addEvent(evt, requestID, existingEvent.OptType, 450, "Out of sequence");
return;
}
// if the event was updated (modification numbers don't match), we must re-optin/out, provided
// the event is still active
if (existingEvent.OadrEvent.eiEvent.eventDescriptor.modificationNumber != evt.eiEvent.eventDescriptor.modificationNumber &&
evt.oadrResponseRequired == ResponseRequiredType.always &&
evt.eiEvent.eventDescriptor.eventStatus != EventStatusEnumeratedType.completed)
{
// the event was modified; need to send createdEvent again
if (evt.eiEvent.eventDescriptor.eventStatus != EventStatusEnumeratedType.cancelled)
{
m_callbacks.logSystemMessage("Opting modified event: " + existingEvent.OptType.ToString() + " , " + eventID, UserControls.Log.WebLogView.eWebLogMessageStatus.INFO);
createdEventHelper.addEvent(evt, requestID, existingEvent.OptType, 200, "OK");
}
// event was cancelled; need to optIn to indicate we ackowledge the cancellation
// optOut indicates we cannot cancel
else
{
m_callbacks.logSystemMessage("Opting into cancelled event: " + eventID, UserControls.Log.WebLogView.eWebLogMessageStatus.INFO);
createdEventHelper.addEvent(evt, requestID, OptTypeType.optIn, 200, "OK");
m_idToEvent[eventID].OptType = OptTypeType.optIn;
}
}
// if the event is active and is being cancelled and the Start After parameter was set,
// delay cancelling the event by RandomizedMinutes minutes
if (m_idToEvent[eventID].OadrEvent.eiEvent.eventDescriptor.eventStatus == EventStatusEnumeratedType.active &&
m_idToEvent[eventID].RandomizedMinutes != 0 && evt.eiEvent.eventDescriptor.eventStatus == EventStatusEnumeratedType.cancelled)
{
// force the event to remain active
evt.eiEvent.eventDescriptor.eventStatus = EventStatusEnumeratedType.active;
// set the end time to be used to detemermine when the event will end
m_idToEvent[eventID].initiateDelayCancel();
m_callbacks.logSystemMessage(string.Format("Active event with randomized start time was cancelled. event will be cancelled at ",
m_idToEvent[eventID].DelayCanceledEndTime.ToString()), UserControls.Log.WebLogView.eWebLogMessageStatus.INFO);
}
EventStatusEnumeratedType oldEventStatus = m_idToEvent[eventID].OadrEvent.eiEvent.eventDescriptor.eventStatus;
EventStatusEnumeratedType newEventStatus = evt.eiEvent.eventDescriptor.eventStatus;
// log event status changes
if (oldEventStatus != evt.eiEvent.eventDescriptor.eventStatus)
{
m_callbacks.logSystemMessage("Server reported Event status changed: " + eventID + ", old=" + oldEventStatus.ToString() + ", new=" + newEventStatus.ToString(), UserControls.Log.WebLogView.eWebLogMessageStatus.INFO);
}
// replace the event
m_idToEvent[eventID].OadrEvent = evt;
return;
}
/**********************************************************/
private void processNewEvent(string requestID, OptTypeType oadrOptType, CreatedEventHelper createdEventHelper, oadrDistributeEventTypeOadrEvent evt)
{
string eventID = evt.eiEvent.eventDescriptor.eventID;
m_idToEvent.Add(eventID, new OadrEventWrapper(evt, oadrOptType));
m_callbacks.logSystemMessage("Found new event " + eventID, UserControls.Log.WebLogView.eWebLogMessageStatus.INFO);
// send a createdEvent message if a response is required
if (evt.oadrResponseRequired == ResponseRequiredType.always)
{
// send the default opt for new events that aren't cancelled or completed
if (evt.eiEvent.eventDescriptor.eventStatus != EventStatusEnumeratedType.cancelled &&
evt.eiEvent.eventDescriptor.eventStatus != EventStatusEnumeratedType.completed)
{
m_callbacks.logSystemMessage("Opting new event: " + oadrOptType.ToString() + " , " + eventID, UserControls.Log.WebLogView.eWebLogMessageStatus.INFO);
createdEventHelper.addEvent(evt, requestID, oadrOptType, 200, "OK");
}
else if (evt.eiEvent.eventDescriptor.eventStatus == EventStatusEnumeratedType.cancelled)
{
// event was already cancelled by the time we first received it;
// need to optIn to indicate we ackowledge the cancellation
// optOut indicates we cannot cancel
m_callbacks.logSystemMessage("Opting into cancelled event: " + eventID, UserControls.Log.WebLogView.eWebLogMessageStatus.INFO);
createdEventHelper.addEvent(evt, requestID, OptTypeType.optIn, 200, "OK");
m_idToEvent[eventID].OptType = OptTypeType.optIn;
}
else if (evt.eiEvent.eventDescriptor.eventStatus == EventStatusEnumeratedType.completed)
{
// optOut of the previously completed event
m_callbacks.logSystemMessage("Opting out of completed event: " + eventID, UserControls.Log.WebLogView.eWebLogMessageStatus.INFO);
createdEventHelper.addEvent(evt, requestID, OptTypeType.optOut, 200, "OK");
m_idToEvent[eventID].OptType = OptTypeType.optOut;
}
}
}
public void generateOadrDistributeEvent()
{
oadrPayload payload = new oadrPayload();
payload.oadrSignedObject = new oadrSignedObject();
oadrDistributeEventType distributeEvent = new oadrDistributeEventType();
distributeEvent.schemaVersion = "2.0b";
distributeEvent.eiResponse = new EiResponseType();
distributeEvent.eiResponse.requestID = "";
distributeEvent.eiResponse.responseCode = "200";
distributeEvent.eiResponse.responseDescription = "OK";
distributeEvent.requestID = "OadrDisReq050214_092500_050";
distributeEvent.vtnID = "TH_VTN";
payload.oadrSignedObject.Item = distributeEvent;
distributeEvent.oadrEvent = new oadrDistributeEventTypeOadrEvent[1];
oadrDistributeEventTypeOadrEvent oadrEvent = new oadrDistributeEventTypeOadrEvent();
distributeEvent.oadrEvent[0] = oadrEvent;
eiEventType eiEvent = new eiEventType();
oadrEvent.eiEvent = eiEvent;
eiEvent.eventDescriptor = new eventDescriptorType();
eiEvent.eventDescriptor.eventID = "Event050214_092500_550_0";
eiEvent.eventDescriptor.modificationNumber = 0;
eiEvent.eventDescriptor.modificationDateTime = DateTime.ParseExact("2014-02-05T17:25:00Z", "yyyy-MM-ddTHH:mm:00Z", CultureInfo.InvariantCulture);
eiEvent.eventDescriptor.modificationReason = "Update";
eiEvent.eventDescriptor.priority = 1;
eiEvent.eventDescriptor.eiMarketContext = new eventDescriptorTypeEiMarketContext();
eiEvent.eventDescriptor.eiMarketContext.marketContext = "http://MarketContext1";
eiEvent.eventDescriptor.createdDateTime = DateTime.ParseExact("2014-02-05T17:25:00Z", "yyyy-MM-ddTHH:mm:00Z", CultureInfo.InvariantCulture);
eiEvent.eventDescriptor.eventStatus = EventStatusEnumeratedType.completed;
eiEvent.eventDescriptor.testEvent = "false";
eiEvent.eventDescriptor.vtnComment = "Sample Payload";
eiEvent.eventDescriptor.vtnComment = "comment";
// active period
eiEvent.eiActivePeriod = new eiActivePeriodType();
eiEvent.eiActivePeriod.properties = new properties();
eiEvent.eiActivePeriod.properties.dtstart = new dtstart();
eiEvent.eiActivePeriod.properties.dtstart.datetime = DateTime.ParseExact("2014-02-05T17:35:00Z", "yyyy-MM-ddTHH:mm:00Z", CultureInfo.InvariantCulture);
eiEvent.eiActivePeriod.properties.duration = new DurationPropType();
eiEvent.eiActivePeriod.properties.duration.duration = "PT5M";
eiEvent.eiActivePeriod.properties.xeiNotification = new DurationPropType();
eiEvent.eiActivePeriod.properties.xeiNotification.duration = "PT1M";
// signals
eiEvent.eiEventSignals = new eiEventSignalsType();
eiEvent.eiEventSignals.eiEventSignal = new eiEventSignalType[1];
eiEventSignalType signal = new eiEventSignalType();
signal.intervals = new IntervalType[1];
signal.intervals[0] = new IntervalType();
signal.intervals[0].duration = new DurationPropType();
signal.intervals[0].duration.duration = "PT5M";
IntervalTypeUidUid uid = new IntervalTypeUidUid();
uid.text = "0";
signal.intervals[0].Item = uid;
// signal payload
signal.intervals[0].streamPayloadBase = new StreamPayloadBaseType[1];
signalPayloadType val = new signalPayloadType();
PayloadFloatType pft = new PayloadFloatType();
pft.value = (float)3.14;
val.Item = pft;
signal.intervals[0].streamPayloadBase[0] = val;
eiEvent.eiEventSignals.eiEventSignal[0] = signal;
// signal type
signal.signalName = SignalNameEnumeratedType.ELECTRICITY_PRICE.ToString();
signal.signalType = SignalTypeEnumeratedType.price;
signal.signalID = "SIG_02";
currencyType currency = new currencyType();
currency.itemDescription = currencyItemDescriptionType.currencyPerKWh;
currency.itemUnits = ISO3AlphaCurrencyCodeContentType.USD;
currency.siScaleCode = SiScaleCodeType.none;
signal.itemBase = currency;
signal.currentValue = new currentValueType();
PayloadFloatType pft2 = new PayloadFloatType();
pft2.value = (float)0.0;
signal.currentValue.Item = pft2;
signal.eiTarget = new EiTargetType();
signal.eiTarget.resourceID = new string[2];
signal.eiTarget.resourceID[0] = "resource1";
signal.eiTarget.resourceID[1] = "resource2";
oadrEvent.oadrResponseRequired = ResponseRequiredType.always;
string xml = SerializeOadrObject.serializeOjbect(payload, payload.GetType());
Console.Out.WriteLine(xml);
/*serializer = new XmlSerializer(typeof(eiEventSignalType));
*
* MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(xml));
*
* signal = (eiEventSignalType)serializer.Deserialize(ms);
*
* Assert.IsNotNull(signal);
*
* ms.Close();*/
}
