public async Task <IActionResult> PutScore(string id, string userid, ScoreRequest request)
{
if (userid == "@me")
{
userid = UserId;
}
var objective = (await _scoreboard.GetByApplicationAsync(AppId)).FirstOrDefault(o => o.Id == id);
if (objective == null)
{
return(NotFound(new ErrorResponse("The objective does not exist.")));
}
var user = await _users.GetByIdAsync(userid);
if (user == null)
{
return(NotFound(new ErrorResponse("The user does not exist.")));
}
await _scoreboard.SetScoreAsync(id, userid, request.Value);
return(NoContent());
}
/// <summary>
/// 增加积分记录
/// </summary>
public ResultJson AddScoreRecord(ScoreRequest request)
{
ResultJson result = new ResultJson();
bool flag = false;
if (request.ScoreType.EqualString(Enum_ScoreType.Sport.Enum_GetString()))
{
if (CacheForModelScore.Instance.InsertSportScore(request.UserId))
{
flag = true;
}
}
else if (request.ScoreType.EqualString(Enum_ScoreType.Sleep.Enum_GetString()))
{
if (CacheForModelScore.Instance.InsertSleepScore(request.UserId))
{
flag = true;
}
}
if (flag)
{
result.HttpCode = 200;
result.Message = "用户积分增加";
}
else
{
result.HttpCode = 300;
result.Message = Enum_Message.DataNotSuccessMessage.Enum_GetString();
}
return(result);
}
public IActionResult Get([FromQuery] ScoreRequest request)
{
try
{
if (string.IsNullOrWhiteSpace(request.TimeStamp))
{
return(BadRequest("Timestamp not set in the request"));
}
string[] facilityIds = ParseFacilities();
if (facilityIds.Length == 0)
{
Log.Information($"GetAll returning BadRequest & facility parameter not set in request headers");
return(BadRequest("facility parameter not set"));
}
DateTime dateTimeFormatted = RoundUp(DateTime.Parse(request.TimeStamp), TimeSpan.FromMinutes(30));
var buildingScores = _healthyBuildingRepository
.GetHealthyBuildingScoreTask(ParseFacilities(), dateTimeFormatted).Result;
if (buildingScores.Length == 0)
{
Log.Information($"returning 404 & no data found for Facility ids");
return(NotFound("no data found for Facility ids"));
}
return(Ok(buildingScores));
}
catch (Exception ex)
{
Log.Error($"exception {ex}");
return(StatusCode(500, new { Status = "Error", Message = "Failed in fetching recent aggregated score for healthy buildings" }));
}
}
public static IEnumerator addScore(int score, Action <String> onDone)
{
Dictionary <string, string> headers = new Dictionary <string, string> ();
headers.Add("Content-Type", "application/json");
headers.Add("Token", AppGlobal.token);
ScoreRequest requestData = new ScoreRequest(score);
String requestString = requestData.toJson();
var encoding = new System.Text.UTF8Encoding();
WWW request = new WWW(SCORE_URI, encoding.GetBytes(requestString), headers);
yield return(request);
if (request.error != null)
{
Debug.Log("request error: " + request.error);
}
else
{
Debug.Log("request error: " + request.text);
}
onDone.Invoke("");
}
public override Task <ScoreReply> GetScore(ScoreRequest request, ServerCallContext context)
{
this._logger.LogInformation($"This is ScoreService GetScore {request.LessonId}");
return(Task.FromResult(new ScoreReply()
{
Score = 100
}));
}
public static Score ToScore(this ScoreRequest request)
{
var score = new Score
{
User = String.IsNullOrEmpty(request.User) ? "anon e mouse" : request.User,
Submitted = DateTime.UtcNow,
Deck = Newtonsoft.Json.JsonConvert.SerializeObject(request.Deck),
Lenght = request.Lenght,
Players = request.Players
};
return(score);
}
/// <summary>
/// Call the end point of a scoring experiment and return the results
/// may throw an ApiException if parsing fails
/// </summary>
/// <param name="webServiceUri">scoring web service end point URI</param>
/// <param name="apiKey">scoring web service API key</param>
/// <param name="featureVector">feature vector</param>
/// <param name="globalParameters">global parameters</param>
/// <param name="singleResultInitialization">initialization method for generating response entries</param>
/// <param name="isMultipleResults">true to return multiple results (when available), false to return only one result</param>
/// <returns>scoring results</returns>
private static IList <T> Score <T>(string webServiceUri, string apiKey, Dictionary <string, string> featureVector, Dictionary <string, string> globalParameters, Func <string[], T> singleResultInitialization, bool isMultipleResults = false, IEnumerable <KeyValuePair <string, string> > headers = null)
{
ScoreData scoreData = new ScoreData
{
FeatureVector = featureVector ?? new Dictionary <string, string>(),
GlobalParameters = globalParameters ?? new Dictionary <string, string>()
};
ScoreRequest scoreRequest = new ScoreRequest
{
Id = Guid.NewGuid().ToString(),
Instance = scoreData
};
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
// add any custom headers
if (headers != null)
{
foreach (var header in headers)
{
client.DefaultRequestHeaders.Add(header.Key, header.Value);
}
}
client.BaseAddress = FormatUri(webServiceUri, isMultipleResults);
HttpResponseMessage response = client.PostAsJsonAsync("", scoreRequest).Result;
if (!response.IsSuccessStatusCode)
{
// format all the headers of the response
var headersString = new StringBuilder();
if (response.Headers != null)
{
foreach (var header in response.Headers)
{
headersString.AppendFormat("{0}: {1} {2}", header.Key, string.Join(",", header.Value), Environment.NewLine);
}
}
// once an error happens, collect the response reason + http status + headers to better handle the error
throw new ApplicationException(string.Format("Error getting scoring results: error code: {1} , reason reported:{0} , response headers: {2}", (int)response.StatusCode, response.ReasonPhrase ?? string.Empty, headersString.ToString()));
}
return(ParseResponse(response.Content.ReadAsStringAsync().Result, singleResultInitialization));
}
}
public async Task <bool> IsDeviceReliable(string correlationId, double temperature)
{
try
{
using (var client = new HttpClient())
{
ScoreData scoreData = new ScoreData()
{
FeatureVector = new Dictionary <string, string>()
{
{ "temperature", temperature.ToString() },
},
GlobalParameters = new Dictionary <string, string>()
{
}
};
ScoreRequest scoreRequest = new ScoreRequest()
{
Id = correlationId,
Instance = scoreData
};
string apiKey = CloudConfigurationManager.GetSetting("AzureMLApiKey");
string endpoint = CloudConfigurationManager.GetSetting("AzureMLEndpoint");
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
client.BaseAddress = new Uri(endpoint);
HttpResponseMessage response = await client.PostAsJsonAsync("", scoreRequest);
response.EnsureSuccessStatusCode();
if (response.IsSuccessStatusCode)
{
string result = await response.Content.ReadAsStringAsync();
var array = JArray.Parse(result);
return(array.Last.Value <int>() == 0);
}
}
}
catch (Exception ex)
{
Trace.TraceError("There was an error with AzureML: {0}", ex);
}
return(_defaultReliability == FailAction.Reliable);
}
public void SendPicture(byte[] data)
{
if (!tcpClient.Connected)
{
tcpClient.Connect("localhost", 52200);
}
var stream = tcpClient.GetStream();
Request request = new EmptyRequest();
switch (response.Type)
{
case Response.MessageType.Start:
request = new ImageRequest(data);
break;
case Response.MessageType.Control:
request = new ImageRequest(data);
break;
case Response.MessageType.Result:
request = new ScoreRequest(score);
break;
case Response.MessageType.Finish:
SceneManager.LoadScene(0);
SeriesNumber++;
break;
case Response.MessageType.End:
Application.Quit();
break;
default:
break;
}
var reqBytes = reqSerializer.Serialize(request);
stream.Write(reqBytes, 0, reqBytes.Length);
var receiveBytes = new byte[9];
stream.Read(receiveBytes, 0, receiveBytes.Length);
response = respSerializer.Deserialize(receiveBytes);
Debug.Log(string.Format("{0:0.000} {1:0.000}", response.DeltaAngle, response.DeltaVelocity));
}
public async Task<bool> IsDeviceReliable(string correlationId, double temperature)
{
try
{
using (var client = new HttpClient())
{
ScoreData scoreData = new ScoreData()
{
FeatureVector = new Dictionary<string, string>()
{
{"temperature", temperature.ToString()},
},
GlobalParameters = new Dictionary<string, string>() { }
};
ScoreRequest scoreRequest = new ScoreRequest()
{
Id = correlationId,
Instance = scoreData
};
string apiKey = CloudConfigurationManager.GetSetting("AzureMLApiKey");
string endpoint = CloudConfigurationManager.GetSetting("AzureMLEndpoint");
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
client.BaseAddress = new Uri(endpoint);
HttpResponseMessage response = await client.PostAsJsonAsync("", scoreRequest);
response.EnsureSuccessStatusCode();
if (response.IsSuccessStatusCode)
{
string result = await response.Content.ReadAsStringAsync();
var array = JArray.Parse(result);
return array.Last.Value<int>() == 0;
}
}
}
catch (Exception ex)
{
Trace.TraceError("There was an error with AzureML: {0}", ex);
}
return _defaultReliability == FailAction.Reliable;
}
private ScoreResponse OnUpdateScoreboard(ScoreRequest request, ICommandCallerInfo callerInfo)
{
List <ScoreEntry> points = request.points;
for (int i = 0; i < 5; i++)
{
if (i < points.Count)
{
scoreCanvasUI.transform.Find("Position" + i).GetComponentInChildren <Text>().text = points[i].name + ": " + points[i].value;
}
else
{
scoreCanvasUI.transform.Find("Position" + i).GetComponentInChildren <Text>().text = "";
}
}
return(new ScoreResponse());
}
static async Task InvokeRequestResponseService()
{
using (var client = new HttpClient())
{
ScoreData scoreData = new ScoreData()
{
FeatureVector = new Dictionary <string, string>()
{
{ "vtCOPBRWheelSpeed", "0" },
{ "vtCOPBRMassFlow", "0" },
{ "vtCOPBRRotorDrivePressure", "0" },
{ "vtCOPBRRotorSpeed", "0" },
{ "vtCOPBRFuelConsumption", "0" },
{ "vtCOPBRRotorEfficiency", "0" },
},
GlobalParameters =
new Dictionary <string, string>()
{
}
};
ScoreRequest scoreRequest = new ScoreRequest()
{
Id = "score00001",
Instance = scoreData
};
const string apiKey = "0feHeToqtjZZFTH+2rF17V7C1qo7RVaIs+kT7AkqqI0711KiHBhI8tyFWFT2T4SO1AtSMjZPecBHrmFPCjdOYA=="; // Replace this with the API key for the web service
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
client.BaseAddress = new Uri("https://ussouthcentral.services.azureml.net/workspaces/fc2a1659df5d4f5fb16c9fd6aaebf458/services/c54e29675c0b444083ef6bc655be78f5/score");
HttpResponseMessage response = await client.PostAsJsonAsync("", scoreRequest);
if (response.IsSuccessStatusCode)
{
string result = await response.Content.ReadAsStringAsync();
Console.WriteLine("Result: {0}", result);
}
else
{
Console.WriteLine("Failed with status code: {0}", response.StatusCode);
}
}
}
/// <summary>
/// 添加 成绩
/// </summary>
/// <param name="requestModel"></param>
/// <returns></returns>
public Result <long> Add(ScoreRequest requestModel)
{
if (requestModel == null)
{
return(Result.Error <long>(MsgParameterError));
}
var newScore = new Score()
{
Id = IdHelper.Instance.LongId,
UserId = requestModel.UserId,
ScoreData = requestModel.ScoreData,
};
var result = DbSession.ScoreRepository.Add(newScore);
return(result ? Result.Success(newScore.Id) : Result.Error <long>(MsgAddError));
}
public async Task <IHttpActionResult> ScoreAsync(int id, ScoreRequest request)
{
DAL.Models.Match match = await UnitOfWork.GetMatchRepository().SelectByIdAsync(id)
?? throw new ActionCannotBeExecutedException(ExceptionMessages.MatchNotFound);
if (!match.Players.Any(p => p.Id != request.AuthorId))
{
throw new ActionCannotBeExecutedException(ExceptionMessages.PlayerNotFound + $" In match by Id : {id} UserId : {request.AuthorId}");
}
IPlayerRepository playerRepo = UnitOfWork.GetPlayerRepository();
DAL.Models.Player author = await playerRepo.SelectByIdAsync(request.AuthorId)
?? throw new ActionCannotBeExecutedException(ExceptionMessages.PlayerNotFound);
DAL.Models.Player assistant = null;
if (request.AssistantId.HasValue)
{
if (!match.Players.Any(p => p.Id != request.AssistantId.Value))
{
throw new ActionCannotBeExecutedException(ExceptionMessages.PlayerNotFound + $" In match by Id : {id} UserId : {request.AuthorId}");
}
assistant = await playerRepo.SelectByIdAsync(request.AssistantId.Value)
?? throw new ActionCannotBeExecutedException(ExceptionMessages.PlayerNotFound);
if (assistant.TeamId != author.TeamId)
{
throw new ActionCannotBeExecutedException(ExceptionMessages.TeamsMustBeSame);
}
}
match.Goals.Add(new DAL.Models.Goal
{
Author = author,
Assistant = assistant,
GoalDt = DateTimeOffset.Now,
Team = author.Team
});
await UnitOfWork.SaveChangesAsync();
return(Ok());
}
public ScoreResponse Save(ScoreRequest request)
{
bool newRecord = false;
var lastMaxScore = GetMaxScore();
if (request.TotalScore > lastMaxScore.TotalScore && lastMaxScore.TotalScore > 0)
{
newRecord = true;
}
var score = new Score(request.GameDate, request.TotalScore, newRecord);
if (score.Valid)
{
scoreRepository.Save(score);
}
return((ScoreResponse)score);
}
public void Should_Add_New_Score()
{
ScoreRequest scoreRequest = new ScoreRequest
{
GameDate = DataGenerator.GameDateValid,
TotalScore = DataGenerator.TotalScoreValid
};
scoreService.Save(scoreRequest);
scoreRepositoryMock.Verify(x =>
x.Save(
It.Is <Score>(s =>
s.GameDate == scoreRequest.GameDate &&
s.TotalScore == scoreRequest.TotalScore &&
s.IsRecord == false
)
)
);
}
public async Task <IActionResult> Post([FromBody] ScoreRequest value)
{
if (ModelState.IsValid)
{
//fix values
var dbvalue = value.ToScore();
var current = _thresholdService.UpdateThreshold(dbvalue.Lenght, dbvalue.Players);
//add and save to db
_context.Scores.Add(dbvalue);
await _context.SaveChangesAsync();
SendGameToVerify(dbvalue);
return(Ok(current));
}
else
{
return(BadRequest(ModelState));
}
}
public void Should_Add_New_Score_Record()
{
scoreRepositoryMock.Setup(x => x.GetMaxScore()).Returns(1);
ScoreRequest scoreRequest = new ScoreRequest
{
GameDate = DataGenerator.GameDateValid,
TotalScore = DataGenerator.TotalScoreValid
};
scoreService.Save(scoreRequest);
scoreRepositoryMock.Verify(x =>
x.Save(
It.Is <Score>(s =>
s.GameDate == scoreRequest.GameDate &&
s.TotalScore == scoreRequest.TotalScore &&
s.IsRecord == true
)
)
);
}
public static async Task <string> ProcessScoreRequest(ScoreRequest scoreRequest, bool scoreResult = true)
{
Logging.LogMessage(LogLevel.Info, $"Processing Range:{scoreRequest.Range.From}-{scoreRequest.Range.To}");
var saveRequests = new List <Task <((string bucketName, string key), PutObjectResponse response)> >();
var items = (await GetItemsFromS3(scoreRequest)).ToList();
var scoredResults = items.Where(i => i != null).Select(ScoreResult)
.ToList();
var max = scoredResults.Max(r => r.Score);
var scoredResultsWithRatings = scoredResults
.Select(c =>
{
c.Rating = ((c.Score / max) * 100.0).GetRating().FormatRating();
return(c);
})
.ToList();
var itemsJson = JsonConvert.SerializeObject(scoredResultsWithRatings);
var keyPrefix = $"{Config.ScoresOutputPrefix}output-{scoreRequest.Range.From}-{scoreRequest.Range.To}";
saveRequests.Add(SaveToS3Object(itemsJson, Config.PublicBucketName, $"{keyPrefix}-{DateTimeOffset.UtcNow.ToUnixTimeSeconds()}.json"));
// update latest if the Score request is equivalent to the default lookup range
if (scoreRequest.Range.From == DefaultRange.From && scoreRequest.Range.To == DefaultRange.To)
{
if (scoreRequest.Range.To >= 100)
{
var worst100ItemsJson = JsonConvert.SerializeObject(scoredResultsWithRatings.OrderBy(c => c.Score).Take(100));
var nextItemsJson = JsonConvert.SerializeObject(scoredResultsWithRatings.OrderBy(c => c.Score).Skip(100));
saveRequests.Add(SaveToS3Object(worst100ItemsJson, Config.PublicBucketName, $"{Config.ScoresOutputPrefix}output-0-100-latest.json"));
saveRequests.Add(SaveToS3Object(nextItemsJson, Config.PublicBucketName, $"{Config.ScoresOutputPrefix}output-100-{scoreRequest.Range.To}-latest.json"));
}
saveRequests.Add(SaveToS3Object(itemsJson, Config.PublicBucketName, $"{keyPrefix}-latest.json"));
}
await Task.WhenAll(saveRequests);
Logging.LogMessage(LogLevel.Info, $"Found {items.Count} items and saved {scoredResults.Count} of them, max score was {max}");
return(string.Join('|', saveRequests.Select(r => $"{r.Result.Item1.bucketName}/{r.Result.Item1.key}")));
}
/// <summary>
/// 修改 成绩
/// </summary>
/// <param name="id"></param>
/// <param name="requestModel"></param>
/// <returns></returns>
public Result Edit(long id, ScoreRequest requestModel)
{
if (id < 1 || requestModel == null)
{
return(Result.Error(MsgParameterError));
}
var currentScore = DbSession.ScoreRepository.Get(id);
if (currentScore == null)
{
return(Result.Error("该成绩不存在！"));
}
currentScore.UserId = requestModel.UserId;
currentScore.ScoreData = requestModel.ScoreData;
var result = DbSession.ScoreRepository.Update(currentScore);
return(result ? Result.Success(MsgEditSuccess) : Result.Error(MsgEditError));
}
public ActionResult <ScoreResponse> Add([FromBody] ScoreRequest request)
{
var response = scoreService.Save(request);
if (!response.Notifications.Any())
{
try
{
unitOfWork.Commit();
return(Created(string.Empty, response));
}
catch (Exception ex)
{
return(StatusCode(500, $"Houve um problema interno com o servidor. Entre em contato com o Administrador do sistema caso o problema persista. Erro interno: {ex.Message}"));
}
}
else
{
response.Notifications = response.Notifications;
return(BadRequest(response));
}
}
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='quizid'>
/// </param>
/// <param name='attemptid'>
/// </param>
/// <param name='scoreReq'>
/// </param>
public static AttemptScore CalculateAttemptScore(this IQuizAPIClient operations, string quizid, string attemptid, ScoreRequest scoreReq)
{
return(Task.Factory.StartNew(s => ((IQuizAPIClient)s).CalculateAttemptScoreAsync(quizid, attemptid, scoreReq), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='quizid'>
/// </param>
/// <param name='attemptid'>
/// </param>
/// <param name='scoreReq'>
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <AttemptScore> CalculateAttemptScoreAsync(this IQuizAPIClient operations, string quizid, string attemptid, ScoreRequest scoreReq, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.CalculateAttemptScoreWithHttpMessagesAsync(quizid, attemptid, scoreReq, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public async Task <HttpResponseMessage> PostScore(string quizid, string attemptid, [FromBody] ScoreRequest scoreReq)
{
var quiz = quizRepo.FindQuiz(quizid);
if (quiz == null)
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
var attempt = attemptsRepo.FindAttempt(quizid, attemptid);
if (attempt == null)
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
if (scoreReq == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
// Calculate score for the given attempt and store this:
var score = attempt.Score(scoreReq.Answers, quizRepo);
attemptsRepo.StoreAttemptScore(quizid, attemptid, score);
// Raise webhook when score was posted and recorded:
await this.NotifyAllAsync("attemptscored", new { quizid = quizid, attemptid = attemptid });
//await this._manager.NotifyAllAsync("attemptscored", new { QuizId = quizid, AttemptId = attemptid });
return(Request.CreateResponse(HttpStatusCode.OK, score));
}
public ReturnScore Index(ScoreRequest request)
{
var frames = request.Frames;
var tenthFrame = request.TenthFrame;
if (frames.Count > 9)
{
return new ReturnScore
{
HasErrors = true,
Errors = new List <string> {
"Cannot have more than 9 standard frames"
}
}
}
;
var scores = new ReturnScore
{
Errors = new List <string>(),
HasErrors = false,
Scores = new List <int>()
};
for (var i = 0; i < frames.Count; i++)
{
var frame = frames[i];
try
{
frame.ValidateInput();
if (i == frames.Count - 1)
{
scores.Scores.Add(frame.ScoreFrame(tenthFrame.MarkOne, tenthFrame.MarkTwo));
}
else
{
if (!string.IsNullOrEmpty(frames[i + 1].MarkTwo))
{
scores.Scores.Add(frame.ScoreFrame(frames[i + 1].MarkOne, frames[i + 1].MarkTwo));
}
else if (i < frames.Count - 2)
{
scores.Scores.Add(frame.ScoreFrame(frames[i + 1].MarkOne, frames[i + 2].MarkOne));
}
else if (i < frames.Count - 1) // scoring 8th frame
{
scores.Scores.Add(frame.ScoreFrame(frames[i + 1].MarkOne, tenthFrame.MarkOne));
}
else // 9th frame
{
scores.Scores.Add(frame.ScoreFrame(tenthFrame.MarkOne, tenthFrame.MarkTwo));
}
}
}
catch (Exception ex)
{
scores.HasErrors = true;
scores.Errors.Add(ex.Message);
}
}
try
{
tenthFrame.ValidateTenthFrame();
scores.Scores.Add(tenthFrame.ScoreFrame());
}
catch (Exception ex)
{
scores.HasErrors = true;
scores.Errors.Add(ex.Message);
}
return(scores);
}
}
