/**********************************************************************************/
public void updateEventOpt(List <oadrDistributeEventTypeOadrEvent> evts, OptTypeType optType, OptReasonEnumeratedType optReason, string resourceID)
{
Thread thread = new Thread(delegate()
{
try
{
CreateOpt createOpt;
foreach (oadrDistributeEventTypeOadrEvent evt in evts)
{
lock (m_ven)
{
createOpt = m_ven.createOptEvent(RandomHex.instance().generateRandomHex(10), RandomHex.instance().generateRandomHex(10),
evt, optType, optReason, resourceID);
}
m_callbacks.processCreateOpt(createOpt);
}
}
catch (Exception ex)
{
m_callbacks.processException(ex);
}
});
thread.Start();
}
/**********************************************************/
public void queueOptUpdate(List <oadrDistributeEventTypeOadrEvent> evts, OptTypeType optType)
{
lock (m_qOptUpdate)
{
OptUpdate optUpdate = new OptUpdate(evts, optType);
m_qOptUpdate.Enqueue(optUpdate);
}
}
/**********************************************************/
public string createdOadrCreatedEvent(string venID, string requestID, List <oadrDistributeEventTypeOadrEvent> evts, OptTypeType optType, int responseCode = 200, string responseDescription = "OK")
{
this.optType = optType;
updatedEvents = evts;
request = new oadrCreatedEventType();
request.schemaVersion = "2.0b";
request.eiCreatedEvent = new eiCreatedEvent();
request.eiCreatedEvent.eiResponse = new EiResponseType();
if (evts.Count != 0)
{
request.eiCreatedEvent.eiResponse.requestID = "";
}
else
{
request.eiCreatedEvent.eiResponse.requestID = requestID;
}
request.eiCreatedEvent.eiResponse.responseCode = responseCode.ToString();
request.eiCreatedEvent.eiResponse.responseDescription = responseDescription;
request.eiCreatedEvent.venID = venID;
request.eiCreatedEvent.eventResponses = new eventResponsesEventResponse[evts.Count];
int index = 0;
foreach (oadrDistributeEventTypeOadrEvent evt in evts)
{
eventResponsesEventResponse eventResponse = new eventResponsesEventResponse();
eventResponse.optType = optType;
eventResponse.qualifiedEventID = new QualifiedEventIDType();
eventResponse.qualifiedEventID.eventID = evt.eiEvent.eventDescriptor.eventID;
eventResponse.qualifiedEventID.modificationNumber = evt.eiEvent.eventDescriptor.modificationNumber;
// eventResponse.requestID = RandomHex.generateRandomHex(10);
eventResponse.requestID = requestID;
eventResponse.responseCode = responseCode.ToString();
eventResponse.responseDescription = responseDescription;
request.eiCreatedEvent.eventResponses[index] = eventResponse;
index++;
}
return(serializeObject((object)request));
}
public OadrEventWrapper(oadrDistributeEventTypeOadrEvent oadrEvent, OptTypeType optType)
{
m_oadrEvent = oadrEvent;
OptType = optType;
RandomizedMinutes = 0;
DelayCancel = false;
setStartAfter();
}
/**********************************************************/
// ucManageOptSchedules callbacks
/**********************************************************/
public void processEventOpt(List <oadrDistributeEventTypeOadrEvent> evts, OptTypeType optType, string requestID, int responseCode, string responseDescription)
{
try
{
setVENParameters();
m_venWrapper.updateEventOpt(evts, optType, requestID, responseCode, responseDescription);
}
catch (Exception ex)
{
updateError(ex);
}
}
/******************************************************************************/
private void optInOut(OptTypeType optType)
{
if (listView1.SelectedItems.Count == 0)
{
return;
}
List <oadrDistributeEventTypeOadrEvent> evts = getSelectedEvents();
if (m_callbackHandler != null)
{
m_callbackHandler.processEventOpt(evts, optType, m_requestID, 200, "OK");
}
}
/**********************************************************/
private void initOpt(string requestID, string optID, OptTypeType optType, OptReasonEnumeratedType optReason, string venID, string marketContext = null)
{
request = new oadrCreateOptType();
request.schemaVersion = "2.0b";
request.requestID = requestID;
request.optID = optID;
request.optType = optType;
request.optReason = (optReason == OptReasonEnumeratedType.xschedule ? "x-schedule" : optReason.ToString());
if (marketContext != null)
{
request.marketContext = marketContext;
}
request.venID = venID;
request.createdDateTime = DateTime.UtcNow;
}
/**********************************************************************************/
public void updateEventOpt(List <oadrDistributeEventTypeOadrEvent> evts, OptTypeType optType, string requestID, int responseCode, string responseDescription)
{
Thread thread = new Thread(delegate()
{
try
{
CreatedEvent createdEvent;
lock (m_ven)
{
createdEvent = m_ven.createdEvent(requestID, evts, optType, responseCode, responseDescription);
}
m_callbacks.processCreatedEvent(createdEvent, m_processEvents.ActiveEvents, requestID);
}
catch (Exception ex)
{
m_callbacks.processException(ex);
}
});
thread.Start();
}
/**********************************************************/
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 processEvents(oadrDistributeEventType distributeEvent, string requestID, eOptType optType, VEN2b ven)
{
List <string> eventIDs = new List <string>(); // track list of valid events from distributeEvent object
// will use to match against our list of active events
// validate the VTN id
if (distributeEvent.vtnID != ven.VTNID)
{
// the VTN ID was invalid; remove all events and send an error message
checkForRemovedEvents(eventIDs);
m_callbacks.logSystemMessage("Invalid VTN ID: " + distributeEvent.vtnID, UserControls.Log.WebLogView.eWebLogMessageStatus.WARNING);
CreatedEvent createdEvent = ven.createdEvent(requestID, 452, "Invalid ID");
m_callbacks.processCreatedEvent(createdEvent, m_idToEvent, requestID);
return;
}
// the VTN didn't send any events; clear all events we have stored
if (distributeEvent.oadrEvent == null)
{
checkForRemovedEvents(eventIDs);
m_callbacks.processCreatedEvent(null, m_idToEvent, requestID);
return;
}
OptTypeType oadrOptType = (optType == eOptType.OptIn ? OptTypeType.optIn : OptTypeType.optOut);
// send a createdEvent with an opt type of the incoming optType for all new events
// that aren't canceled or completed. optIn/out of cancelled and completed events as appropriate
CreatedEventHelper createdEventHelper = new CreatedEventHelper();
foreach (oadrDistributeEventTypeOadrEvent evt in distributeEvent.oadrEvent)
{
string eventID = evt.eiEvent.eventDescriptor.eventID;
// validate that the event is for this VEN and MarketContext
if (!eventValid(evt, ven, requestID, createdEventHelper))
{
continue;
}
eventIDs.Add(eventID);
if (!m_idToEvent.ContainsKey(eventID))
{
processNewEvent(requestID, oadrOptType, createdEventHelper, evt);
}
else
{
processExistingEvent(requestID, createdEventHelper, evt);
}
OadrEventWrapper eventWrapper = m_idToEvent[eventID];
if (eventWrapper.RandomizedMinutes != 0)
{
m_callbacks.logSystemMessage(string.Format("Event start time delayed due to start after parameter: event ID={0}, start after={1}, randomized minutes={2}",
eventWrapper.OadrEvent.eiEvent.eventDescriptor.eventID, eventWrapper.OadrEvent.eiEvent.eiActivePeriod.properties.tolerance.tolerate.startafter,
eventWrapper.RandomizedMinutes), UserControls.Log.WebLogView.eWebLogMessageStatus.INFO);
}
}
// events in m_idToEvent but not in the incoming distributeEvent message must be
// implicitly canceled
checkForRemovedEvents(eventIDs);
if (createdEventHelper.EventResponses.Count > 0)
{
CreatedEvent createdEvent = ven.createdEvent(createdEventHelper);
m_callbacks.processCreatedEvent(createdEvent, m_idToEvent, requestID);
}
else
{
// still need to call this function to ensure the UI is updated with any event status changes
m_callbacks.processCreatedEvent(null, m_idToEvent, requestID);
}
}
/**********************************************************/
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 OptUpdate(List <oadrDistributeEventTypeOadrEvent> evts, OptTypeType optType)
{
m_events = evts;
m_optType = optType;
}
/**********************************************************/
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);
}
/**********************************************************/
public CreatedEvent createdEvent(string requestID, List <oadrDistributeEventTypeOadrEvent> evts, OptTypeType optType, int responseCode = 200, string responseDescription = "OK")
{
CreatedEvent request = new CreatedEvent();
string requestBody = request.createdOadrCreatedEvent(VENID, requestID, evts, optType, responseCode, responseDescription);
if ((request.response = (oadrResponseType)postRequest(requestBody, "/EiEvent", request, true)) != null)
{
request.setEiResponse(request.response.eiResponse);
}
return(request);
}
/**********************************************************/
public void processCreateEventOpt(List <oadrDistributeEventTypeOadrEvent> evts, OptTypeType optType, OptReasonEnumeratedType optReason, string resourceID)
{
try
{
setVENParameters();
m_venWrapper.updateEventOpt(evts, optType, optReason, resourceID);
}
catch (Exception ex)
{
updateError(ex);
}
}
/**********************************************************/
public CreatedEvent createdEvent(string requestID, List <oadrDistributeEventOadrEvent> evts, OptTypeType optType)
{
CreatedEvent createdEvent = new CreatedEvent();
string requestBody = createdEvent.createdOadrCreatedEvent(VENID, requestID, evts, optType);
createdEvent.response = (oadrResponse)postRequest(requestBody, "/EiEvent", createdEvent, typeof(oadrResponse));
return(createdEvent);
}
public string createdOadrCreatedEvent(string venID, string requestID, List <oadrDistributeEventOadrEvent> evts, OptTypeType optType, int responseCode = 200, string responseDescription = "OK")
{
this.optType = optType;
updatedEvents = evts;
createdEvent = new oadrCreatedEvent();
createdEvent.eiCreatedEvent = new eiCreatedEvent();
createdEvent.eiCreatedEvent.eiResponse = new eiResponse();
if (evts.Count != 0)
{
createdEvent.eiCreatedEvent.eiResponse.requestID = "";
}
else
{
createdEvent.eiCreatedEvent.eiResponse.requestID = requestID;
}
createdEvent.eiCreatedEvent.eiResponse.responseCode = responseCode.ToString();
createdEvent.eiCreatedEvent.eiResponse.responseDescription = responseDescription;
createdEvent.eiCreatedEvent.venID = venID;
createdEvent.eiCreatedEvent.eventResponses = new eventResponsesEventResponse[evts.Count];
int index = 0;
foreach (oadrDistributeEventOadrEvent evt in evts)
{
eventResponsesEventResponse eventResponse = new eventResponsesEventResponse();
eventResponse.optType = optType;
eventResponse.qualifiedEventID = new QualifiedEventIDType();
eventResponse.qualifiedEventID.eventID = evt.eiEvent.eventDescriptor.eventID;
eventResponse.qualifiedEventID.modificationNumber = evt.eiEvent.eventDescriptor.modificationNumber;
// eventResponse.requestID = RandomHex.generateRandomHex(10);
eventResponse.requestID = requestID;
eventResponse.responseCode = responseCode.ToString();
eventResponse.responseDescription = responseDescription;
createdEvent.eiCreatedEvent.eventResponses[index] = eventResponse;
index++;
}
XmlSerializer serializer;
// serialize the event
serializer = new XmlSerializer(typeof(oadrCreatedEvent));
// StringWriter sw = new StringWriter();
StringWriterWithEncoding sw = new StringWriterWithEncoding(Encoding.UTF8);
serializer.Serialize(sw, createdEvent);
requestBody = sw.ToString();
return(requestBody);
}
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);
}
