/**********************************************************************************/
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();
}
/**********************************************************************************/
private bool doCreatePartyRegistration()
{
// if we've previously registered, the VTN should return our VEN ID and
// Registration ID in the queryRegistration message
// We shouldn't need to call CreatePartyRegistration at this point, but the
// test set will n1_0020 will fail if we don't send the query message
CreatePartyRegistration createPartyRegistration;
lock (m_ven)
{
createPartyRegistration = m_ven.createPartyRegistration(RandomHex.instance().generateRandomHex(10), oadrProfileType.Item20b, oadrTransportType.simpleHttp, "", false, false, true);
}
m_callbacks.processCreatePartyRegisteration(createPartyRegistration);
// exit if registration failed
if (createPartyRegistration.eiResponseCode != 200)
{
return(false);
}
setPollinterval(createPartyRegistration.response);
return(true);
}
/**********************************************************/
public string createdOadrCreatedEvent(CreatedEventHelper createdEventHelper, string venID, int responseCode = 200, string responseDescription = "OK")
{
request = new oadrCreatedEventType();
request.schemaVersion = "2.0b";
request.eiCreatedEvent = new eiCreatedEvent();
request.eiCreatedEvent.eiResponse = new EiResponseType();
if (createdEventHelper.EventResponses.Count != 0)
{
request.eiCreatedEvent.eiResponse.requestID = "";
}
else
{
request.eiCreatedEvent.eiResponse.requestID = RandomHex.instance().generateRandomHex(10); //requestID;
}
request.eiCreatedEvent.eiResponse.responseCode = responseCode.ToString();
request.eiCreatedEvent.eiResponse.responseDescription = responseDescription;
request.eiCreatedEvent.venID = venID;
request.eiCreatedEvent.eventResponses = new eventResponsesEventResponse[createdEventHelper.EventResponses.Count];
int index = 0;
foreach (eventResponsesEventResponse eventResponse in createdEventHelper.EventResponses)
{
request.eiCreatedEvent.eventResponses[index] = eventResponse;
index++;
}
return(serializeObject((object)request));
}
public string createOadrRequestEvent(string venID, uint replyLimit = 0, string requestID = "")
{
requestEvent = new oadrRequestEvent();
requestEvent.eiRequestEvent = new eiRequestEvent();
requestEvent.eiRequestEvent.venID = venID;
requestEvent.eiRequestEvent.requestID = (requestID == "" ? RandomHex.instance().generateRandomHex(10) : requestID);
if (replyLimit > 0)
{
requestEvent.eiRequestEvent.replyLimit = replyLimit;
requestEvent.eiRequestEvent.replyLimitSpecified = true;
}
XmlSerializer serializer;
// serialize the event
serializer = new XmlSerializer(typeof(oadrRequestEvent));
// StringWriter sw = new StringWriter();
StringWriterWithEncoding sw = new StringWriterWithEncoding(Encoding.UTF8);
serializer.Serialize(sw, requestEvent);
requestBody = sw.ToString();
return(requestBody);
}
/**********************************************************/
public string createQueryRegistration(string requestID = "")
{
request = new oadrQueryRegistrationType();
request.schemaVersion = "2.0b";
request.requestID = (requestID != "" ? requestID : RandomHex.instance().generateRandomHex(10));
return(serializeObject(request));
}
/********************************************************************************/
public ucLoad(string resourceID)
{
InitializeComponent();
if (resourceID == null || resourceID == "")
{
resourceID = RandomHex.instance().generateRandomHex(10);
}
initResource(resourceID);
}
public string createPartyRegistration(string requestID, string venID, string registrationID)
{
request = new oadrCancelPartyRegistrationType();
request.schemaVersion = "2.0b";
request.requestID = (requestID != "" ? requestID : RandomHex.instance().generateRandomHex(10));
request.registrationID = registrationID;
request.venID = venID;
return(serializeObject((object)request));
}
public static ReportDescription generateReportDescription()
{
ReportDescription reportDescription = new ReportDescription();
string reportSpecifierID = RandomHex.instance().generateRandomHex(10);
// add a status report
reportDescription.addReport(reportSpecifierID, ReportName.TELEMETRY_STATUS, 10, DurationModifier.MINUTES);
reportDescription.addDescription(reportSpecifierID, RandomHex.instance().generateRandomHex(10), "resource1", ReportEnumeratedType.xresourceStatus,
ReadingTypeEnumeratedType.xnotApplicable, "http://MarketContext1", 1, 1, false, DurationModifier.MINUTES);
// history usage report
reportSpecifierID = RandomHex.instance().generateRandomHex(10);
reportDescription.addReport(reportSpecifierID, ReportName.HISTORY_USAGE, 10, DurationModifier.MINUTES);
reportDescription.addDescriptionEnergyItem(reportSpecifierID, RandomHex.instance().generateRandomHex(10), "resource1", ReportEnumeratedType.usage,
ReadingTypeEnumeratedType.DirectRead, "http://MarketContext1", 1, 10, false, DurationModifier.MINUTES, eEnergyItemType.EnergyReal,
"RealEnergy", "Wh", SiScaleCodeType.n);
reportDescription.addDescriptionPowerItem(reportSpecifierID, RandomHex.instance().generateRandomHex(10), "resource1", ReportEnumeratedType.usage,
ReadingTypeEnumeratedType.DirectRead, "http://MarketContext1", 1, 10, false, DurationModifier.MINUTES, ePowerItemType.PowerReal,
"RealPower", "W", SiScaleCodeType.n, 60, 110, true);
// the test set will fail if reactive or appparent power/energy are telemetry or history reports
/*reportDescription.addDescriptionPowerItem(reportSpecifierID, RandomHex.instance().generateRandomHex(10), "resource1", ReportEnumeratedType.usage,
* ReadingTypeEnumeratedType.DirectRead, "http://MarketContext1", 1, 10, false, ePowerItemType.PowerApparent,
* "ApparentPower", "VA", SiScaleCodeType.n, 60, 110, true);
*
* reportDescription.addDescriptionPowerItem(reportSpecifierID, RandomHex.instance().generateRandomHex(10), "resource1", ReportEnumeratedType.usage,
* ReadingTypeEnumeratedType.DirectRead, "http://MarketContext1", 1, 10, false, ePowerItemType.PowerReactive,
* "ReactivePower", "VAR", SiScaleCodeType.n, 60, 110, true);*/
// telemetry usage
reportSpecifierID = RandomHex.instance().generateRandomHex(10);
reportDescription.addReport(reportSpecifierID, ReportName.TELEMETRY_USAGE, 10, DurationModifier.MINUTES);
reportDescription.addDescriptionPowerItem(reportSpecifierID, RandomHex.instance().generateRandomHex(10), "resource1", ReportEnumeratedType.usage,
ReadingTypeEnumeratedType.DirectRead, "http://MarketContext1", 1, 10, false, DurationModifier.MINUTES, ePowerItemType.PowerReal,
"RealPower", "W", SiScaleCodeType.n, 60, 110, true);
return(reportDescription);
}
public void reportGeneration()
{
ReportDescription reportDescription = ReportHelper.generateReportDescription();
RegisterReport registerReport = new RegisterReport();
string output = registerReport.createRegisterReport(RandomHex.instance().generateRandomHex(10),
"TH_VEN", reportDescription);
Console.Out.WriteLine(output);
Assert.IsTrue(output.Contains("x-notApplicable"));
Assert.IsTrue(output.Contains("x-resourceStatus"));
object oadrObject = SerializeOadrObject.deserializeObject(output, typeof(oadrPayload));
}
/**********************************************************/
public CreateOpt processOptSchedule(VEN2b ven)
{
OptSchedule optSchedule;
lock (m_qOptSchedule)
{
if (m_qOptSchedule.Count == 0)
{
return(null);
}
optSchedule = m_qOptSchedule.Dequeue();
}
return(ven.createOptSchedule(RandomHex.instance().generateRandomHex(10), optSchedule));
}
/**********************************************************************************/
private bool doRegisterReports(string reportRequestID = null)
{
//ReportDescription reportDescription = m_resources.ReportDescription;
Dictionary <string, ReportWrapper> reports = m_resources.Reports;
RegisterReport registerReport;
CreatedReport createdReport = null;
lock (m_ven)
{
registerReport = m_ven.registerReport(RandomHex.instance().generateRandomHex(10), reports, reportRequestID);
// check for piggy backed report requests
if (registerReport.response.oadrReportRequest != null)
{
// send the createReport callback immediately to allow UI's to update
// if there's a one shot or history report request, these reports
// need to be registered before processCreatedReport() is called below
m_callbacks.processCreateReport(registerReport.response.oadrReportRequest);
m_resources.createReport(registerReport.response.oadrReportRequest);
// issue a createdReport message using the requestID from the registerReport message
createdReport = m_ven.createdReport(registerReport.request.requestID, 200, "OK", m_resources.PendingReports);
}
}
m_callbacks.processRegisterReport(registerReport);
// the registerReport response included a piggy-backed reportRequest
if (createdReport != null)
{
m_callbacks.processCreatedReport(createdReport);
// the new report might have a start date of NOW; call sendReports to force
// the report to be sent immediately
m_resources.sendReports(DateTime.Now);
}
if (registerReport.eiResponseCode != 200)
{
return(false);
}
return(true);
}
/**********************************************************/
public string createOadrRequestEvent(string venID, uint replyLimit = 0, string requestID = "")
{
request = new oadrRequestEventType();
request.schemaVersion = "2.0b";
request.eiRequestEvent = new eiRequestEvent();
request.eiRequestEvent.venID = venID;
request.eiRequestEvent.requestID = (requestID == "" ? RandomHex.instance().generateRandomHex(10) : requestID);
if (replyLimit > 0)
{
request.eiRequestEvent.replyLimit = replyLimit;
request.eiRequestEvent.replyLimitSpecified = true;
}
return(serializeObject((object)request));
}
/**********************************************************/
private void btnAddResource_Click(object sender, EventArgs e)
{
string resourceID = tbResourceID.TextBoxText;
if (resourceID != "")
{
// check that resourceID is unique
if (m_resources.ContainsKey(resourceID))
{
MessageBox.Show("The selected Resource ID is not unique. Please select a new Resource ID.", "Resource ID is not unique", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
}
else
{
resourceID = RandomHex.instance().generateRandomHex(10);
}
addResource(resourceID, cmbResourceType.SelectedItem.ToString());
}
public void P1_2015_VTN_1()
{
VEN2b ven = new VEN2b(new HttpWebRequestWrapper(false, System.Net.SecurityProtocolType.Tls12), TestProperties.vtnURL, TestProperties.venID, TestProperties.venPassword);
OptSchedule optSchedule = new OptSchedule();
optSchedule.addOptSchedule(DateTime.UtcNow.AddDays(1), 0);
optSchedule.OptType = OptTypeType.optIn;
optSchedule.OptReason = OptReasonEnumeratedType.notParticipating;
optSchedule.MarketContext = "http://marketcontext1";
optSchedule.ResourceID = "resource1";
CreateOpt createOpt = ven.createOptSchedule(RandomHex.instance().generateRandomHex(10), optSchedule);
Console.Out.WriteLine(createOpt.responseBody);
Assert.IsNotNull(createOpt.response);
Assert.AreEqual(createOpt.request.optID, createOpt.response.optID);
}
public void N1_0020_TH_VTN_1()
{
VEN2b ven = new VEN2b(new HttpWebRequestWrapper(false, System.Net.SecurityProtocolType.Tls12), TestProperties.vtnURL, TestProperties.venName, TestProperties.venID, TestProperties.venPassword);
// register
CreatePartyRegistration createPartyRegistration = ven.createPartyRegistration(RandomHex.instance().generateRandomHex(10), oadrProfileType.Item20b, oadrTransportType.simpleHttp, "", false, false, true);
Assert.IsTrue(createPartyRegistration.response != null);
Console.Out.WriteLine(createPartyRegistration.responseBody);
// POLL
OadrPoll oadrPoll = ven.poll();
Assert.IsNotNull(oadrPoll.response);
Console.Out.WriteLine(oadrPoll.responseBody);
// First request is registerReport
Assert.IsTrue(oadrPoll.responseTypeIs(typeof(oadrRegisterReportType)));
oadrRegisterReportType registerReportType = oadrPoll.getRegisterReportResponse();
RegisteredReport registeredReport = ven.registeredReport(registerReportType.requestID, "200", "OK");
Assert.IsNotNull(registeredReport.response);
Assert.AreEqual(registeredReport.response.eiResponse.responseCode, "200");
// register our own report
ReportDescription reportDescription = ReportHelper.generateReportDescription();
RegisterReport registerReport = ven.registerReport(RandomHex.instance().generateRandomHex(10), reportDescription);
Assert.IsNotNull(registerReport.response);
Assert.AreEqual("200", registerReport.response.eiResponse.responseCode);
Assert.AreEqual(registerReport.request.requestID, registerReport.response.eiResponse.requestID);
}
/**********************************************************************************/
private void doSendUpdateReport(oadrReportType report, oadrReportRequestType reportRequest)
{
UpdateReport updateReport;
lock (m_ven)
{
updateReport = m_ven.updateReport(RandomHex.instance().generateRandomHex(10), report, reportRequest.reportRequestID);
}
m_callbacks.processUpdateReport(updateReport);
// UpdatedReports can contain a CancelReport piggybacked message; process
// the message if it exists
// since the VTN is not expecting a cancelledReport response so we can't call processCancelReport(...) directly
if (updateReport.response.oadrCancelReport != null)
{
// cancel the report request
List <string> pendingReports = m_resources.addCancelReport(updateReport.response.oadrCancelReport);
// call the callback to update the UI
m_callbacks.processCancelReport(updateReport.response.oadrCancelReport);
}
}
/**********************************************************************************/
public void createOptSchedule(OptSchedule optSchedule)
{
Thread thread = new Thread(delegate()
{
try
{
CreateOpt createOpt;
lock (m_ven)
{
createOpt = m_ven.createOptSchedule(RandomHex.instance().generateRandomHex(10), optSchedule);
}
m_callbacks.processCreateOptSchedule(createOpt);
}
catch (Exception ex)
{
m_callbacks.processException(ex);
}
});
thread.Start();
}
/**********************************************************************************/
public void cancelOptSchedule(string optID)
{
Thread thread = new Thread(delegate()
{
try
{
CancelOpt cancelOpt;
lock (m_ven)
{
cancelOpt = m_ven.createCancelOpt(RandomHex.instance().generateRandomHex(10), optID);
}
m_callbacks.processCancelOpt(cancelOpt);
}
catch (Exception ex)
{
m_callbacks.processException(ex);
}
});
thread.Start();
}
public void N1_0010_TH_VTN_1()
{
VEN2b ven = new VEN2b(new HttpWebRequestWrapper(false, System.Net.SecurityProtocolType.Tls12), TestProperties.vtnURL, TestProperties.venName, TestProperties.venID, TestProperties.venPassword);
QueryRegistration queryRegistration = ven.queryRegistration();
Assert.IsTrue(queryRegistration.response != null);
CreatePartyRegistration createPartyRegistration = ven.createPartyRegistration(RandomHex.instance().generateRandomHex(10), oadrProfileType.Item20b, oadrTransportType.simpleHttp, "", false, false, true);
Assert.IsTrue(createPartyRegistration.response != null);
}
public ucLoad()
{
InitializeComponent();
initResource(RandomHex.instance().generateRandomHex(10));
}
/********************************************************************************/
public oadrOptScheduleModel()
{
OptID = RandomHex.instance().generateRandomHex(10);
}
