private void AddDefault <T>(InMemoryRecord amplaRecord, string field, T defaultValue)
{
if (amplaRecord.Find(field) == null)
{
amplaRecord.SetFieldValue(field, defaultValue);
}
}
public void SaveUsingModelClass()
{
ProductionModel model = new ProductionModel {
Location = location
};
DateTime before = DateTime.UtcNow.AddSeconds(-1);
dynamic record = ViewPoint.Save(model);
DateTime after = before.AddSeconds(5);
Assert.That((object)record, Is.Not.Null);
Assert.That(record.Location, Is.EqualTo(location));
Assert.That(record.Id, Is.GreaterThan(0));
Assert.That(Records, Is.Not.Empty);
InMemoryRecord amplaRecord = Records[0];
Assert.That(amplaRecord, Is.Not.Null);
Assert.That(amplaRecord.Location, Is.EqualTo(location));
Assert.That(amplaRecord.Module, Is.EqualTo(module));
Assert.That(amplaRecord.GetFieldValue("Sample Period", DateTime.MinValue), Is.InRange(before, after));
}
public void SubmitWithNullFields()
{
SimpleEnergyModel model = new SimpleEnergyModel
{
Location = location,
StartTime = DateTime.Now,
CauseLocation = null,
Cause = null,
Classification = null
};
Repository.Add(model);
Assert.That(model.Id, Is.GreaterThan(0));
Assert.That(Records, Is.Not.Empty);
InMemoryRecord record = Records[0];
Assert.That(record.Location, Is.EqualTo(location));
Assert.That(record.Module, Is.EqualTo(module));
Assert.That(record.GetFieldValue("Start Time", DateTime.MinValue), Is.GreaterThan(DateTime.MinValue));
Assert.That(record.Find("Cause Location"), Is.Null);
Assert.That(record.Find("Cause"), Is.Null);
Assert.That(record.Find("Classification"), Is.Null);
}
private DataSubmissionResult UpdateDataRecord(SubmitDataRecord submitDataRecord, string user)
{
int recordId = (int)submitDataRecord.MergeCriteria.SetId;
Dictionary <int, InMemoryRecord> database = amplaDatabase.GetModuleRecords(submitDataRecord.Module.ToString());
InMemoryRecord record = FindRecord(database, submitDataRecord.Location, submitDataRecord.Module, recordId);
DateTime editTime = DateTime.UtcNow;
foreach (Field field in submitDataRecord.Fields)
{
string oldValue = string.Empty;
FieldValue fieldValue = record.Find(field.Name);
if (fieldValue == null)
{
record.Fields.Add(new FieldValue(field.Name, field.Value));
}
else
{
oldValue = fieldValue.Value;
fieldValue.Value = field.Value;
}
AddAuditRecord(record, editTime, field.Name, oldValue, field.Value, user);
}
return(new DataSubmissionResult
{
RecordAction = RecordAction.Update,
SetId = recordId
});
}
public void ConfirmModel()
{
Assert.That(Records, Is.Empty);
AreaValueModel model = new AreaValueModel {
Area = "ROM", Value = 100
};
Repository.Add(model);
Assert.That(Records, Is.Not.Empty);
InMemoryRecord record = Records[0];
Assert.That(record.RecordId, Is.GreaterThan(0));
Assert.That(record.IsConfirmed(), Is.False);
Assert.That(model.Id, Is.EqualTo(record.RecordId));
AreaValueModel confirmModel = Repository.FindById(model.Id);
Assert.That(confirmModel, Is.Not.Null);
Repository.Confirm(confirmModel);
Assert.That(Records.Count, Is.EqualTo(1));
record = Records[0];
Assert.That(record.RecordId, Is.EqualTo(confirmModel.Id));
Assert.That(record.IsConfirmed(), Is.True);
}
public void GetViaModel()
{
DateTime before = DateTime.Now.AddMinutes(-1);
DateTime after = DateTime.Now.AddMinutes(+1);
LocationModel model = new LocationModel {
Location = Locations[1]
};
Repository.Add(model);
Assert.That(model.Id, Is.GreaterThan(0));
Assert.That(Records, Is.Not.Empty);
InMemoryRecord record = Records[0];
Assert.That(record.Location, Is.EqualTo(Locations[1]));
Assert.That(record.Module, Is.EqualTo("Production"));
Assert.That(record.GetFieldValue("Sample Period", DateTime.MinValue), Is.InRange(before.ToUniversalTime(), after.ToUniversalTime()));
LocationModel getModel = Repository.FindById(model.Id);
Assert.That(getModel.Sample, Is.InRange(before, after));
Assert.That(getModel.Location, Is.EqualTo(Locations[1]));
}
private DataSubmissionResult InsertDataRecord(SubmitDataRecord submitDataRecord, string user)
{
string module = submitDataRecord.Module.ToString();
Dictionary <int, InMemoryRecord> database = amplaDatabase.GetModuleRecords(module);
int setId = amplaDatabase.GetNewSetId(module);
setId++;
GetView view = amplaConfiguration.GetViewForLocation(module, submitDataRecord.Location);
InMemoryRecord amplaRecord = new InMemoryRecord(view)
{
Location = submitDataRecord.Location,
Module = module,
RecordId = setId
};
foreach (Field field in submitDataRecord.Fields)
{
amplaRecord.Fields.Add(new FieldValue(field.Name, field.Value));
}
AddDefaultFields(amplaRecord, user);
database[setId] = amplaRecord;
return(new DataSubmissionResult
{
RecordAction = RecordAction.Insert,
SetId = setId
});
}
/// <summary>
/// Updates the record status.
/// </summary>
/// <param name="request">The request.</param>
/// <returns></returns>
public UpdateRecordStatusResponse UpdateRecordStatus(UpdateRecordStatusRequest request)
{
return(TryCatchThrowFault(() =>
{
List <UpdateRecordStatusResult> results = new List <UpdateRecordStatusResult>();
CheckCredentials(request.Credentials);
foreach (UpdateRecordStatus recordStatus in request.UpdateRecords)
{
string module = recordStatus.Module.ToString();
Dictionary <int, InMemoryRecord> database = amplaDatabase.GetModuleRecords(module);
CheckReportingPoint(module, recordStatus.Location);
int recordId = (int)recordStatus.MergeCriteria.SetId;
InMemoryRecord record = FindRecord(database, recordStatus.Location, recordStatus.Module, recordId);
FieldValue confirmed = record.Find("Confirmed");
if (confirmed != null)
{
record.Fields.Remove(confirmed);
}
string value = recordStatus.RecordAction == UpdateRecordStatusAction.Confirm ? "True" : "False";
record.Fields.Add(new FieldValue("Confirmed", value));
results.Add(new UpdateRecordStatusResult
{
Location = recordStatus.Location,
Module = recordStatus.Module,
RecordAction = recordStatus.RecordAction,
SetId = recordId
});
}
return new UpdateRecordStatusResponse {
UpdateRecordStatusResults = results.ToArray()
};
}));
}
public void RecordUsesUtcTime()
{
Assert.That(Records, Is.Empty);
DateTime beforeUtc = DateTime.UtcNow.AddMinutes(-5);
DateTime afterUtc = DateTime.UtcNow.AddMinutes(+5);
DateTime beforeLocal = beforeUtc.ToLocalTime();
DateTime afterLocal = afterUtc.ToLocalTime();
AreaValueModel model = new AreaValueModel {
Area = "ROM", Value = 100
};
Repository.Add(model);
Assert.That(Records, Is.Not.Empty);
InMemoryRecord record = Records[0];
Assert.That(record.Location, Is.EqualTo(location));
Assert.That(record.RecordId, Is.GreaterThan(0));
Assert.That(record.GetFieldValue("Area", ""), Is.EqualTo("ROM"));
Assert.That(record.GetFieldValue <double>("Value", 0), Is.EqualTo(100.0d));
Assert.That(record.GetFieldValue("Sample Period", DateTime.MinValue),
Is.GreaterThan(beforeUtc).And.LessThan(afterUtc));
Assert.That(model.Id, Is.EqualTo(record.RecordId));
AreaValueModel updated = Repository.FindById(record.RecordId);
Assert.That(updated.Sample, Is.GreaterThan(beforeLocal).And.LessThan(afterLocal));
}
public void ModelsUseLocalTime()
{
Assert.That(Records, Is.Empty);
DateTime localHour = DateTime.Now.TrimToHour();
AreaValueModel model = new AreaValueModel {
Area = "ROM", Value = 100, Sample = localHour
};
DateTime utcHour = localHour.ToUniversalTime();
Repository.Add(model);
Assert.That(Records, Is.Not.Empty);
InMemoryRecord record = Records[0];
Assert.That(record.Location, Is.EqualTo(location));
Assert.That(record.RecordId, Is.GreaterThan(0));
Assert.That(record.GetFieldValue("Area", ""), Is.EqualTo("ROM"));
Assert.That(record.GetFieldValue <double>("Value", 0), Is.EqualTo(100.0d));
Assert.That(record.GetFieldValue("Sample Period", DateTime.MinValue), Is.EqualTo(utcHour));
Assert.That(model.Id, Is.EqualTo(record.RecordId));
AreaValueModel updated = Repository.FindById(record.RecordId);
Assert.That(updated.Sample, Is.EqualTo(localHour));
}
public void SubmitWithBasicFields()
{
SimplePlanningModel model = new SimplePlanningModel
{
Location = location,
PlannedStart = DateTime.Today,
PlannedEnd = DateTime.Today.AddDays(1),
State = "Available",
ActivityId = "ABC-123"
};
Repository.Add(model);
Assert.That(model.Id, Is.GreaterThan(0));
Assert.That(Records, Is.Not.Empty);
InMemoryRecord record = Records[0];
Assert.That(record.Location, Is.EqualTo(location));
Assert.That(record.Module, Is.EqualTo(module));
Assert.That(record.GetFieldValue("Planned Start Time", DateTime.MinValue), Is.EqualTo(DateTime.Today.ToUniversalTime()));
Assert.That(record.GetFieldValue("Planned End Time", DateTime.MinValue), Is.EqualTo(DateTime.Today.AddDays(1).ToUniversalTime()));
Assert.That(record.Find("State"), Is.Null);
Assert.That(record.GetFieldValue("ActivityId", ""), Is.EqualTo("ABC-123"));
}
public void CreatedByDefault()
{
SimpleDataWebServiceClient webServiceClient = Create();
InMemoryRecord record = ProductionRecords.NewRecord().MarkAsNew();
SubmitDataRequest request = new SubmitDataRequest
{
Credentials = CreateCredentials(),
SubmitDataRecords = new[]
{
record.ConvertToSubmitDataRecord()
}
};
DateTime before = DateTime.Now.AddSeconds(-10).ToUniversalTime();
DateTime after = before.AddSeconds(+20);
SubmitDataResponse response = webServiceClient.SubmitData(request);
Assert.That(response, Is.Not.Null);
Assert.That(DatabaseRecords.Count, Is.EqualTo(1));
InMemoryRecord inserted = DatabaseRecords[0];
Assert.That(inserted.GetFieldValue("CreatedBy", "null"), Is.EqualTo("User"));
Assert.That(inserted.GetFieldValue("CreatedDateTime", DateTime.MinValue), Is.InRange(before, after));
}
public void GetAuditDataWithARecordWithNoChanges()
{
SimpleDataWebServiceClient webServiceClient = Create();
InMemoryRecord record = ProductionRecords.NewRecord().MarkAsNew();
SubmitDataRequest submitRequest = new SubmitDataRequest
{
Credentials = CreateCredentials(),
SubmitDataRecords = new[]
{
record.ConvertToSubmitDataRecord()
}
};
webServiceClient.SubmitData(submitRequest);
Assert.That(DatabaseRecords, Is.Not.Empty);
int recordId = DatabaseRecords[0].RecordId;
GetAuditDataRequest request = new GetAuditDataRequest
{
Credentials = CreateCredentials(),
Filter = new GetAuditDataFilter {
Location = location, Module = AmplaModules.Production, SetId = Convert.ToString(recordId)
}
};
GetAuditDataResponse response = webServiceClient.GetAuditData(request);
Assert.That(response.RowSets, Is.Not.Empty);
Assert.That(response.RowSets[0].Rows, Is.Empty);
}
public void CreatedBySetInRequest()
{
SimpleDataWebServiceClient webServiceClient = Create();
InMemoryRecord record = ProductionRecords.NewRecord().MarkAsNew();
record.SetFieldValue("CreatedBy", "UnitTests");
record.SetFieldValue("CreatedDateTime", DateTime.Today);
SubmitDataRequest request = new SubmitDataRequest
{
Credentials = CreateCredentials(),
SubmitDataRecords = new[]
{
record.ConvertToSubmitDataRecord()
}
};
SubmitDataResponse response = webServiceClient.SubmitData(request);
Assert.That(response, Is.Not.Null);
Assert.That(DatabaseRecords.Count, Is.EqualTo(1));
InMemoryRecord inserted = DatabaseRecords[0];
Assert.That(inserted.GetFieldValue("CreatedBy", "null"), Is.EqualTo("UnitTests"));
Assert.That(inserted.GetFieldValue("CreatedDateTime", DateTime.MinValue), Is.EqualTo(DateTime.Today.ToUniversalTime()));
}
/// <summary>
/// Deletes the records.
/// </summary>
/// <param name="request">The request.</param>
/// <returns></returns>
public DeleteRecordsResponse DeleteRecords(DeleteRecordsRequest request)
{
return(TryCatchThrowFault(() =>
{
DateTime editTime = DateTime.Now;
List <DeleteRecordsResult> results = new List <DeleteRecordsResult>();
string user = CheckCredentials(request.Credentials);
foreach (DeleteRecord deleteRecord in request.DeleteRecords)
{
Dictionary <int, InMemoryRecord> database = amplaDatabase.GetModuleRecords(deleteRecord.Module.ToString());
CheckReportingPoint(deleteRecord.Module.ToString(), deleteRecord.Location);
int recordId = (int)deleteRecord.MergeCriteria.SetId;
InMemoryRecord record = FindRecord(database, deleteRecord.Location, deleteRecord.Module, recordId);
FieldValue deleted = record.Find("Deleted");
if (deleted != null)
{
record.Fields.Remove(deleted);
}
record.Fields.Add(new FieldValue("Deleted", "True"));
AddAuditRecord(record, editTime, "IsDeleted", false.ToString(), true.ToString(), user);
results.Add(new DeleteRecordsResult
{
Location = deleteRecord.Location,
Module = deleteRecord.Module,
RecordAction = DeleteRecordsAction.Delete,
SetId = recordId
});
}
return new DeleteRecordsResponse {
DeleteRecordsResults = results.ToArray()
};
}));
}
public override bool Matches(InMemoryRecord record)
{
if (filters.Any(filter => !filter.Matches(record)))
{
return(false);
}
return(filters.Count > 0);
}
public void DuplicateLocationBug()
{
InMemoryRecord record = ProductionRecords.NewRecord();
Assert.That(record.Location, Is.EqualTo(location));
Assert.That(record.Fields.Count(field => field.Name == "Location"), Is.EqualTo(1));
InMemoryRecord clone = record.Clone();
Assert.That(clone.Location, Is.EqualTo(location));
Assert.That(clone.Fields.Count(field => field.Name == "Location"), Is.EqualTo(1));
}
public void GetAuditDataWithARecordWithChanges()
{
SimpleDataWebServiceClient webServiceClient = Create();
InMemoryRecord record = ProductionRecords.NewRecord().MarkAsNew();
record.SetFieldValue("Field 1", 150);
SubmitDataRequest submitRequest = new SubmitDataRequest
{
Credentials = CreateCredentials(),
SubmitDataRecords = new[]
{
record.ConvertToSubmitDataRecord()
}
};
webServiceClient.SubmitData(submitRequest);
Assert.That(DatabaseRecords, Is.Not.Empty);
int recordId = DatabaseRecords[0].RecordId;
InMemoryRecord updateRecord = new InMemoryRecord(ProductionViews.StandardView())
{
Location = record.Location,
Module = record.Module,
RecordId = recordId
};
updateRecord.SetFieldValue("Field 1", 200);
SubmitDataRequest update = new SubmitDataRequest
{
Credentials = CreateCredentials(),
SubmitDataRecords = new[]
{
updateRecord.ConvertToSubmitDataRecord()
}
};
webServiceClient.SubmitData(update);
GetAuditDataRequest request = new GetAuditDataRequest
{
Credentials = CreateCredentials(),
Filter = new GetAuditDataFilter {
Location = location, Module = AmplaModules.Production, SetId = Convert.ToString(recordId)
}
};
GetAuditDataResponse response = webServiceClient.GetAuditData(request);
AssertAuditTableContains(response, location, recordId, "Field 1", "150", "200");
}
public static InMemoryRecord NewRecord()
{
InMemoryRecord record = new InMemoryRecord { Location = "Enterprise.Site.Area.Downtime", Module = "Downtime" };
record.SetFieldValue("IsManual", false);
record.SetFieldValue("Deleted", false);
record.SetFieldValue("Confirmed", false);
record.SetFieldValue("Start Time", DateTime.Now.TrimToSeconds());
record.SetFieldValue("Duration", 90);
record.RecordId = _recordId++;
return record;
}
public void NormalRecord()
{
InMemoryRecord record = ProductionRecords.NewRecord();
Assert.That(record, Is.Not.Null);
Assert.That(record.Module, Is.EqualTo(module));
Assert.That(record.Location, Is.EqualTo(location));
InMemoryRecord newRecord = ProductionRecords.NewRecord();
Assert.That(record.RecordId, Is.Not.EqualTo(newRecord.RecordId));
}
public void Update()
{
SimpleDataWebServiceClient webServiceClient = Create();
InMemoryRecord record = ProductionRecords.NewRecord().MarkAsNew();
InMemoryRecord update = record.Clone();
update.Fields.Clear();
update.Location = record.Location;
update.Fields.Add(new FieldValue("New Field", "100"));
SubmitDataRequest request = new SubmitDataRequest
{
Credentials = CreateCredentials(),
SubmitDataRecords = new[]
{
record.ConvertToSubmitDataRecord()
}
};
SubmitDataResponse response = webServiceClient.SubmitData(request);
Assert.That(response.DataSubmissionResults, Is.Not.Null);
Assert.That(response.DataSubmissionResults.Length, Is.EqualTo(1));
Assert.That(response.DataSubmissionResults[0].RecordAction, Is.EqualTo(RecordAction.Insert));
Assert.That(response.DataSubmissionResults[0].SetId, Is.GreaterThan(100));
Assert.That(DatabaseRecords.Count, Is.EqualTo(1));
Assert.That(DatabaseRecords[0].Find("New Field"), Is.Null);
update.RecordId = (int)response.DataSubmissionResults[0].SetId;
request = new SubmitDataRequest
{
Credentials = CreateCredentials(),
SubmitDataRecords = new[]
{
update.ConvertToSubmitDataRecord()
}
};
response = webServiceClient.SubmitData(request);
Assert.That(response.DataSubmissionResults, Is.Not.Null);
Assert.That(response.DataSubmissionResults.Length, Is.EqualTo(1));
Assert.That(response.DataSubmissionResults[0].RecordAction, Is.EqualTo(RecordAction.Update));
Assert.That(response.DataSubmissionResults[0].SetId, Is.EqualTo(update.RecordId));
Assert.That(DatabaseRecords.Count, Is.EqualTo(1));
Assert.That(DatabaseRecords[0].Find("New Field"), Is.Not.Null);
Assert.That(DatabaseRecords[0].Find("New Field").Value, Is.EqualTo("100"));
}
public static InMemoryRecord NewRecord()
{
InMemoryRecord record = new InMemoryRecord { Location = "Enterprise.Site.Area.Production", Module = "Production" };
record.SetFieldValue("IsManual", false);
record.SetFieldValue("Deleted", false);
record.SetFieldValue("Confirmed", false);
record.SetFieldValue("Sample Period", DateTime.Now.TrimToSeconds());
record.SetFieldValue("Duration", 90);
record.SetFieldValue("Field 1", 100);
record.SetFieldValue("Unique", Guid.NewGuid());
record.RecordId = _recordId++;
return record;
}
public int AddExistingRecord(InMemoryRecord record)
{
string module = record.Module;
int newSetId = amplaDatabase.GetNewSetId(module);
Dictionary <int, InMemoryRecord> database = amplaDatabase.GetModuleRecords(module);
InMemoryRecord clone = record.Clone();
clone.RecordId = newSetId;
database[newSetId] = clone;
return(newSetId);
}
public void GetDataReturnsLocation()
{
SimpleDataWebServiceClient webServiceClient = new SimpleDataWebServiceClient(
database, configuration, new SimpleSecurityWebServiceClient("User"));
InMemoryRecord record = ProductionRecords.NewRecord().MarkAsNew();
SubmitDataRequest submitRequest = new SubmitDataRequest
{
Credentials = CreateCredentials(),
SubmitDataRecords = new[]
{
record.ConvertToSubmitDataRecord()
}
};
SubmitDataResponse submitResponse = webServiceClient.SubmitData(submitRequest);
Assert.That(submitResponse.DataSubmissionResults, Is.Not.Null);
Assert.That(submitResponse.DataSubmissionResults.Length, Is.EqualTo(1));
Assert.That(submitResponse.DataSubmissionResults[0].RecordAction, Is.EqualTo(RecordAction.Insert));
Assert.That(submitResponse.DataSubmissionResults[0].SetId, Is.GreaterThan(100));
string recordId = Convert.ToString(submitResponse.DataSubmissionResults[0].SetId);
Assert.That(DatabaseRecords.Count, Is.EqualTo(1));
Assert.That(DatabaseRecords[0].Location, Is.EqualTo(location));
GetDataRequest request = new GetDataRequest
{
Credentials = CreateCredentials(),
Filter = new DataFilter {
Location = record.Location, Criteria = new[] { new FilterEntry {
Name = "Id", Value = recordId
} }
},
View = new GetDataView {
Context = NavigationContext.Plant, Mode = NavigationMode.Location, Module = AmplaModules.Production
},
Metadata = true,
OutputOptions = new GetDataOutputOptions {
ResolveIdentifiers = false
},
};
GetDataResponse response = webServiceClient.GetData(request);
AssertResponseContainsValue(response, "Duration", "90");
AssertResponseContainsValue(response, "Location", location);
}
public static InMemoryRecord NewRecord()
{
InMemoryRecord record = new InMemoryRecord(MaintenanceViews.StandardView())
{
Location = "Enterprise.Site.Area.Maintenance", Module = "Maintenance"
};
record.SetFieldValue("IsManual", false);
record.SetFieldValue("Deleted", false);
record.SetFieldValue("Confirmed", false);
record.SetFieldValue("Sample Period", DateTime.Now.TrimToSeconds());
record.SetFieldValue("Duration", 90);
record.RecordId = _recordId++;
return(record);
}
public void GetVersion_NotRelevantChanges()
{
Assert.That(Records, Is.Empty);
AreaValueModel model = new AreaValueModel {
Area = "ROM", Value = 100
};
Repository.Add(model);
Assert.That(Records.Count, Is.EqualTo(1));
int recordId = Records[0].RecordId;
InMemoryRecord record = new InMemoryRecord(ProductionViews.AreaValueModelView())
{
Module = module,
Location = location,
RecordId = recordId
};
record.SetFieldValue("Sample Period", DateTime.Today);
UpdateRecord(record);
Assert.That(Records.Count, Is.EqualTo(1));
Assert.That(Records[0].GetFieldValue("Sample Period", DateTime.MinValue), Is.EqualTo(DateTime.Today.ToUniversalTime()));
ModelVersions versions = Repository.GetVersions(model.Id);
Assert.That(versions, Is.Not.Null);
Assert.That(versions.Versions, Is.Not.Empty);
Assert.That(versions.Versions.Count, Is.EqualTo(2)); // one version change ('Sample Period') is not relevant
ModelVersion <AreaValueModel> last = (ModelVersion <AreaValueModel>)versions.Versions[0];
ModelVersion <AreaValueModel> current = (ModelVersion <AreaValueModel>)versions.Versions[1];
Assert.That(last.Model, Is.Not.Null);
Assert.That(last.IsCurrentVersion, Is.False);
Assert.That(last.Model.Id, Is.EqualTo(model.Id));
Assert.That(last.Model.Value, Is.EqualTo(model.Value));
Assert.That(last.Model.Area, Is.EqualTo(model.Area));
Assert.That(current.Model, Is.Not.Null);
Assert.That(current.IsCurrentVersion, Is.True);
Assert.That(current.Model.Id, Is.EqualTo(model.Id));
Assert.That(current.Model.Value, Is.EqualTo(model.Value));
Assert.That(current.Model.Area, Is.EqualTo(model.Area));
}
protected int UpdateRecord(InMemoryRecord record)
{
SubmitDataRequest request = new SubmitDataRequest
{
Credentials = new Credentials {
Username = "******", Password = "******"
},
SubmitDataRecords = new[] { record.ConvertToSubmitDataRecord() }
};
SubmitDataResponse response = webServiceClient.SubmitData(request);
Assert.That(response.DataSubmissionResults, Is.Not.Empty);
Assert.That(response.DataSubmissionResults[0].RecordAction, Is.EqualTo(RecordAction.Update), "Expected an Update to occur");
return((int)response.DataSubmissionResults[0].SetId);
}
public void SubmitWithCauseAsString()
{
SimpleEnergyModel model = new SimpleEnergyModel {
Location = location, StartTime = DateTime.Now, Cause = "Broken"
};
Repository.Add(model);
Assert.That(model.Id, Is.GreaterThan(0));
Assert.That(Records, Is.Not.Empty);
InMemoryRecord record = Records[0];
Assert.That(record.Location, Is.EqualTo(location));
Assert.That(record.Find("Cause"), Is.Null);
}
public void SubmitWithClassificationAsString()
{
SimpleEnergyModel model = new SimpleEnergyModel {
Location = location, StartTime = DateTime.Now, Classification = "Unplanned Process"
};
Repository.Add(model);
Assert.That(model.Id, Is.GreaterThan(0));
Assert.That(Records, Is.Not.Empty);
InMemoryRecord record = Records[0];
Assert.That(record.Location, Is.EqualTo(location));
Assert.That(record.Find("Classification"), Is.Null);
}
public void SubmitWithClassification()
{
IdentifierEnergyModel model = new IdentifierEnergyModel {
Location = location, StartTime = DateTime.Now, Classification = 200
};
Repository.Add(model);
Assert.That(model.Id, Is.GreaterThan(0));
Assert.That(Records, Is.Not.Empty);
InMemoryRecord record = Records[0];
Assert.That(record.Location, Is.EqualTo(location));
Assert.That(record.GetFieldValue("Classification", -1), Is.EqualTo(200));
}
public static InMemoryRecord NewRecord()
{
InMemoryRecord record = new InMemoryRecord(MetricsViews.StandardView())
{
Location = "Enterprise.Site.Area.Metrics",
Module = "Metrics"
};
record.SetFieldValue("IsManual", false);
record.SetFieldValue("Deleted", false);
record.SetFieldValue("Start Time", DateTime.Today);
record.SetFieldValue("End Time", DateTime.Today.AddHours(1));
record.SetFieldValue("Period", "Hour");
record.SetFieldValue("Duration", 3600);
record.RecordId = _recordId++;
return(record);
}
public void DefaultStartTime()
{
SimpleQualityModel model = new SimpleQualityModel {
Location = location
};
Repository.Add(model);
Assert.That(model.Id, Is.GreaterThan(0));
Assert.That(Records, Is.Not.Empty);
InMemoryRecord record = Records[0];
Assert.That(record.Location, Is.EqualTo(location));
Assert.That(record.GetFieldValue("Sample Period", DateTime.MinValue), Is.GreaterThan(DateTime.MinValue));
}
public override bool Matches(InMemoryRecord record)
{
if (filters.Any(filter => !filter.Matches(record)))
{
return false;
}
return filters.Count > 0;
}
public abstract bool Matches(InMemoryRecord record);
public override bool Matches(InMemoryRecord record)
{
return record.Location == location;
}
public override bool Matches(InMemoryRecord record)
{
return record.Location.StartsWith(location);
}
public override bool Matches(InMemoryRecord record)
{
return record.RecordId == id;
}
public void GetAuditDataWithARecordWithChanges()
{
SimpleDataWebServiceClient webServiceClient = new SimpleDataWebServiceClient(module, location);
InMemoryRecord record = ProductionRecords.NewRecord().MarkAsNew();
record.SetFieldValue("Field 1", 150);
SubmitDataRequest submitRequest = new SubmitDataRequest
{
Credentials = CreateCredentials(),
SubmitDataRecords = new[]
{
record.ConvertToSubmitDataRecord()
}
};
webServiceClient.SubmitData(submitRequest);
Assert.That(webServiceClient.DatabaseRecords, Is.Not.Empty);
int recordId = webServiceClient.DatabaseRecords[0].RecordId;
InMemoryRecord updateRecord = new InMemoryRecord
{
Location = record.Location,
Module = record.Module,
RecordId = recordId
};
updateRecord.SetFieldValue("Field 1", 200);
SubmitDataRequest update = new SubmitDataRequest
{
Credentials = CreateCredentials(),
SubmitDataRecords = new[]
{
updateRecord.ConvertToSubmitDataRecord()
}
};
webServiceClient.SubmitData(update);
GetAuditDataRequest request = new GetAuditDataRequest
{
Credentials = CreateCredentials(),
Filter = new GetAuditDataFilter { Location = location, Module = AmplaModules.Production, SetId = Convert.ToString(recordId) }
};
GetAuditDataResponse response = webServiceClient.GetAuditData(request);
AssertAuditTableContains(response, location, recordId, "Field 1", "150", "200");
}
