public void Export(DataTuple exportableTuple)
{
FbTransaction fbTransaction = fbConnection.BeginTransaction();
StringBuilder newDataText = new StringBuilder();
newDataText.Append("INSERT INTO ");
newDataText.Append(fbTableName);
newDataText.Append(" (title, rowvalue)");
newDataText.Append(" VALUES ('");
newDataText.Append(exportableTuple.Title);
newDataText.Append("', '");
newDataText.Append(exportableTuple.Value);
newDataText.Append("')");
FbCommand fbCommand = new FbCommand
{
CommandText = newDataText.ToString(),
Connection = fbConnection,
Transaction = fbTransaction
};
fbCommand.ExecuteNonQuery();
fbTransaction.Commit();
fbCommand.Dispose();
}
/// <summary>
///
/// </summary>
/// <remarks></remarks>
/// <seealso cref=""/>
/// <param name="dt"></param>
/// <param name="pksVs"></param>
/// <returns></returns>
private bool sameDatatuple(DataTuple dt, Dictionary <long, string> pksVs)
{
bool IsSame = true;
foreach (KeyValuePair <long, string> kvp in pksVs)
{
if (dt.VariableValues.Count > 0)
{
object value = dt.VariableValues.Where(p => p.VariableId.Equals(kvp.Key)).First().Value;
if (value != null)
{
//value not equal different datatuples
if (value.ToString() != kvp.Value)
{
IsSame = false; break;
}
}
// if value is null means not equal to a not null value and
// v1 = null != v2 = null
else
{
IsSame = false; break;
}
}
else
{
IsSame = false; break;
}
}
return(IsSame);
}
/// <summary>
/// convert primary keys to string
/// returns null if a emtpy string is inside
/// </summary>
/// <remarks></remarks>
/// <seealso cref=""/>
/// <param name="datatuple"></param>
/// <param name="primaryKeys"></param>
/// <returns></returns>
private string getPrimaryKeysAsString(DataTuple datatuple, List <long> primaryKeys)
{
string value = "";
foreach (long t in primaryKeys)
{
// empty means not equals value
// so if value is empty add timestamp millisec
//datatuple.Materialize();
object v = datatuple.VariableValues.Where(p => p.VariableId.Equals(t)).First().Value;
if (v != null)
{
//if (!String.IsNullOrEmpty(v.ToString()))
if (!String.IsNullOrEmpty((string)v))
{
value += ";" + v;
}
else
{
return("");
}
}
else
{
return("");
}
}
return(value);
}
string[] generateSystemListForData(string contextName, DataTuple data)
{
return(data.componentData.GetContextNames()
.Where(ctxName => ctxName == contextName)
.Select(ctxName => generateAddSystem(ctxName, data))
.ToArray());
}
string generateAddSystem(string contextName, DataTuple data)
{
return(SYSTEM_ADD_TEMPLATE
.Replace(data.componentData, contextName, data.eventData)
.Replace("${priority}", data.eventData.priority.ToString())
.Replace("${Event}", data.componentData.Event(contextName, data.eventData)));
}
public static void RightKeyPressed()
{
var chart = lastMouseOveredChart;
if (chart == null)
{
return;
}
object xCategory = GetCurrentXCategory(chart);
object rightXCategory = null;
bool categoryReached = false;
for (int i = 0; i < chart.ActualWidth; i++)
{
DataTuple tuple = chart.ConvertPointToData(new Point(i, 0));
if (object.Equals(xCategory, tuple.FirstValue))
{
categoryReached = true;
}
else if (categoryReached)
{
rightXCategory = tuple.FirstValue;
break;
}
}
if (rightXCategory == null)
{
return;
}
UpdateCharts(GetAnnotationsGroup(chart), rightXCategory);
}
private static void Chart_MouseMove(object sender, System.Windows.Input.MouseEventArgs e)
{
RadCartesianChart chart = (RadCartesianChart)sender;
lastMouseOveredChart = chart;
string group = GetAnnotationsGroup(chart);
object currentXCategory = GetCurrentXCategory(chart);
Point position = e.GetPosition(chart);
if (!chart.PlotAreaClip.Contains(position.X, position.Y))
{
if (HidesAnnotationsOnMouseLeave && currentXCategory != null)
{
HideAnnotations(group);
}
return;
}
DataTuple tuple = chart.ConvertPointToData(position);
object xCategory = tuple.FirstValue;
if (object.Equals(xCategory, currentXCategory))
{
return;
}
UpdateCharts(group, xCategory);
}
public static void MoveTrackBall(ChartTrackBallBehavior behav, NavigateDirection direction)
{
var chart = (RadCartesianChart)behav.Chart;
object currentXCategory = null;
if (chart.PlotAreaClip.X <= behav.Position.X && behav.Position.X <= chart.PlotAreaClip.Right)
{
currentXCategory = chart.ConvertPointToData(behav.Position).FirstValue;
}
Func <int, int> next = GetPositionXFunction(direction);
object adjacentXCategory = null;
int startX = GetCoercedPositionX(behav);
for (int x = startX; chart.PlotAreaClip.X <= x && x <= chart.PlotAreaClip.Right; x = next(x))
{
DataTuple tuple = chart.ConvertPointToData(new Point(x, 0));
if (!object.Equals(currentXCategory, tuple.FirstValue))
{
adjacentXCategory = tuple.FirstValue;
break;
}
}
var adjacentPosition = chart.ConvertDataToPoint(new DataTuple(adjacentXCategory, null));
adjacentPosition.Y = behav.Chart.ActualHeight / 2;
behav.Position = adjacentPosition;
}
/// <summary>
/// Convert a Datatuple to a Row
/// </summary>
/// <remarks></remarks>
/// <seealso cref=""/>
/// <param name="dataTupleId">Id of the Datatuple to convert</param>
/// <param name="rowIndex">Position of the Row</param>
/// <returns></returns>
protected Row DatatupleToRow(long dataTupleId, int rowIndex)
{
DataTuple dataTuple = DatasetManager.DataTupleRepo.Query(d => d.Id.Equals(dataTupleId)).FirstOrDefault();
dataTuple.Materialize();
return(DatatupleToRow(dataTuple, rowIndex));
}
private void UIElement_MouseMove(object sender, MouseEventArgs e)
{
Point mousePosition = e.GetPosition(radCartesianChart1);
DataTuple tuple = radCartesianChart1.ConvertPointToData(mousePosition);
string Category = (string)tuple.FirstValue;
double Value = (double)tuple.SecondValue;
//...
}
public int CompareTo(DataTuple other, List <bool> directions)
{
IEnumerator <bool> iterDirs = directions.GetEnumerator();
IEnumerator <object> iterThis = GetEnumerator();
IEnumerator <object> iterOther = other.GetEnumerator();
while (iterThis.MoveNext())
{
bool descending = iterDirs.MoveNext() ? iterDirs.Current : false;
if (iterOther.MoveNext())
{
// compare items
object thisVal = iterThis.Current;
object otherVal = iterOther.Current;
if (thisVal == null && otherVal == null)
{
continue;
}
else if (thisVal == null)
{
return(descending ? 1 : -1);
}
else if (otherVal == null)
{
return(descending ? -1 : 1);
}
else if (thisVal is IComparable)
{
int cmp = ((IComparable)thisVal).CompareTo(otherVal);
// if not equal, done
if (cmp != 0)
{
return(descending ? -cmp : cmp);
}
}
else
{
return(0); // TODO throw ?
}
}
else
{
return(descending ? -1 : 1);
}
}
bool desc2 = iterDirs.MoveNext() ? iterDirs.Current : false;
if (iterOther.MoveNext())
{
return(desc2 ? 1 : -1);
}
else
{
return(0);
}
}
private DataTuple ReadTuple(StorableDocument doc, ICollection <OrderBy> orderBy)
{
DataTuple tuple = new DataTuple();
foreach (OrderBy o in orderBy)
{
tuple.Add(doc.GetData(o.getAttributeInfo().getName()));
}
return(tuple);
}
/// <summary>
///
/// </summary>
/// <remarks></remarks>
/// <seealso cref=""/>
/// <param name="dataTuple"></param>
/// <returns></returns>
private bool IsEmpty(DataTuple dataTuple)
{
foreach (VariableValue variableValue in dataTuple.VariableValues)
{
if (variableValue.Value != null)
{
return(false);
}
}
return(true);
}
public void ReadRow_textWithWhitspaceAtBeginningandEnd_WithspaceRemoved(string rowString)
{
//preperation
List <string> row = new List <string>(rowString.Split('|'));
//Mock IOUtility -> ConvertDateToCulture
var ioUtilityMock = new Mock <IOUtility>();
ioUtilityMock.Setup(i => i.ConvertDateToCulture("2018")).Returns("2018");
//Mock datasetManager -> CreateVariableValue
var datasetManagerMock = new Mock <DatasetManager>();
datasetManagerMock.Setup(d => d.CreateVariableValue("", "", DateTime.Now, DateTime.Now, new ObtainingMethod(), 1, new List <ParameterValue>())).Returns(
new VariableValue()
{
Value = "",
Note = "",
SamplingTime = DateTime.Now,
ResultTime = DateTime.Now,
ObtainingMethod = new ObtainingMethod(),
VariableId = 1,
ParameterValues = new List <ParameterValue>()
}
);
//prepare the variables
DataReader reader = new AsciiReader(dataStructure, new AsciiFileReaderInfo(), ioUtilityMock.Object);
IEnumerable <string> vairableNames = dataStructure.Variables.Select(v => v.Label);
List <VariableIdentifier> variableIdentifiers = reader.SetSubmitedVariableIdentifiers(vairableNames.ToList());
List <Error> errors = reader.ValidateComparisonWithDatatsructure(variableIdentifiers);
errors.Should().BeNull();
//test
DataTuple dt = reader.ReadRow(new List <string>(row), 1);
var v1 = dt.VariableValues[0].Value.ToString();
var v2 = dt.VariableValues[1].Value.ToString();
var v3 = dt.VariableValues[2].Value.ToString();
var v4 = dt.VariableValues[3].Value.ToString();
Assert.That(v1, Is.EqualTo("1"));
Assert.That(v2, Is.EqualTo("test"));
Assert.That(v3, Is.EqualTo("2.2"));
Assert.That(v4, Is.EqualTo("true"));
//Assert.Throws<Exception>(() => reader.ReadRow(new List<string>(row), 1));
}
private static void Annotation_MouseMove(object sender, System.Windows.Input.MouseEventArgs e)
{
var annotation = (CartesianChartAnnotation)sender;
if (annotationToIsDragging.ContainsKey(annotation))
{
bool isDragging = annotationToIsDragging[annotation];
if (isDragging)
{
var chart = (RadCartesianChart)annotation.Chart;
Point mousePosition = e.GetPosition(chart);
Point coercedPosition = GetCoercedPosition(mousePosition, chart.PlotAreaClip);
DataTuple dataTuple = chart.ConvertPointToData(coercedPosition);
UpdateAnnotationPosition(annotation, dataTuple);
}
}
}
/// <summary>
///
/// </summary>
/// <remarks></remarks>
/// <seealso cref=""/>
/// <param name="dt"></param>
/// <param name="pks"></param>
/// <returns></returns>
private Dictionary <long, string> getPrimaryKeyValues(DataTuple dt, List <long> pks)
{
Dictionary <long, string> temp = new Dictionary <long, string>();
foreach (long k in pks)
{
object value = dt.VariableValues.Where(p => p.VariableId.Equals(k)).First().Value;
if (value != null)
{
temp.Add(k, value.ToString());
}
else
{
temp.Add(k, "");
}
}
return(temp);
}
public void ReadRow_RowIsNullTest_DataTupleIsNull()
{
//Mock IOUtility
var ioUtilityMock = new Mock <IOUtility>();
ioUtilityMock.Setup(i => i.ConvertDateToCulture("2018")).Returns("2018");
//prepare the variables
DataReader reader = new AsciiReader(dataStructure, new AsciiFileReaderInfo(), ioUtilityMock.Object);
IEnumerable <string> vairableNames = dataStructure.Variables.Select(v => v.Label);
reader.SetSubmitedVariableIdentifiers(vairableNames.ToList());
//test
DataTuple dt = reader.ReadRow(null, 1);
//asserts
dt.Should().BeNull();
}
public void ReadRow_ValidRowTest_DataTupleIsValid(string rowString)
{
//preperation
List <string> row = new List <string>(rowString.Split('|'));
//Mock IOUtility -> ConvertDateToCulture
var ioUtilityMock = new Mock <IOUtility>();
ioUtilityMock.Setup(i => i.ConvertDateToCulture("2018")).Returns("2018");
//Mock datasetManager -> CreateVariableValue
var datasetManagerMock = new Mock <DatasetManager>();
datasetManagerMock.Setup(d => d.CreateVariableValue("", "", DateTime.Now, DateTime.Now, new ObtainingMethod(), 1, new List <ParameterValue>())).Returns(
new VariableValue()
{
Value = "",
Note = "",
SamplingTime = DateTime.Now,
ResultTime = DateTime.Now,
ObtainingMethod = new ObtainingMethod(),
VariableId = 1,
ParameterValues = new List <ParameterValue>()
}
);
//prepare the variables
DataReader reader = new AsciiReader(dataStructure, new AsciiFileReaderInfo(), ioUtilityMock.Object);
IEnumerable <string> vairableNames = dataStructure.Variables.Select(v => v.Label);
List <VariableIdentifier> variableIdentifiers = reader.SetSubmitedVariableIdentifiers(vairableNames.ToList());
List <Error> errors = reader.ValidateComparisonWithDatatsructure(variableIdentifiers);
errors.Should().BeNull();
//test
DataTuple dt = reader.ReadRow(new List <string>(row), 1);
//asserts
dt.Should().NotBeNull();
dt.VariableValues.Count.Should().Equals(row.Count);
}
public ActionResult FlipDateTime(long id, long variableid)
{
DatasetManager datasetManager = new DatasetManager();
try
{
DatasetVersion dsv = datasetManager.GetDatasetLatestVersion(id);
IEnumerable <long> datatupleIds = datasetManager.GetDatasetVersionEffectiveTupleIds(dsv);
foreach (var tid in datatupleIds)
{
DataTuple dataTuple = datasetManager.DataTupleRepo.Get(tid);
dataTuple.Materialize();
bool needUpdate = false;
foreach (var vv in dataTuple.VariableValues)
{
string systemType = vv.DataAttribute.DataType.SystemType;
if (systemType.Equals(typeof(DateTime).Name) && vv.VariableId.Equals(variableid))
{
string value = vv.Value.ToString();
vv.Value = flip(value, out needUpdate);
}
}
if (needUpdate)
{
dataTuple.Dematerialize();
datasetManager.UpdateDataTuple(dataTuple);
}
}
}
catch (Exception ex)
{
}
finally
{
datasetManager.Dispose();
}
return(RedirectToAction("Index"));
}
private List <StorableDocument> Sort(ICollection <OrderBy> orderBy, List <StorableDocument> docs)
{
if (orderBy == null || orderBy.Count == 0 || docs.Count < 2)
{
return(docs);
}
List <bool> directions = new List <bool>();
foreach (OrderBy o in orderBy)
{
directions.Add(o.isDescending());
}
docs.Sort((o1, o2) =>
{
DataTuple v1 = ReadTuple(o1, orderBy);
DataTuple v2 = ReadTuple(o2, orderBy);
return(v1.CompareTo(v2, directions));
});
return(docs);
}
private bool Equal2(DataTuple newDatatuple, DataTuple sourceDatatuple)
{
foreach (VariableValue newVariableValue in newDatatuple.VariableValues)
{
foreach (VariableValue sourceVariableValue in sourceDatatuple.VariableValues)
{
if (newVariableValue.VariableId.Equals(sourceVariableValue.VariableId))
{
if (!newVariableValue.Value.Equals(sourceVariableValue.Value))
{
return(false);
}
else
{
break;
}
}
}
}
return(true);
}
public static void LeftKeyPressed()
{
var chart = lastMouseOveredChart;
if (chart == null)
{
return;
}
object xCategory = GetCurrentXCategory(chart);
if (xCategory == null)
{
return;
}
object leftXCategory = null;
for (int i = 0; i <= chart.ActualWidth; i++)
{
DataTuple tuple = chart.ConvertPointToData(new Point(i, 0));
if (object.Equals(xCategory, tuple.FirstValue))
{
break;
}
leftXCategory = tuple.FirstValue;
}
if (leftXCategory == null)
{
return;
}
UpdateCharts(GetAnnotationsGroup(chart), leftXCategory);
}
private static void ProcessNodeProperties(GeneralTreeNodeViewModel node, BinaryStreamCLI stream)
{
var streamType = stream.GetStreamType();
var title = stream.GetTitle();
var value = stream.GetValue();
var data = new DataTuple(
title,
value
);
if (streamType != PropertyType.Property)
{
//when forming a node we need to get only properties
return;
}
node.Properties.Add(data);
switch (title) //we need to get the name of the node to properly display it
{
case "gui_name":
node.Header = value;
break;
case "storage_type":
var storageType = value;
node.IsFinalGuiNode = storageType == "final_node";
node.IsGuiNode = storageType == "node" || node.IsFinalGuiNode;
break;
case "markup":
node.Markup = value;
break;
}
}
private String GenerateAddSystem(string contextName, DataTuple data)
{
return(SYSTEM_ADD_TEMPLATE
.Replace(_contexts, data.Ent, contextName, data.EventInfo)
.Replace("${priority}", data.EventInfo.Priority.ToString())
.Replace("${Event}", data.Ent.Event(_contexts, contextName, data.EventInfo)));
}
private String[] GenerateSystemListForData(DataTuple data)
{
return(data.Ent.Get_ <ContextNamesComp>().Values
.Select(ctxName => GenerateAddSystem(ctxName, data))
.ToArray());
}
/// <summary>
/// Read Row and convert each value into a variableValue
/// and each row to a Datatuple
/// </summary>
/// <param name="row">List of values in one row</param>
/// <param name="indexOfRow">Currently row index</param>
/// <returns>DataTuple</returns>
public DataTuple ReadRow(List <string> row, int indexOfRow)
{
DataTuple dt = new DataTuple();
string value = "";
// convert row to List<VariableValue>
for (int i = 0; i < row.Count(); i++)
{
VariableIdentifier variableIdentifier = this.SubmitedVariableIdentifiers.ElementAt(i);
long variableId = 0;
if (variableIdentifier.id > 0)
{
variableId = this.SubmitedVariableIdentifiers.ElementAt(i).id;
}
else
{
variableId = getVariableUsage(variableIdentifier).Id;
}
// if variable from systemtype datatime
// maybee needs to convert into the default datetime culture format
if (this.StructuredDataStructure.Variables.Where(p => p.Id.Equals(variableId)).FirstOrDefault().DataAttribute.DataType.SystemType.Equals("DateTime"))
{
Dlm.Entities.DataStructure.DataType dataType = this.StructuredDataStructure.Variables.Where(p => p.Id.Equals(variableId)).FirstOrDefault().DataAttribute.DataType;
if (dataType != null && dataType.Extra != null)
{
DataTypeDisplayPattern dp = DataTypeDisplayPattern.Materialize(dataType.Extra);
if (dp != null && !string.IsNullOrEmpty(dp.StringPattern))
{
value = IOUtility.ConvertToDateUS(row[i], dp.StringPattern);
}
else
{
value = IOUtility.ConvertDateToCulture(row[i]);
}
}
else
{
value = IOUtility.ConvertDateToCulture(row[i]);
}
}
else
{
if (this.StructuredDataStructure.Variables.Where(p => p.Id.Equals(variableId)).FirstOrDefault().DataAttribute.DataType.SystemType.Equals("Double") ||
this.StructuredDataStructure.Variables.Where(p => p.Id.Equals(variableId)).FirstOrDefault().DataAttribute.DataType.SystemType.Equals("Decimal") ||
this.StructuredDataStructure.Variables.Where(p => p.Id.Equals(variableId)).FirstOrDefault().DataAttribute.DataType.SystemType.Equals("Float"))
{
value = row[i];
if (Info.Decimal.Equals(DecimalCharacter.comma))
{
if (value.Contains("."))
{
value = value.Replace(".", "");
}
if (value.Contains(","))
{
value = value.Replace(',', '.');
}
}
if (Info.Decimal.Equals(DecimalCharacter.point))
{
if (value.Contains(","))
{
value = value.Remove(',');
}
}
}
else
{
value = row[i];
}
}
dt.VariableValues.Add(DatasetManager.CreateVariableValue(value, "", DateTime.Now, DateTime.Now, new ObtainingMethod(), variableId, new List <ParameterValue>()));
}
return(dt);
}
private String[] GenerateSystemListForData(string contextName, DataTuple data)
{
return(data.Ent.contextNamesComp.Values
.Where(ctxName => ctxName == contextName)
.Select(ctxName => GenerateAddSystem(ctxName, data))
.ToArray());
}
public DataTable ConvertPrimaryDataToDatatable(DatasetVersion dsv, IEnumerable <long> dsVersionTupleIds)
{
DataTable dt = new DataTable();
dt.TableName = "Primary data table";
DatasetManager datasetManager = new DatasetManager();
try
{
StructuredDataStructure sds = this.GetUnitOfWork().GetReadOnlyRepository <StructuredDataStructure>().Get(dsv.Dataset.DataStructure.Id);
if (dsVersionTupleIds != null && sds != null)
{
foreach (var vu in sds.Variables)
{
// use vu.Label or vu.DataAttribute.Name
DataColumn col = dt.Columns.Add("ID" + vu.Id.ToString()); // or DisplayName also
col.Caption = vu.Label;
switch (vu.DataAttribute.DataType.SystemType)
{
case "String":
{
col.DataType = Type.GetType("System.String");
break;
}
case "Double":
{
col.DataType = Type.GetType("System.Double");
break;
}
case "Int16":
{
col.DataType = Type.GetType("System.Int16");
break;
}
case "Int32":
{
col.DataType = Type.GetType("System.Int32");
break;
}
case "Int64":
{
col.DataType = Type.GetType("System.Int64");
break;
}
case "Decimal":
{
col.DataType = Type.GetType("System.Decimal");
break;
}
case "DateTime":
{
col.DataType = Type.GetType("System.DateTime");
break;
}
default:
{
col.DataType = Type.GetType("System.String");
break;
}
}
if (vu.Parameters.Count > 0)
{
foreach (var pu in vu.Parameters)
{
DataColumn col2 = dt.Columns.Add(pu.Label.Replace(" ", "")); // or DisplayName also
col2.Caption = pu.Label;
}
}
}
foreach (var id in dsVersionTupleIds)
{
DataTuple dataTuple = datasetManager.DataTupleRepo.Query(d => d.Id.Equals(id)).FirstOrDefault();
dataTuple.Materialize();
dt.Rows.Add(ConvertTupleIntoDataRow(dt, dataTuple, sds));
}
}
return(dt);
}
finally
{
datasetManager.Dispose();
}
}
/// <summary>
/// get a updated datatuple on a specific value.
/// based on the created test datastructure
/// index:
/// 0 = int
/// 1 = text
/// 2 = double
/// 3 = bool
/// 4 = datetime
/// </summary>
/// <param name="source"></param>
/// <param name="updateVarIndex"></param>
/// <param name="datasetManager"></param>
/// <returns></returns>
public DataTuple GetUpdatedDatatuple(DataTuple source, int updateVarIndex)
{
if (source == null)
{
return(null);
}
source.Materialize();
var vv = source.VariableValues[updateVarIndex];
if (vv != null)
{
switch (updateVarIndex)
{
case 0: //int
{
vv.Value = new Random().Next();
break;
}
case 1: //text
{
var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
var stringChars = new char[8];
var random = new Random();
for (int i = 0; i < stringChars.Length; i++)
{
stringChars[i] = chars[random.Next(chars.Length)];
}
vv.Value = new String(stringChars);
break;
}
case 2: //double
{
vv.Value = new Random().NextDouble();
break;
}
case 3: //bool
{
vv.Value = false;
break;
}
case 4:
{
vv.Value = DateTime.Now.ToString(new CultureInfo("en-US"));
break;
}
//default:
}
}
source.Dematerialize();
source.Should().NotBeNull();
return(source);
}
public Dataset UpdateOneTupleForDataset(Dataset dataset, StructuredDataStructure dataStructure, long id, int value, DatasetManager datasetManager)
{
dataset.Status.Should().Be(DatasetStatus.CheckedIn);
dataset.Should().NotBeNull();
try
{
if (datasetManager.IsDatasetCheckedOutFor(dataset.Id, "David") || datasetManager.CheckOutDataset(dataset.Id, "David"))
{
dataset.Status.Should().Be(DatasetStatus.CheckedOut, "Dataset must be in Checkedout status.");
DatasetVersion workingCopy = datasetManager.GetDatasetWorkingCopy(dataset.Id);
DataTuple oldDt = datasetManager.DataTupleRepo.Get(id);
DataTuple dt = new DataTuple();
dt.VariableValues.Add(new VariableValue()
{
VariableId = dataStructure.Variables.First().Id, Value = value
});
dt.VariableValues.Add(new VariableValue()
{
VariableId = dataStructure.Variables.Skip(1).First().Id, Value = "Test"
});
dt.VariableValues.Add(new VariableValue()
{
VariableId = dataStructure.Variables.Skip(2).First().Id, Value = 5
});
dt.VariableValues.Add(new VariableValue()
{
VariableId = dataStructure.Variables.Skip(3).First().Id, Value = true
});
dt.VariableValues.Add(new VariableValue()
{
VariableId = dataStructure.Variables.Skip(4).First().Id, Value = DateTime.Now.ToString(new CultureInfo("en-US"))
});
dt.Dematerialize();
dt.Should().NotBeNull();
dt.JsonVariableValues.Should().NotBeNull();
List <DataTuple> tuples = new List <DataTuple>();
DataTuple newDt = new DataTuple();
newDt.Id = id;
newDt.XmlAmendments = dt.XmlAmendments;
newDt.JsonVariableValues = dt.JsonVariableValues;
newDt.Materialize();
newDt.OrderNo = oldDt.OrderNo;
tuples.Add(newDt);
datasetManager.EditDatasetVersion(workingCopy, null, tuples, null);
dataset.Status.Should().Be(DatasetStatus.CheckedOut, "Dataset must be in Checkedout status.");
}
return(dataset);
}
catch (Exception ex)
{
return(null);
}
}
