public void Test_イコールイコールテスト()
{
var vo1 = new MeasureValue(1.23456f);
var vo2 = new MeasureValue(1.23456f);
Assert.True(vo1 == vo2);
}
public void イコールテスト()
{
var vo1 = new MeasureValue(1.23456f);
var vo2 = new MeasureValue(1.23456f);
Assert.IsTrue(vo1.Equals(vo2));
}
public void Test_イコールテスト()
{
var vo1 = new MeasureValue(1.23456f);
var vo2 = new MeasureValue(1.23456f);
Assert.Equal(vo1, vo2);
}
private static string GetOid(DashboardItemMouseActionEventArgs e)
{
MultiDimensionalData data = e.Data.GetSlice(e.GetAxisPoint());
MeasureDescriptor descriptor = data.GetMeasures().SingleOrDefault(item => item.DataMember == "Oid");
MeasureValue measureValue = data.GetValue(descriptor);
return(measureValue.Value.ToString());
}
//Newするときにコンストラクタで必ず値が入る。完全コンストラクタパターン
public MeasureEntity(int areaId,
DateTime measureDate,
float measureValue)
{
AreaId = new AreaId(areaId);
MeasureDate = new MeasureDate(measureDate);
MeasureValue = new MeasureValue(measureValue);
}
public MeasureEntity(string id
, DateTime date
, float value)
{
Id = id;
Date = date;
Value = new MeasureValue(value);
}
public void イコールテスト()
{
var vo1 = new MeasureValue(1.23456f);
var vo2 = new MeasureValue(1.23456f);
Assert.AreEqual(true, vo1.Equals(vo2));
Assert.AreEqual(true, vo1 == vo2);
}
private void DrawMeasure(Graphics gfx, int index, Font font, int x, int y)
{
MeasureValue tVal = fValues[index];
if (!string.IsNullOrEmpty(tVal.Text) && !double.IsNaN(tVal.Value))
{
DrawText(gfx, tVal.Text, font, tVal.Color, x, y);
}
}
public static GetMeasureValueListResult Create(MeasureValue value)
{
return(new GetMeasureValueListResult()
{
Date = value.CreatedAt.ConvertUtcToJst(),
Temperature = value.Temperature + value.TemperatureOffset,
Humidity = value.Humidity + value.HumidityOffset,
Illumination = value.Illumination,
Movement = value.Movement
});
}
public bool AddScores(TestCollection tc)
{
Dictionary <string, Dictionary <string, MeasureValue> > measureValues = new Dictionary <string, Dictionary <string, MeasureValue> >();
Dictionary <string, Dictionary <string, MeasureValue> > measureValuesIn = new Dictionary <string, Dictionary <string, MeasureValue> >();
foreach (Dictionary <string, Score> scores in this.Scores.TestScores.Values)
{
foreach (Score score in scores.Values)
{
string measureOf = score.MeasureOf;
string measureLabel = score.MeasureLabel;
string measureValue = score.MeasureValue;
if (!measureValuesIn.ContainsKey(measureLabel))
{
measureValuesIn[measureLabel] = new Dictionary <string, MeasureValue>();
}
double score_d, se_d;
if (Double.TryParse(measureValue, out score_d) && Double.TryParse(score.MeasureSE, out se_d))
{
measureValuesIn[measureLabel][measureOf] = new MeasureValue(measureLabel, measureOf, score_d, se_d);
}
else
{
measureValuesIn[measureLabel][measureOf] = new MeasureValue(measureLabel, measureOf, measureValue);
}
}
}
List <ScoringEngine.ConfiguredTests.ItemScore> itemScores = this.GetItemScoresForScoringEngine();
measureValues = new ScoringEngine.Scorer(tc).ApplyComputationRules(this.Name, this.Testee.EnrolledGrade, measureValuesIn, itemScores, this.Opportunity.StartDate, this.Opportunity.Status, this.Opportunity.Forms, this.Opportunity.DateForceCompleted, this.TestMode, this.Opportunity.Accomodations, this.Opportunity.RTSAccommodations);
if (measureValues.Count == 0)
{
return(false);
}
bool xmlChanged = false;
foreach (Dictionary <string, MeasureValue> measures in measureValues.Values)
{
foreach (MeasureValue measureValue in measures.Values)
{
Score score = new Score(measureValue.MeasureOf, measureValue.MeasureLabel, measureValue.ScoreString, measureValue.StandardErrorString);
bool changed = this.Opportunity.AddScoreIfNew(score);
xmlChanged = xmlChanged ? xmlChanged : changed;
}
}
return(xmlChanged);
}
//1397.08.26
//why this methods calls multiple time. enable break point to see why
private void UpdateEdgeLables()
{
this._edgeLabelLayer.Items.Clear();
//if (this._webMercatorGeometry?.GetAllPoints().Length <= 1)
////if (this._webMercatorGeometry.NumberOfPoints <= 1 || temp <= 1)
//{
// return;
//}
if (Options.IsEdgeLabelVisible)
{
var edges = _webMercatorGeometry.GetLineSegments().Select(i => ToEdgeLengthLocatable(i.Start, i.End));
foreach (var item in edges)
{
_edgeLabelLayer.Items.Add(item);
}
}
if (Options.IsMeasureVisible)
{
var point = this._webMercatorGeometry?.GetMeanOrLastPoint();
if (point == null)
{
return;
}
var element = new View.MapMarkers.RectangleLabelMarker(MeasureLabel);
//do not show length/area when geometry has just one/two point or new part has just one/two point
if (double.IsNaN(MeasureValue))
{
return;
}
element.TooltipValue = MeasureValue.ToInvariantString();
var offset = _screenToMap(20);
_edgeLabelLayer.Items.Add(new Locateable(Model.AncherFunctionHandlers.BottomCenter)
{
Element = element,
X = point.X + offset,
Y = point.Y + offset
});
}
}
private void PrepareValue(IList <MeasureValue> measures, double mVal, string sign, string uom, ValueRange[] ranges)
{
string strVal = !double.IsNaN(mVal) ? ALCore.GetDecimalStr(mVal) : string.Empty;
string text = string.Format("{0}={1} {2}", sign, strVal, uom);
Color color = Color.Black;
ValueRange bounds = CheckValue(mVal, ranges);
if (bounds != null)
{
color = bounds.Color;
}
var tval = new MeasureValue(sign, mVal, uom, strVal, text, color, ranges);
measures.Add(tval);
}
/// <summary>
/// コンストラクター
/// DDDでは完全コンストラクターにする（引数に全ての項目を含む）
/// 値をセットしたら変更はできない
/// </summary>
/// <param name="areaId">エリアID</param>
/// <param name="measureDate">計測日</param>
/// <param name="measureValue">計測値</param>
public MeasureEntity(
int areaId,
DateTime measureDate,
float measureValue)
{
// ID
// 非DDDの考え方
// AreaId = areaId;
// DDDの考え方
// ValueObject化する（クラス）
AreaId = new AreaId(areaId);
// MeasureDate = measureDate;
MeasureDate = new MeasureDate(measureDate);
// MeasureValue = measureValue;
MeasureValue = new MeasureValue(measureValue);
}
public async Task Run([TimerTrigger("0 */1 * * * *")] TimerInfo myTimer, ILogger log)
{
var result = await _client.GetAsync("/1/devices");
var contentString = await result.Content.ReadAsStringAsync();
log.LogInformation($"response:{contentString}");
if (result.IsSuccessStatusCode)
{
var content = JsonConvert.DeserializeObject <List <GetDeviceResponse> >(contentString);
var now = DateTime.UtcNow;
var values = content.Select(e => MeasureValue.Create(e, now));
foreach (var val in values)
{
await _cosmosDbService.AddMeasureValue(val);
}
}
log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");
}
public MeasureEntity(string measureId, DateTime measureDate, float measureValue)
{
MeasureId = measureId ?? throw new ArgumentNullException(nameof(measureId));
MeasureDate = new MeasureDate(measureDate);
MeasureValue = new MeasureValue(measureValue);
}
public MeasureMutation(
IRepositoryWrapper rep)
{
Name = "Mutation";
#region Update
Field <BatteryStateType>(
"updateBatteryState",
"Update the state of the battery.",
new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "id", Description = "The unique identifier of the battery."
},
new QueryArgument <NonNullGraphType <BatteryStateInputType> > {
Name = "batteryStateType"
}
),
context =>
{
var id = context.GetArgument <Guid>("id");
var state = context.GetArgument <BatteryState>("batteryStateType");
state.Id = id;
return(rep.BatteryState.Update(state));
});
Field <ListGraphType <BatteryStateType> >(
"updateBatteryStateBunch",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <ListGraphType <IdGraphType> > > {
Name = "ids"
},
new QueryArgument <NonNullGraphType <ListGraphType <DateTimeOffsetGraphType> > > {
Name = "timestamps"
},
new QueryArgument <NonNullGraphType <ListGraphType <BooleanGraphType> > > {
Name = "states"
}),
resolve: context =>
{
var time = DateTimeOffset.Now;
var ids = context.GetArgument <IList <Guid> >("ids");
var timestamps = context.GetArgument <IList <DateTimeOffset> >("timestamps");
var batteryStates = context.GetArgument <IList <bool> >("states");
var newBatteryStates = new List <BatteryState>();
foreach (var id in ids)
{
newBatteryStates.Add(new BatteryState
{
Id = id,
State = batteryStates[newBatteryStates.Count],
Timestamp = timestamps[newBatteryStates.Count]
});
}
var updatedStates = rep.BatteryState.UpdateBunch(newBatteryStates);
return(updatedStates);
});
Field <PriorityStateType>(
"updatePriorityState",
"Update the value of the Priority.",
new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "id", Description = "The unique identifier of the battery."
},
new QueryArgument <NonNullGraphType <PriorityStateInputType> > {
Name = "priorityStateType"
}
),
context =>
{
var id = context.GetArgument <Guid>("id");
var state = context.GetArgument <PriorityState>("priorityStateType");
return(rep.PriorityState.Update(state));
});
Field <ListGraphType <PriorityStateType> >(
"updatePriorityStateBunch",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <ListGraphType <IdGraphType> > > {
Name = "ids"
},
new QueryArgument <NonNullGraphType <ListGraphType <PriorityStateInputType> > > {
Name = "priorityStateTypes"
}),
resolve: context =>
{
var time = DateTimeOffset.Now;
var ids = context.GetArgument <IList <Guid> >("ids");
var priorityStates = context.GetArgument <IList <PriorityState> >("priorityStateTypes");
var updatedStates = new List <PriorityState>();
foreach (var id in ids)
{
updatedStates.Add(new PriorityState
{
Id = id,
State = priorityStates[updatedStates.Count].State,
Timestamp = priorityStates[updatedStates.Count].Timestamp
});
}
var result = rep.PriorityState.UpdateBunch(updatedStates);
return(result);
});
FieldAsync <UnitType>(
"updateUnit",
"Update Unit by id",
new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "id"
},
new QueryArgument <NonNullGraphType <UnitInputType> > {
Name = "unitType"
}
),
resolve: async context =>
{
var id = context.GetArgument <Guid>("id");
var unit = context.GetArgument <Unit>("unitType");
var old = await rep.Unit.SelectByIdAsync(id);
old.Name = unit.Name;
old.Display = unit.Display;
return(rep.Unit.Update(old));
});
FieldAsync <MeasurePointType>(
"updateMeasurePoint",
"Update MeasurePoint by id.",
new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "id"
},
new QueryArgument <NonNullGraphType <MeasurePointInputType> > {
Name = "measurePointType"
}),
async context =>
{
var id = context.GetArgument <Guid>("id");
var measurePoint = context.GetArgument <MeasurePoint>("measurePointType");
var old = await rep.MeasurePoint.SelectByIdAsync(id);
old.Display = measurePoint.Display;
old.Unit = measurePoint.Unit;
old.Location = measurePoint.Location;
old.Min = measurePoint.Min;
old.Max = measurePoint.Max;
old.ExternId = measurePoint.ExternId ?? old.ExternId;
return(rep.MeasurePoint.Update(old));
});
FieldAsync <LinkType>(
"updateLink",
"Update an existing Link",
new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "id"
},
new QueryArgument <NonNullGraphType <LinkInputType> > {
Name = "linkType"
}
),
resolve: async context =>
{
var id = context.GetArgument <Guid>("id");
var link = context.GetArgument <Link>("linkType");
var old = await rep.Link.SelectByIdAsync(id);
old.Name = link.Name;
old.LinkValue = link.LinkValue;
return(rep.Link.Update(old));
});
#endregion
#region Create
FieldAsync <MeasurePointType>(
"createMeasurePoint",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <MeasurePointInputType> > {
Name = "measurePointType"
}
),
resolve: async context =>
{
var measurePoint = context.GetArgument <MeasurePoint>("measurePointType");
measurePoint.Id = Guid.NewGuid();
measurePoint.Created = DateTimeOffset.Now;
return(await rep.MeasurePoint.InsertAsync(measurePoint));
});
FieldAsync <MeasureValueType>(
"createMeasureValue",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <MeasureValueInputType> > {
Name = "measureValueType"
}
),
resolve: async context =>
{
var measureValue = context.GetArgument <MeasureValue>("measureValueType");
measureValue.Id = Guid.NewGuid();
measureValue.Timestamp = DateTimeOffset.Now;
return(await rep.MeasureValue.InsertAsync(measureValue));
});
FieldAsync <MeasureValueType>(
"createEasyMeasureValue",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <FloatGraphType> > {
Name = "value"
},
new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "pointId"
}
),
resolve: async context =>
{
var value = context.GetArgument <double>("value");
var pointId = context.GetArgument <Guid>("pointId");
var measureValue = new MeasureValue
{
Id = Guid.NewGuid(),
Timestamp = DateTimeOffset.Now,
Point = pointId,
Value = value
};
return(await rep.MeasureValue.InsertAsync(measureValue));
});
FieldAsync <ListGraphType <MeasureValueType> >(
"createMeasureValueBunch",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <ListGraphType <FloatGraphType> > > {
Name = "values"
},
new QueryArgument <NonNullGraphType <ListGraphType <IdGraphType> > > {
Name = "points"
}),
resolve: async context =>
{
var time = DateTimeOffset.Now;
var values = context.GetArgument <IEnumerable <double> >("values");
var points = context.GetArgument <IEnumerable <Guid> >("points");
var measureValues = new List <MeasureValue>();
foreach (var value in values)
{
var point = points.ElementAt(measureValues.Count);
measureValues.Add(new
MeasureValue
{
Id = Guid.NewGuid(),
Point = point,
Timestamp = time,
Value = value
});
}
_ = await rep.MeasureValue.InsertBunchAsync(measureValues);
return(measureValues);
});
FieldAsync <UnitType>(
"createUnit",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <UnitInputType> > {
Name = "unitType"
}
),
resolve: async context =>
{
var unit = context.GetArgument <Unit>("unitType");
unit.Id = Guid.NewGuid();
unit.Created = DateTimeOffset.Now;
return(await rep.Unit.InsertAsync(unit));
});
FieldAsync <LocationType>(
"createLocation",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <LocationInputType> > {
Name = "locationType"
}
),
resolve: async context =>
{
var location = context.GetArgument <Location>("locationType");
location.Id = Guid.NewGuid();
location.Created = DateTimeOffset.Now;
return(await rep.Location.InsertAsync(location));
});
FieldAsync <LinkType>(
"createLink",
"Create a new Link",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <LinkInputType> > {
Name = "linkType"
}
),
resolve: async context =>
{
var link = context.GetArgument <Link>("linkType");
link.Id = Guid.NewGuid();
return(await rep.Link.InsertAsync(link));
});
#endregion
}
public async Task WriteRecordsMultiMeasureValueMultipleRecords()
{
Console.WriteLine("Writing records with multi value attributes mixture type");
DateTimeOffset now = DateTimeOffset.UtcNow;
string currentTimeString = (now.ToUnixTimeMilliseconds()).ToString();
List <Dimension> dimensions = new List <Dimension> {
new Dimension {
Name = "region", Value = "us-east-1"
},
new Dimension {
Name = "az", Value = "az1"
},
new Dimension {
Name = "hostname", Value = "host1"
}
};
var commonAttributes = new Record
{
Dimensions = dimensions,
Time = currentTimeString
};
var cpuUtilization = new MeasureValue
{
Name = "cpu_utilization",
Value = "13.6",
Type = "DOUBLE"
};
var memoryUtilization = new MeasureValue
{
Name = "memory_utilization",
Value = "40",
Type = "DOUBLE"
};
var activeCores = new MeasureValue
{
Name = "active_cores",
Value = "4",
Type = "BIGINT"
};
var computationalRecord = new Record
{
MeasureName = "computational_utilization",
MeasureValues = new List <MeasureValue> {
cpuUtilization, memoryUtilization, activeCores
},
MeasureValueType = "MULTI"
};
var aliveRecord = new Record
{
MeasureName = "is_healthy",
MeasureValue = "true",
MeasureValueType = "BOOLEAN"
};
List <Record> records = new List <Record>();
records.Add(computationalRecord);
records.Add(aliveRecord);
try
{
var writeRecordsRequest = new WriteRecordsRequest
{
DatabaseName = MultiMeasureValueConstants.MultiMeasureValueSampleDb,
TableName = MultiMeasureValueConstants.MultiMeasureValueSampleTable,
Records = records,
CommonAttributes = commonAttributes
};
WriteRecordsResponse response = await writeClient.WriteRecordsAsync(writeRecordsRequest);
Console.WriteLine($"Write records status code: {response.HttpStatusCode.ToString()}");
}
catch (Exception e)
{
Console.WriteLine("Write records failure:" + e.ToString());
}
}
public void AddMeasureValue(MeasureValue measureValue) => _context.MeasureValues.Add(measureValue);
public MeasureEntity(string measureId, MeasureDate measureDate, MeasureValue measureValue)
{
MeasureId = measureId;
MeasureDate = measureDate;
MeasureValue = measureValue;
}
public async Task AddMeasureValue(MeasureValue value)
{
await _container.CreateItemAsync(value, value.PertitionKey);
}
private async void InsertValues(
object state)
{
if (_running)
{
_logger.LogInformation(4444, $"Job is already running");
return;
}
_running = true;
var lastTimestamp = _repository.LastTimestamp();
var currentTimestamp = lastTimestamp.AddMinutes(1);
while (currentTimestamp < DateTime.Now.CutSeconds())
{
_ = _repository.AddTimestamp(currentTimestamp.CutSeconds());
currentTimestamp = currentTimestamp.AddMinutes(1);
}
_ = await _repository.SaveChangesAsync();
var targets = new List <MeasureValue>();
var delete = new List <MqttMessage>();
// Filter relevant messages
var messages =
await _repository
.GetMessagesAsQueryable()
.Where(msg => !msg.Topic.EndsWith("neo7m"))
.OrderBy(msg => msg.Created)
.ToListAsync();
foreach (var message in messages)
{
if (!double.TryParse(message.Message, out var v))
{
delete.Add(message);
continue;
}
var fields = message.Topic.Split('/');
if (fields.Length != 4)
{
delete.Add(message);
continue;
}
var tmpTimestamp = message.Created.CutSeconds();
var timestamp = _repository.GetTimestamp(tmpTimestamp);
if (timestamp == null)
{
_logger.LogInformation($"Timestamp {tmpTimestamp.ToString()} not exist");
continue;
}
var room = _repository.GetRoom(fields[1]);
var measureType = _repository.GetMeasureType(fields[2]);
var sensorType = _repository.GetSensorType(fields[3]);
if (room == null && measureType == null && sensorType == null)
{
_logger.LogError(6666, $"Error with types");
continue;
}
var value = new MeasureValue
{
MeasureTimeTimestamp = timestamp.Timestamp,
SensorTypeName = sensorType.Name,
RoomName = room?.Name,
MeasureTypeName = measureType?.Name,
Value = v
};
if (targets.FirstOrDefault(
msg =>
msg.RoomName == value.RoomName &&
msg.SensorTypeName == value.SensorTypeName &&
msg.MeasureTypeName == value.MeasureTypeName &&
msg.MeasureTimeTimestamp == value.MeasureTimeTimestamp) != null)
{
_logger.LogError(4444, $"Value are duplicate in MqttMessages");
delete.Add(message);
continue;
}
targets.Add(value);
delete.Add(message);
}
foreach (var target in targets)
{
if (!_repository.MeasureExists(
target.RoomName,
target.MeasureTypeName,
target.SensorTypeName,
target.MeasureTimeTimestamp))
{
_repository.AddMeasureValue(target);
}
}
foreach (var dMessage in delete)
{
_repository.DeleteMessage(dMessage);
}
_ = await _repository.SaveChangesAsync();
_running = false;
}
