public static async Task UndoLesson(DataServiceRestClient client)
{
//Delete the catalogs first, since deleting attributes which are used by catalogs will cause an error
await client.DeleteCatalogs(new[] { MachineCatalog.Uuid });
await client.DeleteAttributeDefinitions(EntityDto.Catalog, new[] { MachineName.Key, MachineNumber.Key, MachineVendor.Key });
}
/// <summary>
/// Shows how to work with the attribute configuration.
/// </summary>
/// <param name="client">The client.</param>
public static async Task Lesson(DataServiceRestClient client)
{
//Create attributes
await client.CreateAttributeDefinition(Entity.Part, AttributeDefinition);
//This will create an attribute which can be used by catalogs. Don't be confused, this is no catalog attribute
await client.CreateAttributeDefinition(Entity.Catalog, CatalogColumnAttributeDefinition);
//Create a catalog which we can use for our catalog attribute
await client.CreateCatalogs(new[] { Catalog });
//Create the catalog attribute definition.
await client.CreateAttributeDefinition(Entity.Part, CatalogAttributeDefinition);
//Notes: - you can't create catalog attributes for catalogs (Entity.Catalog)
//Notes: - you must obey the shown order of commands!
//You can update everything except the key, which is the identifier.
//To change the key, you must delete and recreate the attribute, but be aware: all data stored for this attribute will be lost!
CatalogAttributeDefinition.Description = "Characteristic catalog attribute";
await client.UpdateAttributeDefinitions(Entity.Characteristic, new[] { CatalogAttributeDefinition });
//Get all attributes
var configuration = await client.GetConfiguration();
//Attributes are assigned to an entity: part, characteristic, measurement, value or catalog.
Console.WriteLine($"Attributes for part: {configuration.PartAttributes.Length}");
Console.WriteLine($"Attributes for characteristic: {configuration.CharacteristicAttributes.Length}");
Console.WriteLine($"Attributes for measurement: {configuration.MeasurementAttributes.Length}");
Console.WriteLine($"Attributes for value: {configuration.ValueAttributes.Length}");
Console.WriteLine($"Attributes for catalog: {configuration.CatalogAttributes.Length}");
}
public static async Task Lesson(DataServiceRestClient client)
{
await client.CreateParts(new[] { Part, SubPart });
await client.CreateCharacteristics(new[] { Characteristic, Child, SubChild });
//Depth null will result in a recursive search
var result = await client.GetCharacteristics(Part.Path, null);
Console.WriteLine($"Depth null: {result.Count()} characteristics");
//Depth 0 will return an empty list
result = await client.GetCharacteristics(Part.Path, 0);
Console.WriteLine($"Depth 0: {result.Count()} characteristics");
//Depth 1 will return the direct child characteristics
result = await client.GetCharacteristics(Part.Path, 1);
Console.WriteLine($"Depth 1: {result.Count()} characteristics");
//Depth 2 will return the direct children and their children, but not the children of subparts
result = await client.GetCharacteristics(Part.Path, 2);
Console.WriteLine($"Depth 2: {result.Count()} characteristics");
//Use UpdateParts and UpdateCharacteristics to rename entities, and modify their attributes
Part.Path = PathHelper.RoundtripString2PathInformation("P:/PartName2/");
await client.UpdateParts(new[] { Part });
}
public static void CheckCatalogAttribute(DataServiceRestClient client, EntityDto entity, ushort key, string description,
Guid catalog)
{
var configuration = client.GetConfiguration().Result;
var definition = configuration.GetDefinition(key);
if (definition == null)
{
client.CreateAttributeDefinition(entity, new CatalogAttributeDefinitionDto
{
Key = key,
Description = description,
Catalog = catalog
});
}
else if (configuration.GetTypeForKey(key) != entity || definition.Description != description ||
(definition as CatalogAttributeDefinitionDto)?.Catalog != catalog)
{
client.UpdateAttributeDefinitions(entity, new AbstractAttributeDefinitionDto[]
{
new CatalogAttributeDefinitionDto
{
Key = key,
Description = description,
Catalog = catalog
}
});
}
}
public static void CheckAttribute(DataServiceRestClient client, EntityDto entity, ushort key, string description,
AttributeTypeDto type)
{
var configuration = client.GetConfiguration().Result;
var definition = configuration.GetDefinition(key);
if (definition == null)
{
client.CreateAttributeDefinition(entity, new AttributeDefinitionDto
{
Key = key,
Description = description,
Type = type
});
}
else if (configuration.GetTypeForKey(key) != entity || definition.Description != description ||
(definition as AttributeDefinitionDto)?.Type != type)
{
//Don't do this, in case the PiWeb database is already in use. Changing the configuration will cause data-loss!!!
client.UpdateAttributeDefinitions(entity, new AbstractAttributeDefinitionDto[]
{
new AttributeDefinitionDto
{
Key = key,
Description = description,
Type = type
}
});
}
}
public static InspectionPlanCharacteristicDto GetOrCreateCharacteristic(DataServiceRestClient client, string partName, string characteristicName, Dictionary <string, ushort> mapping, Dictionary <string, object> values)
{
var characteristics = client.GetCharacteristics(PathHelper.String2PartPathInformation(partName), 1).Result;
var attributes = values.Select(pair => new AttributeDto(mapping[pair.Key], pair.Value)).ToArray();
var existingCharacteristic = characteristics.FirstOrDefault(p => string.Equals(p.Path.Name, characteristicName));
if (existingCharacteristic == null)
{
existingCharacteristic = new InspectionPlanCharacteristicDto
{
Path = PathHelper.RoundtripString2PathInformation("PC:/" + partName + " / " + characteristicName + "/"),
Uuid = Guid.NewGuid(),
Attributes = attributes
};
client.CreateCharacteristics(new[]
{
existingCharacteristic
}).Wait();
}
else
{
existingCharacteristic.Attributes = attributes;
//maybe update the existing characteristic, so the attributes are up-to-date
client.UpdateCharacteristics(new[]
{
existingCharacteristic
}).Wait();
}
return(existingCharacteristic);
}
public static async Task Lesson(DataServiceRestClient client)
{
//The statistics in serviceInformation are calculated periodically by the server, and are not guaranteed to be always exact.
var info = await client.GetServiceInformation();
Console.WriteLine(info.ServerName);
}
private static void ExportToPiWeb(string serverUri, string inspectionName, IEnumerable <Characteristic> data,
Dictionary <string, ushort> attributeMapping)
{
//1. Create the client
var client = new DataServiceRestClient(new Uri(serverUri));
//2. Check the server configuration
foreach (var entry in attributeMapping)
{
Configuration.CheckAttribute(client, EntityDto.Characteristic, entry.Value, entry.Key, AttributeTypeDto.Float);
}
//2.1 Make sure the essential time and value attributes are present
Configuration.CheckAttribute(client, EntityDto.Measurement, WellKnownKeys.Measurement.Time, "Time",
AttributeTypeDto.DateTime);
Configuration.CheckAttribute(client, EntityDto.Value, WellKnownKeys.Value.MeasuredValue, "Value", AttributeTypeDto.Float);
//3. Check the inspection plan
//3.1 Check the inspection plan part
var part = InspectionPlan.GetOrCreatePart(client, inspectionName);
var characteristicMapping = new Dictionary <Characteristic, InspectionPlanCharacteristicDto>();
//3.2 Check the inspection plan characteristics
foreach (var characteristic in data)
{
var inspectionPlanCharacteristic = InspectionPlan.GetOrCreateCharacteristic(client, part.Path.Name,
characteristic.Name, attributeMapping, characteristic.Attributes);
characteristicMapping.Add(characteristic, inspectionPlanCharacteristic);
}
//4. Create the measurement
var dataCharacteristics = characteristicMapping.Select(pair => new DataCharacteristicDto
{
Uuid = pair.Value.Uuid,
Path = pair.Value.Path,
Value = new DataValueDto
{
Attributes = new[] { new AttributeDto(1, pair.Key.Value) }
}
}).ToArray();
var measurement = new DataMeasurementDto
{
Uuid = Guid.NewGuid(),
PartUuid = part.Uuid,
Time = DateTime.UtcNow,
Attributes = new[] { new AttributeDto(WellKnownKeys.Measurement.Time, DateTime.UtcNow) },
Characteristics = dataCharacteristics
};
//4.1 Write the measurement to the database
client.CreateMeasurementValues(new[] { measurement }).Wait();
}
public static async Task Lesson(DataServiceRestClient client, RawDataServiceRestClient rawClient)
{
await client.CreateParts(new[] { Part });
//PiWeb only accepts binary data
var data = Encoding.UTF8.GetBytes("Hello RawDataService!");
var target = RawDataTargetEntityDto.CreateForPart(Part.Uuid);
//Notes: - see e.g. http://wiki.selfhtml.org/wiki/Referenz:MIME-Typen for a complete list of mime types
// - When using Key = -1, the server will generate a new key. The generated key can be read from the result.
var createdRawDataInfo = await rawClient.CreateRawData(new RawDataInformationDto
{
FileName = "Hello.txt",
MimeType = "text/plain",
Key = -1,
Created = DateTime.Now,
LastModified = DateTime.Now,
MD5 = new Guid(MD5.Create().ComputeHash(data)),
Size = data.Length,
Target = target
}, data);
Console.WriteLine($"RawData created with key: {createdRawDataInfo.Key}");
//We can simply update raw data information like filename or MIME-type
if (createdRawDataInfo.Key.HasValue)
{
createdRawDataInfo.FileName = "HelloEdit.txt";
Console.WriteLine($"Renaming raw data file to {createdRawDataInfo.FileName}");
await rawClient.UpdateRawDataInformation(target, createdRawDataInfo.Key.Value, createdRawDataInfo);
}
var rawDataInformation = await rawClient.ListRawData(new[] { target });
foreach (var information in rawDataInformation)
{
Console.WriteLine($"Fetching {information.FileName}: {information.Size} bytes");
//Fetch the data by providing the correct RawDataInformation
data = await rawClient.GetRawData(information);
Console.WriteLine($"Content: {Encoding.UTF8.GetString( data )}");
//We can use the key we found with the ListRawData function to delete a single file
await rawClient.DeleteRawDataForPart(Part.Uuid, information.Key);
}
//Or we simply delete all raw data for a certain entity
await rawClient.DeleteRawDataForPart(Part.Uuid);
}
public static async Task UndoLesson(DataServiceRestClient client)
{
//Delete attributes
await client.DeleteAttributeDefinitions(Entity.Part, new[] { AttributeDefinition.Key });
await client.DeleteAttributeDefinitions(Entity.Characteristic, new[] { CatalogAttributeDefinition.Key });
await client.DeleteAttributeDefinitions(Entity.Catalog, new[] { CatalogColumnAttributeDefinition.Key });
//Delete catalogs
await client.DeleteCatalogs(new[] { Catalog.Uuid });
}
public static async Task UndoLesson(DataServiceRestClient client)
{
await client.DeleteMeasurementsByUuid(new[] { Measurement.Uuid });
//The server can be configured to allow or disallow deleting of parts with measurements
await client.DeleteCharacteristics(new[] { Characteristic.Uuid });
await client.DeleteParts(new[] { Part.Uuid });
await client.DeleteAttributeDefinitions(EntityDto.Measurement, new[] { MeasurementAttributeDefinition.Key });
await client.DeleteAttributeDefinitions(EntityDto.Value, new[] { ValueAttributeDefinition.Key });
}
public async Task RequestConfiguration()
{
// given
using var server = WebServer.StartNew(Port);
using var client = new DataServiceRestClient(Uri);
var config = Fixture.Create <ConfigurationDto>();
server.RegisterReponse("/DataServiceRest/configuration", JsonConvert.SerializeObject(config));
// when
var result = await client.GetConfiguration();
// then
Assert.That(JsonConvert.SerializeObject(result), Is.EqualTo(JsonConvert.SerializeObject(config)));
}
public static InspectionPlanPartDto GetOrCreatePart(DataServiceRestClient client, string name)
{
var parts = client.GetParts(PathInformationDto.Root, null, 1).Result;
var existingPart = parts.FirstOrDefault(p => string.Equals(p.Path.Name, name));
if (existingPart == null)
{
existingPart = new InspectionPlanPartDto
{
Path = PathHelper.String2PartPathInformation(name),
Uuid = Guid.NewGuid()
};
client.CreateParts(new[]
{
existingPart
}).Wait();
}
return(existingPart);
}
static void Main( )
{
var client = new DataServiceRestClient(new System.Uri("http://127.0.0.1:8080/"));
var rawDataClient = new RawDataServiceRestClient(new System.Uri("http://127.0.0.1:8080/"));
ServiceInformation.Lesson(client).Wait();
Configuration.Lesson(client).Wait();
Configuration.UndoLesson(client).Wait();
Catalogs.Lesson(client).Wait();
Catalogs.UndoLesson(client).Wait();
InspectionPlan.Lesson(client).Wait();
InspectionPlan.UndoLesson(client).Wait();
Measurements.Lesson(client).Wait();
Measurements.UndoLesson(client).Wait();
RawData.Lesson(client, rawDataClient).Wait();
RawData.UndoLesson(client, rawDataClient).Wait();
}
public static async Task Lesson(DataServiceRestClient client)
{
//A catalog must have at least one attribute.
//Attributes with entity 'Catalog' must not be of type 'CatalogAttribute'
await client.CreateAttributeDefinitions(EntityDto.Catalog, new[] { MachineName, MachineNumber, MachineVendor });
//Create the catalog
await client.CreateCatalogs(new[] { MachineCatalog });
//Add an attribute
MachineCatalog.ValidAttributes = MachineCatalog.ValidAttributes.Append(MachineVendor.Key);
await client.UpdateCatalogs(new[] { MachineCatalog });
//Add an entry
await client.CreateCatalogEntries(MachineCatalog.Uuid, new[] { EntryXenos });
//Update existing catalog entries
EntryAccura.Attributes = EntryAccura.Attributes.Append(new AttributeDto(MachineVendor.Key, "Zeiss"));
EntryContura.Attributes = EntryContura.Attributes.Append(new AttributeDto(MachineVendor.Key, "Zeiss"));
await client.UpdateCatalogs(new[] { MachineCatalog });
}
private async void checkConnect2PiWebServer()
{
_ServerUri = new Uri(PiWebHost_Data["Main"].ToString());
_RestDataServiceClient = new DataServiceRestClient(_ServerUri);
await CheckConnection();
}
public static async Task UndoLesson(DataServiceRestClient client, RawDataServiceRestClient rawClient)
{
await client.DeleteParts(new[] { Part.Uuid });
}
public static async Task Lesson(DataServiceRestClient client)
{
//Create the most commonly used attributes for measurement and measurement value
var configuration = await client.GetConfiguration();
if (configuration.GetDefinition(EntityDto.Measurement, MeasurementAttributeDefinition.Key) == null)
{
await client.CreateAttributeDefinition(EntityDto.Measurement, MeasurementAttributeDefinition);
}
if (configuration.GetDefinition(EntityDto.Value, ValueAttributeDefinition.Key) == null)
{
await client.CreateAttributeDefinition(EntityDto.Value, ValueAttributeDefinition);
}
//Every measurement is attached to a part, and every value is attached to a characteristic
await client.CreateParts(new[] { Part });
await client.CreateCharacteristics(new[] { Characteristic });
//The function 'CreateMeasurements' will create measurements without any values. You'll much more likely use the 'CreateMeasurementValues' function
await client.CreateMeasurementValues(new[] { Measurement });
Value.Value = new DataValueDto(0.0) //This will result in an unmeasured characteristic, because the attribute array doesn't contain K1
{
Attributes = new AttributeDto[] { }
};
await client.UpdateMeasurementValues(new[] { Measurement });
Value.Value = new DataValueDto //this will work!
{
Attributes = new[] { new AttributeDto(ValueAttributeDefinition.Key, 0.5) }
};
await client.UpdateMeasurementValues(new[] { Measurement });
var result = await client.GetMeasurementValues(
PathInformationDto.Root, // Part where to search measurements
new MeasurementValueFilterAttributesDto
{
AggregationMeasurements = AggregationMeasurementSelectionDto.All, // Decide how to include aggregated measurements in your query
CharacteristicsUuidList = null, // Use characteristic uuids to fetch single measurement values
Deep = true, // A deep search will find measurements recursively below the start path
FromModificationDate = null, // Will only search measurements with a modification date (LastModified) newer than the specified one
ToModificationDate = null, // Will only search measurements with a modification date (LastModified) older than the specified one
LimitResult = 10, // Will limit the number of returned measurements
MeasurementUuids = null, // Use measurement uuids to search for specific measurements
OrderBy = new[] // Order the returned measurements by specific attributes
{
new OrderDto(WellKnownKeys.Measurement.Time, OrderDirectionDto.Asc, EntityDto.Measurement)
},
RequestedMeasurementAttributes = null, // Specify, which measurement attributes should be returned (default: all)
RequestedValueAttributes = null, // Specify, which value attributes should be returned (default: all)
SearchCondition = new GenericSearchAttributeConditionDto // You can create more complex attribute conditions using the GenericSearchAnd, GenericSearchOr and GenericSearchNot class
{
Attribute = WellKnownKeys.Measurement.Time, //Only measurement attributes are supported
Operation = OperationDto.GreaterThan,
Value = XmlConvert.ToString(DateTime.UtcNow - TimeSpan.FromDays(2), XmlDateTimeSerializationMode.Utc)
}
});
foreach (var measurement in result)
{
Console.WriteLine(measurement.ToString());
}
}
public static async Task UndoLesson(DataServiceRestClient client)
{
await client.DeleteParts(new[] { Part.Uuid });
await client.DeleteCharacteristics(new[] { Characteristic.Uuid, Child.Uuid });
}
