public static async Task Recompute_Success()
{
const string UserId = "SomeUserId";
var model = new RecomputeRequest
{
UploadIds = new[] { 0, 1, 2 },
Priority = UploadProcessingMessagePriority.High,
};
var mockDatabaseCommandFactory = new Mock <IDatabaseCommandFactory>(MockBehavior.Strict);
List <UploadProcessingMessage> messages = null;
var mockUploadScheduler = new Mock <IUploadScheduler>(MockBehavior.Strict);
mockUploadScheduler
.Setup(_ => _.ScheduleAsync(It.IsAny <IEnumerable <UploadProcessingMessage> >()))
.Callback <IEnumerable <UploadProcessingMessage> >(_ => messages = _.ToList())
.Returns(Task.CompletedTask);
var mockUser = new Mock <ClaimsPrincipal>(MockBehavior.Strict);
var mockUserManager = MockUserManager.CreateMock();
mockUserManager
.Setup(_ => _.GetUserId(mockUser.Object))
.Returns(UserId);
var mockHttpContext = new Mock <HttpContext>(MockBehavior.Strict);
mockHttpContext.SetupGet(_ => _.User).Returns(mockUser.Object);
var controller = new AdminController(
mockDatabaseCommandFactory.Object,
mockUploadScheduler.Object,
mockUserManager.Object);
controller.ControllerContext = new ControllerContext {
HttpContext = mockHttpContext.Object
};
await controller.Recompute(model);
Assert.Equal(model.UploadIds.Count, messages.Count);
for (var i = 0; i < messages.Count; i++)
{
Assert.Equal(model.UploadIds[i], messages[i].UploadId);
Assert.Equal(model.Priority, messages[i].Priority);
Assert.Equal(UserId, messages[i].Requester);
}
mockDatabaseCommandFactory.VerifyAll();
mockUploadScheduler.VerifyAll();
mockUser.VerifyAll();
mockHttpContext.VerifyAll();
// Workaround for a Moq bug. See: https://github.com/moq/moq4/issues/456#issuecomment-331692858
mockUserManager.Object.Logger = mockUserManager.Object.Logger;
mockUserManager.VerifyAll();
}
public Task Recompute(RecomputeRequest model)
{
var userId = this.userManager.GetUserId(this.User);
var messages = model.UploadIds.Select(uploadId => new UploadProcessingMessage {
UploadId = uploadId, Requester = userId, Priority = model.Priority
});
return(this.uploadScheduler.ScheduleAsync(messages));
}
public virtual ActionResult Recompute([FromBody] RecomputeRequest request)
{
// gets the action with the same name as the argument
var action = _codecAction.SubActions.FirstOrDefault(c => c.Name.Equals(request.Action));
// if action not found
if (action == null)
{
return(Json(ReturnResult <string> .Fail("Action not found")));
}
// retrieve the quant
var quantArray = JsonHelper.RetrieveQuantsArray(request.Params.QuantizationFactorsArray);
foreach (var _action in _codecAction.SubActions)
{
_action.Parameters[Constants.PARAM_NAME_QUANT_FACTORS_ARRAY] = quantArray;
_action.Parameters[Constants.PARAM_NAME_ENTROPY_ALGORITHM] = JsonHelper.CastTo <EntropyAlgorithm>(request.Params.EntropyAlgorithm);
}
// retrive tiles from Inputs
var tileList = new List <Tile>();
foreach (var tileJson in request.Inputs)
{
Triplet <string> triplet = JsonHelper.RetrieveTriplet(tileJson);
string dataFormat = request.Params.UseDataFormat;
Tile tile = null;
if (dataFormat.Equals(Constants.DataFormat.HEX))
{
tile = Tile.FromStrings(triplet, new HexTileSerializer());
}
else
{
tile = Tile.FromStrings(triplet, new IntegerTileSerializer());
}
if (dataFormat.Equals(Constants.DataFormat.FixedPoint_11_5))
{
tile.RightShift(5);
}
if (dataFormat.Equals(Constants.DataFormat.FixedPoint_12_4))
{
tile.RightShift(4);
}
tileList.Add(tile);
}
var result = action.DoAction(tileList.FirstOrDefault());
// recompute the following steps and update
bool following = false;
Tile input = result;
foreach (var act in _codecAction.SubActions)
{
if (following)
{
result = act.DoAction(input);
input = result;
}
else
{
if (act.Name.Equals(request.Action))
{
following = true;
}
}
}
return(Json(ReturnResult <string> .Success("Success")));
}
public override ActionResult Recompute([FromBody] RecomputeRequest request)
{
// TODO: Add parameters obtain into a function
string name = JsonHelper.CastTo <string>(request.Action);
// gets the action with the same name as the argument
var action = _codecAction.SubActions.SingleOrDefault(c => c.Name.Equals(name));
// if action not found
if (action == null)
{
return(Json(ReturnResult <string> .Fail("Action not found")));
}
// retrieve the quant
var quantArray = JsonHelper.RetrieveQuantsArray(request.Params.QuantizationFactorsArray);
_codecAction.Parameters[Constants.PARAM_NAME_QUANT_FACTORS_ARRAY] = quantArray;
// retrive the progressive quants
var progQuantList = new List <QuantizationFactorsArray>();
foreach (var layer in request.Params.ProgQuantizationArray)
{
var layerQuants = JsonHelper.RetrieveQuantsArray(layer);
progQuantList.Add(layerQuants);
}
var progQuantarray = new ProgressiveQuantizationFactors
{
ProgQuants = progQuantList
};
_codecAction.Parameters[Constants.PARAM_NAME_PROGRESSIVE_QUANT_LIST] = progQuantarray;
_codecAction.Parameters[Constants.PARAM_NAME_ENTROPY_ALGORITHM] = JsonHelper.CastTo <EntropyAlgorithm>(request.Params.EntropyAlgorithm);
_codecAction.Parameters[Constants.PARAM_NAME_USE_REDUCE_EXTRAPOLATE] = JsonHelper.CastTo <UseReduceExtrapolate>(request.Params.UseReduceExtrapolate);
// TODO: error handle
var preFramePath = this.HttpContext.Session.Get <string>(PreviousFrameImage);
Frame preFrame = Utility.GetPreviousFrame(preFramePath, _codecAction.Parameters);
ICodecAction diffing = _codecAction.SubActions.SingleOrDefault(c => c.Name.Equals(Constants.PENCODE_NAME_SUBBANDDIFFING));
diffing.Parameters[Constants.PARAM_NAME_PREVIOUS_FRAME] = preFrame;
// retrive tiles from Inputs
var tileList = new List <Tile>();
foreach (var tileJson in request.Inputs)
{
Triplet <string> triplet = JsonHelper.RetrieveTriplet(tileJson);
string dataFormat = request.Params.UseDataFormat;
Tile tile = null;
if (dataFormat.Equals(Constants.DataFormat.HEX))
{
tile = Tile.FromStrings(triplet, new HexTileSerializer());
}
else
{
tile = Tile.FromStrings(triplet, new IntegerTileSerializer());
}
if (dataFormat.Equals(Constants.DataFormat.FixedPoint_11_5))
{
tile.RightShift(5);
}
if (dataFormat.Equals(Constants.DataFormat.FixedPoint_12_4))
{
tile.RightShift(4);
}
tileList.Add(tile);
}
var result = action.DoAction(tileList.ToArray());
// recompute the following steps and update
bool following = false;
Tile[] input = result;
foreach (var act in _codecAction.SubActions)
{
if (following)
{
result = act.DoAction(input);
input = result;
}
else
{
if (act.Name.Equals(name))
{
following = true;
}
}
}
// TODO: recompute the following steps and update
return(Json(ReturnResult <string> .Success("Success")));
}
public override ActionResult Recompute([FromBody] RecomputeRequest request)
{
//dynamic obj = CodecBaseController.GetJsonObject(Request.InputStream);
//int layer = JsonHelper.CastTo<int>(request.Layer);
ICodecAction _rfxDecode = GetDecoderWithParameters(request);
string name = JsonHelper.CastTo <string>(request.Action);
// gets the action with the same name as the argument
var action = _rfxDecode.SubActions.SingleOrDefault(c => c.Name.Equals(name));
// if action not found
if (action == null)
{
return(Json(ReturnResult <string> .Fail("Action not found")));
}
// retrive tiles from Inputs
var tileList = new List <Tile>();
foreach (var tileJson in request.Inputs)
{
Triplet <string> triplet = JsonHelper.RetrieveTriplet(tileJson);
string dataFormat = request.Params.UseDataFormat;
Tile tile = null;
if (dataFormat.Equals(Constants.DataFormat.HEX))
{
tile = Tile.FromStrings(triplet, new HexTileSerializer());
}
else
{
tile = Tile.FromStrings(triplet, new IntegerTileSerializer());
}
if (dataFormat.Equals(Constants.DataFormat.FixedPoint_11_5))
{
tile.RightShift(5);
}
if (dataFormat.Equals(Constants.DataFormat.FixedPoint_12_4))
{
tile.RightShift(4);
}
tileList.Add(tile);
}
// hand over parameters
foreach (var key in _rfxDecode.Parameters.Keys)
{
action.Parameters[key] = _rfxDecode.Parameters[key];
}
var result = action.DoAction(tileList.ToArray());
// recompute the following steps and update
bool following = false;
Tile[] input = result;
foreach (var act in _rfxDecode.SubActions)
{
if (following)
{
// hand over parameters
foreach (var key in _rfxDecode.Parameters.Keys)
{
act.Parameters[key] = _rfxDecode.Parameters[key];
}
result = act.DoAction(input);
input = result;
}
else
{
if (act.Name.Equals(name))
{
following = true;
}
}
}
return(Json(ReturnResult <string> .Success("Success")));
}
