Introduction
This example takes the very simple flow element described in the simple flow element example, and adds a data file, upgrading the flow element to an aspect engine.
Instead of storing data statically, as the simple flow element example did, this example will store it in a data file which will be loaded and can also be updated.
Download Example
The source code used in this example is available here:
Dependencies
The aspect engine will need a dependency on the Pipeline engines package now as it is implementing an aspect engine rather than a flow element.
Select a tab to view language specific dependencies.
The only dependency needed for .NET is the
FiftyOne.Pipeline.Engines NuGet package. The only dependency needed for Java is the
pipeline.engines Maven package from com.51degrees. To include this, add the following to the <dependencies> section of the project's pom.xml: <dependency>
<groupId>com.51degrees</groupId>
<artifactId>pipeline.engines</artifactId>
<version>4.2.0</version>
</dependency>
Add a dependency to the
fiftyone.pipeline.engines NPM package to the package.json, and required it in the source with require("fiftyone.pipeline.engines"). Data
The element data implemented in the previous example can now be upgraded to implement an aspect data.
Select a tab to view language specific aspect data implementation.
Instead of implementing
IElementData, the IStarSignData will now implement IAspectData which extends IElementData.
public interface IStarSignData : IAspectData
{
string StarSign { get; }
}
Now the internal implementation of it will implement a 'getter' and add a 'setter' for StarSign in the same way as the previous example.
internal class StarSignData : AspectDataBase, IStarSignData
{
public StarSignData(
ILogger<AspectDataBase> logger,
IPipeline pipeline,
IAspectEngine engine,
IMissingPropertyService missingPropertyService)
: base(logger, pipeline, engine, missingPropertyService)
{
}
public string StarSign
{
// Get the star sign from the internal IDictionary as a string.
get { return GetAs<string>("starsign"); }
// Add the star sign to the internal IDictionary.
set { base["starsign"] = value; }
}
}
Instead of implementing
ElementData, the StarSignData will now implement AspectData which extends ElementData.
public interface StarSignData extends AspectData {
String getStarSign();
}
Now the internal implementation of it will implement a 'getter' and add a 'setter' for StarSign in the same way as the previous example.
class StarSignDataInternal extends AspectDataBase implements StarSignData {
public StarSignDataInternal(
Logger logger,
FlowData flowData,
AspectEngine<? extends AspectData, ? extends AspectPropertyMetaData> engine,
MissingPropertyService missingPropertyService) {
super(logger, flowData, engine, missingPropertyService);
}
@Override
public String getStarSign() {
return getAs("starsign", String.class);
}
void setStarSign(String starSign) {
put("starsign", starSign);
}
}
Note that this concrete implementation of StarSignData sits in the same package as the aspect engine, not the StarSignData interface, as it only needs to be accessible by the aspect engine.
Node's implementation of element data does not require concrete getters for IDE autocompletion, so
aspectDataDictionary can be used. Aspect Engine
Now the actual aspect engine needs to be implemented. For this, the class from the previous example will now implement the on-premise engine's base class.
Select a tab to view language specific aspect engine implementation.
First let's change the class to extend
OnPremiseAspectEngineBase (which partially implements IOnPremiseAspectEngine). This has the type arguments of IStarSignData - the interface extending aspect data which will be added to the flow data, and IAspectPropertyMetaData - instead of IElementPropertyMetaData.
The existing constructor needs to change to match the OnPremiseAspectEngineBase class. So it takes the additional arguments of a data file path, and a temporary data file path. This is the location of the data file that the aspect engine will use, and where to make a temporary copy if required.
The constructor will also read the data file containing the star signs into memory. This is done in another method so that it can also be used by the RefreshData method when a new data file is downloaded (this is not applicable for this example as star sign data will not change).
public class SimpleOnPremiseEngine : OnPremiseAspectEngineBase<IStarSignData, IAspectPropertyMetaData>
{
public SimpleOnPremiseEngine(
string dataFilePath,
ILogger<AspectEngineBase<IStarSignData, IAspectPropertyMetaData>> logger,
Func<IPipeline, FlowElementBase<IStarSignData, IAspectPropertyMetaData>, IStarSignData> aspectDataFactory,
string tempDataFilePath)
: base(logger, aspectDataFactory, tempDataFilePath)
{
_dataFile = dataFilePath;
Init();
}
The Init method in this example will simply read a CSV file with the start and end dates of each star sign, which looks like:
Aries,21/03,19/04
Taurus,20/04,20/05
Gemini,21/05,20/06
Cancer,21/06,22/07
...
and add each to a list of a new class named StarSign which has the following simple implementation:
internal class StarSign
{
public StarSign(string name, DateTime start, DateTime end)
{
Name = name;
Start = start.AddYears(-start.Year + 1);
End = end.AddYears(-end.Year + 1);
}
public string Name { get; private set; }
public DateTime Start { get; private set; }
public DateTime End { get; private set; }
}
Note that the year of the start and end date are both set to 1, as the year should be ignored, but the year 0 cannot be used in a DateTime.
The new Init method looks like this:
private void Init()
{
// Create a new list to store the data.
var starSigns = new List<StarSign>();
// Open the data file to read the data.
using (TextReader reader = File.OpenText(_dataFile))
{
// Read each line and parse it to construct a new instance of
// the StarSign class.
string line = reader.ReadLine();
while (line != null)
{
var columns = line.Split(',');
starSigns.Add(new StarSign(
columns[0],
DateTime.ParseExact(columns[1], @"yy/MM/dd", CultureInfo.InvariantCulture),
DateTime.ParseExact(columns[2], @"yy/MM/dd", CultureInfo.InvariantCulture)));
line = reader.ReadLine();
}
}
// Set the data.
_starSigns = starSigns;
}
Now the abstract methods can be implemented to create a functional aspect engine.
public class SimpleOnPremiseEngine : OnPremiseAspectEngineBase<IStarSignData, IAspectPropertyMetaData>
{
public SimpleOnPremiseEngine(
string dataFilePath,
ILogger<AspectEngineBase<IStarSignData, IAspectPropertyMetaData>> logger,
Func<IPipeline, FlowElementBase<IStarSignData, IAspectPropertyMetaData>, IStarSignData> aspectDataFactory,
string tempDataFilePath)
: base(logger, aspectDataFactory, tempDataFilePath)
{
_dataFile = dataFilePath;
Init();
}
private string _dataFile;
private IList<StarSign> _starSigns;
private void Init()
{
// Create a new list to store the data.
var starSigns = new List<StarSign>();
// Open the data file to read the data.
using (TextReader reader = File.OpenText(_dataFile))
{
// Read each line and parse it to construct a new instance of
// the StarSign class.
string line = reader.ReadLine();
while (line != null)
{
var columns = line.Split(',');
starSigns.Add(new StarSign(
columns[0],
DateTime.ParseExact(columns[1], @"yy/MM/dd", CultureInfo.InvariantCulture),
DateTime.ParseExact(columns[2], @"yy/MM/dd", CultureInfo.InvariantCulture)));
line = reader.ReadLine();
}
}
// Set the data.
_starSigns = starSigns;
}
// The IStarSignData will be stored with the key "starsign" in the FlowData.
public override string ElementDataKey => "starsign";
// The only item of evidence needed is "date-of-birth".
public override IEvidenceKeyFilter EvidenceKeyFilter =>
new EvidenceKeyFilterWhitelist(new List<string>() { "date-of-birth" });
public override IList<IAspectPropertyMetaData> Properties => new List<IAspectPropertyMetaData>() {
// The only property which will be returned is "starsign" which will be
// a string.
new AspectPropertyMetaData(this, "starsign", typeof(string), "starsign", new List<string>(){"free"}, true),
};
// The data file is free.
public override string DataSourceTier => "free";
public override void RefreshData(string dataFileIdentifier)
{
// Reload star signs from the data file.
Init();
}
public override void RefreshData(string dataFileIdentifier, Stream data)
{
// We won't implement this logic in this example.
throw new NotImplementedException();
}
protected override void ProcessEngine(IFlowData data, IStarSignData aspectData)
{
// Cast aspectData to AgeData so the 'setter' is available.
StarSignData starSignData = (StarSignData)aspectData;
if (data.TryGetEvidence("date-of-birth", out DateTime dateOfBirth))
{
// "date-of-birth" is there, so set the star sign.
var monthAndDay = new DateTime(1, dateOfBirth.Month, dateOfBirth.Day);
foreach (var starSign in _starSigns)
{
if (monthAndDay > starSign.Start &&
monthAndDay < starSign.End)
{
// The star sign has been found, so set it in the
// results.
starSignData.StarSign = starSign.Name;
break;
}
}
}
else
{
// "date-of-birth" is not there, so set the star sign to unknown.
starSignData.StarSign = "Unknown";
}
}
protected override void UnmanagedResourcesCleanup()
{
// Nothing to clean up here.
}
}
First let's change the class to extend
OnPremiseAspectEngineBase (which partially implements OnPremiseAspectEngine). This has the type arguments of StarSignData - the interface extending aspect data which will be added to the flow data, and AspectPropertyMetaData - instead of ElementPropertyMetaData.
The existing constructor needs to change to match the OnPremiseAspectEngineBase class. So it takes the additional arguments of a data file path, and a temporary data file path. This is the location of the data file that the aspect engine will use, and where to make a temporary copy if required.
The constructor will also read the data file containing the star signs into memory. This is done in another method so that it can also be used by the refreshData method when a new data file is downloaded (this is not applicable for this example as star sign data is static).
public class SimpleOnPremiseEngine extends OnPremiseAspectEngineBase<StarSignData, AspectPropertyMetaData> {
public SimpleOnPremiseEngine(
String dataFile,
Logger logger,
ElementDataFactory<StarSignData> elementDataFactory,
String tempDir) throws IOException {
super(logger, elementDataFactory, tempDir);
this.dataFile = dataFile;
init();
}
The init method in this example will simply read a CSV file with the start and end dates of each star sign, which looks like:
Aries,21/03,19/04
Taurus,20/04,20/05
Gemini,21/05,20/06
Cancer,21/06,22/07
...
and add each to a list of a new class named StarSign which has the following simple implementation:
public class StarSign {
private final Calendar end;
private final Calendar start;
private final String name;
public StarSign(String name, String start, String end) {
this.name = name;
this.start = Calendar.getInstance();
String[] startDate = start.split("/");
this.start.set(
0,
Integer.parseInt(startDate[1]) - 1,
Integer.parseInt(startDate[0]));
this.end = Calendar.getInstance();
String[] endDate = end.split("/");
this.end.set(
0,
Integer.parseInt(endDate[1]) - 1,
Integer.parseInt(endDate[0]));
}
public String getName() {
return name;
}
public Calendar getStart() {
return start;
}
public Calendar getEnd() {
return end;
}
}
Note that the year of the start and end date are both set to 0, as the year should be ignored.
The new init method looks like this:
private void init() throws IOException {
List<StarSign> starSigns = new ArrayList<>();
try (FileReader fileReader = new FileReader(dataFile)) {
try (BufferedReader reader = new BufferedReader(fileReader)) {
String line;
while ((line = reader.readLine()) != null) {
String[] columns = line.split(",");
starSigns.add(new StarSign(
columns[0],
columns[1],
columns[2]));
}
}
}
this.starSigns = starSigns;
}
Now the abstract methods can be implemented to create a functional aspect engine.
public class SimpleOnPremiseEngine extends OnPremiseAspectEngineBase<StarSignData, AspectPropertyMetaData> {
public SimpleOnPremiseEngine(
String dataFile,
Logger logger,
ElementDataFactory<StarSignData> elementDataFactory,
String tempDir) throws IOException {
super(logger, elementDataFactory, tempDir);
this.dataFile = dataFile;
init();
}
private final String dataFile;
private List<StarSign> starSigns;
private void init() throws IOException {
List<StarSign> starSigns = new ArrayList<>();
try (FileReader fileReader = new FileReader(dataFile)) {
try (BufferedReader reader = new BufferedReader(fileReader)) {
String line;
while ((line = reader.readLine()) != null) {
String[] columns = line.split(",");
starSigns.add(new StarSign(
columns[0],
columns[1],
columns[2]));
}
}
}
this.starSigns = starSigns;
}
@Override
public String getTempDataDirPath() {
return dataFile;
}
@Override
public Date getDataFilePublishedDate(String dataFileIdentifier) {
return null;
}
@Override
public Date getDataFileUpdateAvailableTime(String dataFileIdentifier) {
return null;
}
@Override
public void refreshData(String dataFileIdentifier) {
try {
init();
} catch (IOException e) {
logger.warn("There was an exception refreshing the data file" +
"'" + dataFileIdentifier + "'",
e);
}
}
@Override
public void refreshData(String dataFileIdentifier, byte[] data) {
// Lets not implement this logic in this example.
}
@Override
protected void processEngine(FlowData data, StarSignData aspectData) throws Exception {
// Cast the StarSignData to StarSignDataInternal so the 'setter' is available.
StarSignDataInternal starSignData = (StarSignDataInternal)aspectData;
TryGetResult<Date> date = data.tryGetEvidence("date-of-birth", Date.class);
if (date.hasValue()) {
// "date-of-birth" is there, so set the star sign.
Calendar dob = Calendar.getInstance();
dob.setTime(date.getValue());
Calendar monthAndDay = Calendar.getInstance();
monthAndDay.set(
0,
dob.get(Calendar.MONTH),
dob.get(Calendar.DATE));
for (StarSign starSign : starSigns) {
if (monthAndDay.compareTo(starSign.getStart()) >= 0 &&
monthAndDay.compareTo(starSign.getEnd()) <= 0) {
starSignData.setStarSign(starSign.getName());
break;
}
}
}
else
{
// "date-of-birth" is not there, so set the star sign to unknown.
starSignData.setStarSign("Unknown");
}
}
@Override
public String getElementDataKey() {
// The StarSignData will be stored with the key "starsign" in the FlowData.
return "starsign";
}
@Override
public EvidenceKeyFilter getEvidenceKeyFilter() {
// The only item of evidence needed is "date-of-birth".
return new EvidenceKeyFilterWhitelist(
Collections.singletonList("date-of-birth"),
String.CASE_INSENSITIVE_ORDER);
}
@Override
public List<AspectPropertyMetaData> getProperties() {
// The only property which will be returned is "starsign" which will be
// an String.
return Collections.singletonList(
(AspectPropertyMetaData) new AspectPropertyMetaDataDefault(
"starsign",
this,
"starsign",
String.class,
Collections.singletonList("free"),
true));
}
@Override
public String getDataSourceTier() {
return "free";
}
@Override
protected void unmanagedResourcesCleanup() {
// Nothing to clean up here.
}
}
First let's change the class to extend engine.
The existing constructor needs to change to match the engine class. So it takes the additional argument of a data file path. This is the location of the data file that the aspect engine will use.
The constructor will also read the data file containing the star signs into memory. This is done in another method so that it can also be used when a new data file is downloaded (this is not applicable for this example as star sign data is static).
// Astrology flowElement
class Astrology extends FiftyOnePipelineEngines.Engine {
constructor ({ datafile }) {
super(...arguments);
// Create a datafile including a filesystem watcher that checks if
// the datafile has changed. Test by changing the names of the
// starsigns to see it update
this.dataFile = new FiftyOnePipelineEngines
.DataFile(
{
flowElement: this,
path: datafile,
autoUpdate: false,
fileSystemWatcher: true
}
);
this.registerDataFile(this.dataFile);
// datakey used to categorise data coming back from
// this flowElement in a pipeline
this.dataKey = 'astrology';
// A filter (in this case a basic list) stating which evidence the
// flowElement is interested in, in this case a query string
this.evidenceKeyFilter = new FiftyOnePipelineCore
.BasicListEvidenceKeyFilter(['query.dateOfBirth']);
// Update the datafile
this.refresh();
}
The refresh method in this example will simply read a JSON file with the start and end dates of each star sign, which looks like:
[
[
"Aries",
"21/03",
"19/04"
],
[
"Taurus",
"20/04",
"20/05"
],
...
and parse into objects.
The new refresh method looks like this:
// A function called when the datafile is updated / refreshed. In this
// case it simply loads the JSON from the file into the engine's memory.
refresh () {
const engine = this;
fs.readFile(this.dataFile.path, 'utf8', function (err, data) {
if (err) {
return console.error(err);
}
data = JSON.parse(data);
// Load the datafile into memory and parse it to make it
// more easily readable
data = data.map(function (e) {
const start = e[1].split('/');
const end = e[2].split('/');
return {
starsign: e[0],
startMonth: parseInt(start[1]),
startDate: parseInt(start[0]),
endMonth: parseInt(end[1]),
endDate: parseInt(end[0])
};
});
engine.data = data;
});
}
Now the abstract methods can be implemented to create a functional aspect engine.
//! [constructor]
// Astrology flowElement
class Astrology extends FiftyOnePipelineEngines.Engine {
constructor ({ datafile }) {
super(...arguments);
// Create a datafile including a filesystem watcher that checks if
// the datafile has changed. Test by changing the names of the
// starsigns to see it update
this.dataFile = new FiftyOnePipelineEngines
.DataFile(
{
flowElement: this,
path: datafile,
autoUpdate: false,
fileSystemWatcher: true
}
);
this.registerDataFile(this.dataFile);
// datakey used to categorise data coming back from
// this flowElement in a pipeline
this.dataKey = 'astrology';
// A filter (in this case a basic list) stating which evidence the
// flowElement is interested in, in this case a query string
this.evidenceKeyFilter = new FiftyOnePipelineCore
.BasicListEvidenceKeyFilter(['query.dateOfBirth']);
// Update the datafile
this.refresh();
}
//! [constructor]
//! [refresh]
// A function called when the datafile is updated / refreshed. In this
// case it simply loads the JSON from the file into the engine's memory.
refresh () {
const engine = this;
fs.readFile(this.dataFile.path, 'utf8', function (err, data) {
if (err) {
return console.error(err);
}
data = JSON.parse(data);
// Load the datafile into memory and parse it to make it
// more easily readable
data = data.map(function (e) {
const start = e[1].split('/');
const end = e[2].split('/');
return {
starsign: e[0],
startMonth: parseInt(start[1]),
startDate: parseInt(start[0]),
endMonth: parseInt(end[1]),
endDate: parseInt(end[0])
};
});
engine.data = data;
});
}
//! [refresh]
// Internal processing function
processInternal (flowData) {
let dateOfBirth = flowData.evidence.get('query.dateOfBirth');
// Collect data to save back into the flowData under this engine
const result = {};
// Lookup the date of birth using the provided and now parsed datafile
if (dateOfBirth) {
dateOfBirth = dateOfBirth.split('-');
const month = parseInt(dateOfBirth[1]);
const day = parseInt(dateOfBirth[2]);
result.starSign = this.data.filter(function (date) {
// Find starsigns in the correct month
if (date.startMonth === month) {
if (date.startDate > day) {
return false;
} else if (date.endMonth === month && date.endDate <= day) {
return false;
} else {
return true;
}
} else if (date.endMonth === month) {
if (date.endDate < day) {
return false;
} else {
return true;
}
} else {
return false;
}
})[0].starsign;
};
// Save the data into an extension of the elementData class
// (in this case a simple dictionary subclass)
const data = new FiftyOnePipelineCore.ElementDataDictionary({
flowElement: this, contents: result
});
// Set this data on the flowElement
flowData.setElementData(data);
}
}
Builder
Now the aspect engine needs one final thing, an element builder to construct it. This needs to provide the aspect engine with a logger and an aspect data factory as in the previous example. However, it also now needs a data file.
Select a tab to view language specific element builder implementation.
As this aspect engine is using a data file, the builder can make use of the logic in the
SingleFileAspectEngineBuilderBase.
public class SimpleOnPremiseEngineBuilder : SingleFileAspectEngineBuilderBase<SimpleOnPremiseEngineBuilder, SimpleOnPremiseEngine>
{
public SimpleOnPremiseEngineBuilder(
ILoggerFactory loggerFactory,
IDataUpdateService dataUpdateService) : base(dataUpdateService)
{
_loggerFactory = loggerFactory;
}
private ILoggerFactory _loggerFactory;
protected override SimpleOnPremiseEngine NewEngine(List<string> properties)
{
if (DataFileConfigs.Count != 1)
{
throw new Exception(
"This builder requires one and only one configured file " +
$"but it has {DataFileConfigs.Count}");
}
var config = DataFileConfigs.First();
return new SimpleOnPremiseEngine(
config.DataFilePath,
_loggerFactory.CreateLogger<SimpleOnPremiseEngine>(),
CreateData,
TempDir);
}
public IStarSignData CreateData(
IPipeline pipeline,
FlowElementBase<IStarSignData, IAspectPropertyMetaData> aspectEngine)
{
return new StarSignData(
_loggerFactory.CreateLogger<StarSignData>(),
pipeline,
(SimpleOnPremiseEngine)aspectEngine,
MissingPropertyService.Instance);
}
public override SimpleOnPremiseEngineBuilder SetPerformanceProfile(PerformanceProfiles profile)
{
// Lets not implement multiple performance profiles in this example.
return this;
}
}
As this aspect engine is using a data file, the builder can make use of the logic in the
SingleFileAspectEngineBuilderBase.
public class SimpleOnPremiseEngineBuilder
extends SingleFileAspectEngineBuilderBase<
SimpleOnPremiseEngineBuilder,
SimpleOnPremiseEngine> {
public SimpleOnPremiseEngineBuilder(ILoggerFactory loggerFactory) {
super(loggerFactory);
}
@Override
protected SimpleOnPremiseEngine newEngine(List<String> properties) {
if (dataFileConfigs.size() != 1)
{
throw new RuntimeException(
"This builder requires one and only one configured file " +
"but it has " + dataFileConfigs.size());
}
DataFileConfiguration config = dataFileConfigs.get(0);
try {
return new SimpleOnPremiseEngine(
config.getDataFilePath(),
loggerFactory.getLogger(SimpleOnPremiseEngine.class.getName()),
new ElementDataFactory<StarSignData>() {
@Override
public StarSignData create(
FlowData flowData,
FlowElement<StarSignData, ?> flowElement) {
return new StarSignDataInternal(
loggerFactory.getLogger(StarSignDataInternal.class.getName()),
flowData,
(SimpleOnPremiseEngine)flowElement,
MissingPropertyServiceDefault.getInstance());
}
},
tempDir);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
@Override
public SimpleOnPremiseEngineBuilder setPerformanceProfile(Constants.PerformanceProfiles profile) {
// Lets not implement multiple performance profiles in this example.
return this;
}
}
The Node implementation does not use separate builder classes. Instead the options are provided by optional constructor parameters.
Usage
Select a tab to view language specific usage.
This new aspect engine can now be added to a Pipeline and used like:
// Construct the engine using the data file. Let's disable auto
// updates as we have not implemented it in this example engine.
var starSignEngine = new SimpleOnPremiseEngineBuilder(_loggerFactory, null)
.SetAutoUpdate(false)
.SetDataFileSystemWatcher(false)
.Build("starsigns.csv", false);
// Construct the pipeline with the example engine.
var pipeline = new PipelineBuilder(_loggerFactory)
.AddFlowElement(starSignEngine)
.Build();
var dob = new DateTime(1992, 12, 18);
// Create a new flow data.
using (var flowData = pipeline.CreateFlowData())
{
// Add the evidence and process the data.
flowData
.AddEvidence("date-of-birth", dob)
.Process();
// Now get the result of the processing.
Console.WriteLine($"With a date of birth of {dob}, " +
$"your star sign is {flowData.Get<IStarSignData>().StarSign}.");
}
to give an output of:
With a date of birth of 18/12/1992, your star sign is Sagittarius.
This new aspect engine can now be added to a Pipeline and used like:
SimpleOnPremiseEngine starSignEngine =
new SimpleOnPremiseEngineBuilder(loggerFactory)
.setAutoUpdate(false)
.build(
Main.class.getClassLoader().getResource("starsigns.csv").getPath(),
false);
Pipeline pipeline = new PipelineBuilder(loggerFactory)
.addFlowElement(starSignEngine)
.build();
Calendar dob = Calendar.getInstance();
dob.set(1992, Calendar.DECEMBER, 18);
try (FlowData flowData = pipeline.createFlowData()) {
flowData
.addEvidence("date-of-birth", dob.getTime())
.process();
System.out.println("With a date of birth of " +
new SimpleDateFormat("yyyy/MM/dd").format(dob.getTime()) +
", your star sign is " +
flowData.getFromElement(starSignEngine).getStarSign() +
".");
}
to give an output of:
With a date of birth of 18/12/1992, your star sign is Sagittarius.
This new aspect engine can now be added to a Pipeline and used like:
const astrologyElement = new Astrology(
{ datafile: (process.env.directory || __dirname) + '/astrology.json' }
);
const http = require('http');
const pipeline = new FiftyOnePipelineCore.PipelineBuilder()
.add(astrologyElement)
.build();
const server = http.createServer((req, res) => {
if (req.url !== '/favicon.ico') {
const flowData = pipeline.createFlowData();
// Add any information from the request
// (headers, cookies and additional client side provided information)
flowData.evidence.addFromRequest(req);
flowData.process().then(function () {
// Output the date of birth form with any results if they exist
const output = `
<h1>Starsigns</h1>
${flowData.astrology.starSign
? '<p>Your starsign is ' +
flowData.astrology.starSign + ' </p>'
: '<p>Add your date of birth to get your starsign</p>'
}
<form>
<label for='dateOfBirth'>Date of birth</label>
<input type='date' name='dateOfBirth' id='dateOfBirth'>
<input type='submit'>
</form>
`;
res.statusCode = 200;
res.setHeader('Content-Type', 'text/html');
res.end(output);
});
}
});
const portNum = process.env.PORT || 3000;
console.info('To test this example, browse to http://localhost:' + portNum);
server.listen(portNum);
To print the star sign of the user.
Next Steps
The Custom Client-Side Evidence example shows how you can build a custom engine that can take evidence supplied by the client.