} // func GetDataFromStream
/// <summary>Pull dataset from the object.</summary>
/// <param name="obj"></param>
/// <returns></returns>
protected override PpsDataSetServer PullData(PpsObjectAccess obj)
{
// get the head or given revision
// create the dataset
var data = (PpsDataSetServer)DataSetDefinition.CreateDataSet();
if (obj.HeadRevId > 0)
{
var xDocumentData = XDocument.Parse(obj.GetText());
data.Read(xDocumentData.Root);
}
else
{
CallTableMethods(LuaOnCreateRevision, obj, data);
}
// correct id and revision
CheckHeadObjectId(obj, data);
// fire triggers
CallTableMethods(LuaOnAfterPull, obj, data);
// mark all has orignal
data.Commit();
return(data);
} // func PullData
} // func GetDatasetResourceFile
/// <summary>Process webrequest, return schema.xml and resource files (client scripts).</summary>
/// <param name="r"></param>
/// <returns></returns>
protected override async Task <bool> OnProcessRequestAsync(IDEWebRequestScope r)
{
if (r.RelativeSubPath == "schema.xml")
{
await Task.Run(() => DataSetDefinition.WriteToDEContext(r, ConfigPath + "/schema.xml"));
return(true);
}
else if (GetDatasetResourceFile(r.RelativeSubPath, out var fi))
{
if (MimeTypeMapping.TryGetMimeTypeFromExtension(fi.Extension, out var mimeType))
{
if (mimeType == MimeTypes.Text.Lua || mimeType == MimeTypes.Text.Html) // map lua,html to plain text, do not change content
{
mimeType = MimeTypes.Text.Plain;
}
}
else
{
mimeType = MimeTypes.Application.OctetStream;
}
await Task.Run(() => r.WriteFile(fi.FullName, mimeType));
return(true);
}
return(await base.OnProcessRequestAsync(r));
} // proc OnProcessRequest
internal DataSetPublishingResult(DataSetDefinition dataSetDefinition, DataSourceInfo dataSourceInfo, UserLocationFlags userReferenceLocation, ProcessingMessageList warnings)
{
m_dataSetDefinition = dataSetDefinition;
m_dataSourceInfo = dataSourceInfo;
m_userReferenceLocation = userReferenceLocation;
m_warnings = warnings;
}
public static ParsedDataSet ParseIPTWPData(IPTWPPacket iptwpPacket, UdpPacket udp, bool extensive)
{
if (iptwpPacket == null || iptwpPacket.IPTWPType == IPTTypes.MA)
{
return(null);
}
DataSetDefinition dataSetDefinition = null;
foreach (var collection in DataCollections)
{
var find = collection.FindByIdentifier(iptwpPacket.Comid.ToString());
if (find != null)
{
dataSetDefinition = find;
break;
}
}
if (dataSetDefinition != null)
{
try
{
var iptPayload = IPTWPPacket.GetIPTPayload(udp, iptwpPacket);
return(dataSetDefinition.Parse(iptPayload, extensive));
}
catch (Exception e)
{
return(ParsedDataSet.CreateError(e.Message));
}
}
return(null);
}
public DataSetCollection GetDataSetCollection()
{
var c = new DataSetCollection();
var datasetdic = new Dictionary <string, DataSetDefinition>();
//var triplets = new Tuple<string, DataSetDefinition, List<int>>();
foreach (Dataset dataset in Datasets)
{
var set = ExtractDataset(dataset);
var d = new DataSetDefinition();
d.BitFields = set;
var serial = d.Serialize();
if (!datasetdic.ContainsKey(serial))
{
datasetdic.Add(serial, d);
}
}
foreach (var t in Telegrams)
{
var comid = t.Comid.ToString();
var set = Datasets.First(dataset => dataset.Datasetid == t.Datasetid);
var dud = new DataSetDefinition()
{
BitFields = ExtractDataset(set)
};
var serial = dud.Serialize();
var datasetdef = datasetdic[serial];
if (string.IsNullOrEmpty(datasetdef.Name))
{
datasetdef.Name = t.Name;
}
else if (!datasetdef.Name.Contains(t.Name))
{
datasetdef.Name += "," + t.Name;
}
if (!datasetdef.Identifiers.Contains(comid))
{
datasetdef.Identifiers.Add(comid);
}
}
var outlist = datasetdic.Values.ToList();
outlist.RemoveAll(d => d.Identifiers.Count == 0);
c.DataSets.AddRange(outlist);
return(c);
}
} // proc WriteDataToStream
/// <summary>Parse dataset from the input stream.</summary>
/// <param name="src"></param>
/// <returns></returns>
protected override PpsDataSetServer GetDataFromStream(Stream src)
{
var data = (PpsDataSetServer)DataSetDefinition.CreateDataSet();
using (var xml = XmlReader.Create(src, Procs.XmlReaderSettings))
data.Read(XDocument.Load(xml).Root);
return(data);
} // func GetDataFromStream
public RSDataSetDefinition PrepareQuery(RSDataSource DataSource, RSDataSetDefinition DataSet, out bool Changed, out string[] ParameterNames)
{
DataSource ds = (DataSource)Converter.Convert(DataSource);
DataSetDefinition dsDef = (DataSetDefinition)Converter.Convert(DataSet);
DataSetDefinition outval = rs.PrepareQuery(ds, dsDef, out Changed, out ParameterNames);
return((RSDataSetDefinition)Converter.Convert(outval));
}
public void Initialize(DataSetDefinition dataSetDefinition)
{
int size = 0;
if (dataSetDefinition.DataSetCore != null && dataSetDefinition.DataSetCore.Query != null && dataSetDefinition.DataSetCore.Query.Parameters != null)
{
size = dataSetDefinition.DataSetCore.Query.Parameters.Count;
}
this.m_parameters = new ParametersImpl(size);
this.InitializeGlobalAndUserCollections();
this.m_currentFields = new FieldsContext(this, dataSetDefinition.DataSetCore);
this.m_dataSources = new DataSourcesImpl(0);
this.m_dataSets = new DataSetsImpl(0);
this.m_variables = new VariablesImpl(false);
this.m_aggregates = new AggregatesImpl(false, this.m_odpContext);
this.m_reportItems = new ReportItemsImpl(false);
this.m_lookups = new LookupsImpl();
}
} // proc OnEndReadConfiguration
private async Task BindDataSetDefinitonAsync()
{
DataSetDefinition = Application.GetDataSetDefinition(Config.GetAttribute("dataset", String.Empty));
if (!DataSetDefinition.IsInitialized) // initialize dataset functionality
{
await DataSetDefinition.InitializeAsync();
}
// prepare scripts for the the current node
var luaEngine = this.GetService <IDELuaEngine>(true);
var list = new List <ILuaAttachedScript>();
foreach (var scriptId in DataSetDefinition.ServerScripts)
{
list.Add(luaEngine.AttachScript(scriptId, this, true));
}
currentAttachedScripts = list.ToArray();
} // proc BindDataSetDefinitonAsync
public DataSetDefinition PrepareQuery(DataSource DataSource, DataSetDefinition DataSet, out bool Changed, out string[] ParameterNames)
{
object[] results = this.Invoke("PrepareQuery", new object[] {
DataSource,
DataSet});
Changed = ((bool)(results[1]));
ParameterNames = ((string[])(results[2]));
return ((DataSetDefinition)(results[0]));
}
/// <remarks/>
public System.IAsyncResult BeginPrepareQuery(DataSource DataSource, DataSetDefinition DataSet, System.AsyncCallback callback, object asyncState)
{
return this.BeginInvoke("PrepareQuery", new object[] {
DataSource,
DataSet}, callback, asyncState);
}
public RetrievalManager(DataSetDefinition dataSetDefinition, OnDemandProcessingContext context)
{
this.m_dataSetDefinition = dataSetDefinition;
this.m_odpContext = context;
}
/// <summary>
/// Loads subscription settings into SubscriptionSettings object
/// </summary>
/// <param name="filename">Name of XML file to parse</param>
/// <returns>Collection of Subscription Settings</returns>
/// <remarks>This is the meaty bit</remarks>
public SubscriptionSettings[] LoadSubscriptions(string filename)
{
try
{
// Load XML Document
var xml = XElement.Load(filename);
//// ---------------------------------------------
//// Read XML into Linq monster
//// ---------------------------------------------
var reportSubscriptions = from reportSubscription in xml.Elements("ReportSubscription")
select
new
{
reportName = (string)reportSubscription.Attribute("ReportName"),
subscriptionDescription =
(string)reportSubscription.Attribute("SubscriptionDescription"),
deliveryMethod =
(string)reportSubscription.Attribute("DeliveryMethod"),
dataSource = (string)reportSubscription.Attribute("DataSource"),
itemPath = (string)reportSubscription.Attribute("ItemPath"),
eventType = (string)reportSubscription.Element("EventType"),
queryDefinition = reportSubscription.Element("QueryDefinition"),
scheduleXml = reportSubscription.Element("ScheduleDefinition"),
fields =
from field in reportSubscription.Element("DatasetDefinition").Elements("Fields").Elements()
select field,
extentionParameters =
from extParam in
reportSubscription.Element("ExtensionParameters").Elements()
select extParam,
parameters =
from param in
reportSubscription.Element("Parameters").Elements()
select param,
extensionSetting = (string)reportSubscription.Element("ExtensionSetting")
};
var subSettings = new SubscriptionSettings[reportSubscriptions.Count()];
var subscriptionIndex = 0;
//// ---------------------------------------------
//// Run through each subscription and get values
//// ---------------------------------------------
foreach (var reportSubscription in reportSubscriptions)
{
subSettings[subscriptionIndex] = new SubscriptionSettings();
// Get Subscription Information
subSettings[subscriptionIndex].ReportName = reportSubscription.reportName;
subSettings[subscriptionIndex].SubscriptionDescription = reportSubscription.subscriptionDescription;
subSettings[subscriptionIndex].DeliveryMethod = reportSubscription.deliveryMethod;
subSettings[subscriptionIndex].DataSource = reportSubscription.dataSource;
subSettings[subscriptionIndex].ItemPath = reportSubscription.itemPath;
subSettings[subscriptionIndex].FullReportName = reportSubscription.itemPath + reportSubscription.reportName;
// Get EventType setting
subSettings[subscriptionIndex].EventType = reportSubscription.eventType;
// Get QueryDefinition
subSettings[subscriptionIndex].QueryDefinition = new QueryDefinition
{
CommandText = (string)reportSubscription.queryDefinition.Element("CommandText"),
CommandType = (string)reportSubscription.queryDefinition.Element("CommandType"),
Timeout = (int)reportSubscription.queryDefinition.Element("Timeout"),
TimeoutSpecified = (bool)reportSubscription.queryDefinition.Element("TimeoutSpecified")
};
// Get Schedule Raw XML
subSettings[subscriptionIndex].ScheduleXml = reportSubscription.scheduleXml.ToString();
// Get Fields
var numberOfFields = reportSubscription.fields.Count();
var fieldsList = new Field[numberOfFields];
var fieldIndex = 0;
foreach (var field in reportSubscription.fields)
{
fieldsList[fieldIndex] = new Field
{
Name = (string)field.Element("Name"),
Alias = (string)field.Element("Alias")
};
fieldIndex++;
}
// Dataset Definition
subSettings[subscriptionIndex].DataSetDefinition = new DataSetDefinition
{
AccentSensitivitySpecified = false,
CaseSensitivitySpecified = false,
KanatypeSensitivitySpecified = false,
WidthSensitivitySpecified = false,
Fields = fieldsList
};
// Get Extension Paramters
int numberOfParameterValues = reportSubscription.extentionParameters.Count();
var extensionParams = new ParameterValueOrFieldReference[numberOfParameterValues];
var extParamIndex = 0;
foreach (var extParam in reportSubscription.extentionParameters)
{
switch ((string)extParam.Attribute("Type"))
{
case "ParameterValue":
var pv = new ParameterValue
{
Name = (string)extParam.Element("Name"),
Value = (string)extParam.Element("Value")
};
extensionParams[extParamIndex] = pv;
break;
case "ParameterFieldReference":
var pfr = new ParameterFieldReference
{
ParameterName = (string)extParam.Element("ParameterName"),
FieldAlias = (string)extParam.Element("FieldAlias")
};
extensionParams[extParamIndex] = pfr;
break;
}
extParamIndex++;
}
subSettings[subscriptionIndex].ExtensionParameters = extensionParams;
// Get (Input) Parameters
int numberOfNormalParameterValues = reportSubscription.parameters.Count();
var parameters = new ParameterValueOrFieldReference[numberOfNormalParameterValues];
var paramIndex = 0;
foreach (var param in reportSubscription.parameters)
{
switch ((string)param.Attribute("Type"))
{
case "ParameterValue":
var pv = new ParameterValue
{
Name = (string)param.Element("Name"),
Value = (string)param.Element("Value")
};
parameters[paramIndex] = pv;
break;
case "ParameterFieldReference":
var pfr = new ParameterFieldReference
{
ParameterName = (string)param.Element("ParameterName"),
FieldAlias = (string)param.Element("FieldAlias")
};
parameters[paramIndex] = pfr;
break;
}
paramIndex++;
}
subSettings[subscriptionIndex].Parameters = parameters;
// Get Extension setting
subSettings[subscriptionIndex].ExtensionSettings = new ExtensionSettings
{
Extension = reportSubscription.extensionSetting,
ParameterValues = extensionParams
};
// Set up Dataset Definition
subSettings[subscriptionIndex].DataSetDefinition.Query = subSettings[subscriptionIndex].QueryDefinition;
// Set up Datasource Definition/Reference
subSettings[subscriptionIndex].DataSourceReference = new DataSourceReference
{
Reference = reportSubscription.itemPath + reportSubscription.dataSource
};
// Prepare Query
var preparationResults = new DataSetDefinition();
try
{
bool changed;
string[] paramNames;
preparationResults =
client.PrepareQuery(
new DataSource()
{
Item = subSettings[subscriptionIndex].DataSourceReference,
Name = "Database" // ?
},
subSettings[subscriptionIndex].DataSetDefinition,
out changed,
out paramNames);
}
catch (SoapException e)
{
Console.WriteLine(e.Message);
}
subSettings[subscriptionIndex].DataRetrievalPlan = new DataRetrievalPlan
{
DataSet = preparationResults,
Item = subSettings[subscriptionIndex].DataSourceReference
};
subscriptionIndex++;
}
return subSettings;
}
catch (Exception e)
{
throw new Exception("Error loading subscription settings. Please use absolute path and check XML file is correctly formed.\n\nError Message:\n------------------\n" + e.Message);
}
}
internal RetrievalManager(DataSetDefinition dataSetDefinition, OnDemandProcessingContext context)
{
m_dataSetDefinition = dataSetDefinition;
m_odpContext = context;
}
public RuntimeDataSourceSharedDataSet(DataSetDefinition dataSetDefinition, OnDemandProcessingContext odpContext)
: base(null, new DataSource(-1, dataSetDefinition.SharedDataSourceReferenceId, dataSetDefinition.DataSetCore), odpContext, false)
{
this.m_dataSetDefinition = dataSetDefinition;
}
/// <remarks/>
public void PrepareQueryAsync(DataSource DataSource, DataSetDefinition DataSet)
{
this.PrepareQueryAsync(DataSource, DataSet, null);
}
/// <remarks/>
public void PrepareQueryAsync(DataSource DataSource, DataSetDefinition DataSet, object userState)
{
if ((this.PrepareQueryOperationCompleted == null))
{
this.PrepareQueryOperationCompleted = new System.Threading.SendOrPostCallback(this.OnPrepareQueryOperationCompleted);
}
this.InvokeAsync("PrepareQuery", new object[] {
DataSource,
DataSet}, this.PrepareQueryOperationCompleted, userState);
}
internal RuntimeDataSourceSharedDataSet(DataSetDefinition dataSetDefinition, OnDemandProcessingContext odpContext)
: base(null, new DataSource(-1, dataSetDefinition.SharedDataSourceReferenceId, dataSetDefinition.DataSetCore), odpContext, mergeTransactions: false)
{
m_dataSetDefinition = dataSetDefinition;
}
