public async Task <DatapointContainer> CreateNewDatapointContainer()
{
var rv = new DatapointContainer();
await rv.Init();
return(rv);
}
public static string GetHostName(this DatapointContainer datapointContainer)
{
if ((datapointContainer?.Dps == null) || (datapointContainer.Dps.Count == 0))
{
return(string.Empty);
}
return(GetHostName(datapointContainer.Dps[0]));
}
public async Task <DatapointContainer> Post([FromBody] DatapointContainer value)
{
DatapointContainer caseToPost = value;
if (value.CaseIsNew)
{
caseToPost = await _datapointContainerManager.CreateNewDatapointContainer();
}
caseToPost.MergeDataPoints(value.ContainerDataPoints);
return(await _datapointContainerManager.SaveDatapointContainerAsync(caseToPost));
}
public async Task <DatapointContainer> GetDatapointContainerAsync(string caseId)
{
DatapointContainer rv = new DatapointContainer();
var datapoints = await containerDataPointTable.Where(pcdp =>
pcdp.ParentId == caseId || (pcdp.DataPointName == DataPointDefinitions.CASE_NAME.DataPointName &&
pcdp.Id == caseId)).ToListAsync();
rv.ContainerDataPoints = datapoints;
return(rv);
}
public async Task SaveDatapointContainerDatapoints(DatapointContainer item)
{
foreach (var datapoint in item.ContainerDataPoints)
{
if (datapoint.QueuedAt <= JAVASCRIPTMINDATE)
{
datapoint.QueuedAt = DateTimeOffset.UtcNow;
await containerDataPointTable.InsertAsync(datapoint);
}
else
{
// nope, we never update a datapoint, we only create new ones!
// means we have a track of all the changes made.
//await containerDataPointTable.UpdateAsync(datapoint);
}
}
}
public static void UpdateContainer(this DatapointContainer container, Action <Datapoint> datapointAction = null)
{
var receivedTimestamp = DateTime.UtcNow;
foreach (var datapoint in container.Dps)
{
datapoint.ReceivedTimestamp = receivedTimestamp;
var hostName = "";
var containerId = Guid.Empty;
foreach (var tag in datapoint.Tags)
{
tag.DatapointId = datapoint.Id;
tag.CustomerId = datapoint.CustomerId;
tag.CollectedTimestamp = datapoint.CollectedTimestamp;
tag.ReceivedTimestamp = datapoint.ReceivedTimestamp;
//this is to be slowly removed.. Bjarni 2016-03-09
if (tag.Key.Equals("CONTAINERID", StringComparison.OrdinalIgnoreCase))
{
containerId = Guid.Parse(tag.Value);
}
if (tag.Key.Equals("Host", StringComparison.OrdinalIgnoreCase))
{
hostName = tag.Value;
}
}
if (datapoint.HostName == string.Empty)
{
datapoint.HostName = hostName;
}
if (datapoint.ContainerId == Guid.Empty)
{
//Log.Add($"CONTAINERID found in datapoint. We cant remote this stuff yet. Update clients for this customer { datapoint.CustomerId}");
datapoint.ContainerId = containerId;
}
datapointAction?.Invoke(datapoint);
}
}
public async Task <ObservableCollection <DatapointContainer> > GetDatapointContainersAsync(bool syncItems = false)
{
try
{
#if OFFLINE_SYNC_ENABLED
if (syncItems)
{
await this.SyncAsync();
}
#endif
ICollection <ContainerDataPoint> items = await containerDataPointTable
//.Where(pcdp => pcdp.ArchivedAt == null)
.ToCollectionAsync();
var allDataPoints = items;
// select all the case names
var containerElements = allDataPoints.Where(pcdp => pcdp.DataPointName == DataPointDefinitions.CASE_NAME.DataPointName);
List <DatapointContainer> containers = new List <DatapointContainer>();
foreach (var pce in containerElements)
{
DatapointContainer container = new DatapointContainer();
container.ContainerDataPoints = allDataPoints.Where((pcdp => pcdp.ParentId == pce.Id || pcdp == pce)).ToList();
containers.Add(container);
}
return(new ObservableCollection <DatapointContainer>(containers));
}
catch (MobileServiceInvalidOperationException msioe)
{
Debug.WriteLine(@"Invalid sync operation: {0}", msioe.Message);
}
catch (Exception e)
{
Debug.WriteLine(@"Sync error: {0}", e.Message);
}
return(null);
}
public void Put(string id, [FromBody] DatapointContainer value)
{
}
public async Task <DatapointContainer> SaveDatapointContainerAsync(DatapointContainer item)
{
await SaveDatapointContainerDatapoints(item);
return(await GetDatapointContainerAsync(item.Id));
}
