public IActionResult UpdateTracker([FromRoute] Guid trackerId, [FromBody] TrackerRequest request)
{
var userId = User.GetUserId();
var customizations = _mapper.Map <TrackerCustomizationSettings>(request.CustomizationSettings);
_trackerService.EditEventTracker(userId, trackerId, request.Name, customizations);
return(Ok());
}
public IActionResult CreateTracker([FromBody] TrackerRequest request)
{
var userId = User.GetUserId();
var customizationSettings = _mapper.Map <TrackerCustomizationSettings>(request.CustomizationSettings);
var trackerId = _trackerService.CreateEventTracker(userId, request.Name, customizationSettings);
return(Ok(_mapper.Map <TrackerPostResponse>(trackerId)));
}
public void RequestToDomain_TrackerRequestToTrackerCustomizationSettings()
{
//arrange
const string scaleMeasurementUnit = "unit";
var trackerRequest = new TrackerRequest
{
Name = "Name1",
CustomizationSettings = new CustomizationSettingsRequest
{
ScaleMeasurementUnit = scaleMeasurementUnit,
IsPhotoRequired = true,
IsScaleRequired = true,
IsRatingRequired = true,
IsGeotagRequired = true,
IsCommentRequired = true,
IsCustomizationRequired = true
}
};
var config = new MapperConfiguration(
cfg =>
{
//map TrackerRequest => TrackerCustomizationSettings
cfg.CreateMap <TrackerRequest, TrackerCustomizationSettings>()
.ConstructUsing(x =>
new TrackerCustomizationSettings(
x.CustomizationSettings.IsPhotoRequired,
x.CustomizationSettings.IsScaleRequired,
x.CustomizationSettings.ScaleMeasurementUnit,
x.CustomizationSettings.IsRatingRequired,
x.CustomizationSettings.IsGeotagRequired,
x.CustomizationSettings.IsCommentRequired,
x.CustomizationSettings.IsCustomizationRequired
));
});
var mapper = new Mapper(config);
//act
var trackerCustomizationSettings = mapper.Map <TrackerRequest, TrackerCustomizationSettings>(trackerRequest);
//assert
Assert.AreEqual(
new TrackerCustomizationSettings(
true,
true,
scaleMeasurementUnit,
true,
true,
true,
true),
trackerCustomizationSettings);
}
private async Task SendRequest(TrackerRequest request, IPEndPoint endpoint)
{
// We add the new request to pending requests, so that we can easily find the source for incoming responses
lock (pendingRequests)
{
pendingRequests[request.TransactionID] = request;
}
// TODO: Send twice?
var result = socket.BeginSendTo(request.Data, 0, request.Length, SocketFlags.None, endpoint, null, socket);
int sentByteCount = await Task <int> .Factory.FromAsync(result, socket.EndSend);
Stats.IncreaseUploadedBytes(sentByteCount);
}
private async Task <Packet> WaitForPacketArrival(TrackerRequest request, CancellationToken cancellationToken)
{
Packet responsePacket = null;
while (true)
{
responsePacket = request.ResponsePacket;
if (responsePacket != null)
{
break;
}
cancellationToken.ThrowIfCancellationRequested();
await Task.Delay(20);
}
return(responsePacket);
}
private async Task SendRequest(TrackerRequest request)
{
if (request.IsIPv6)
{
if (trackerEndpointV6 == null)
{
return;
}
await SendRequest(request, trackerEndpointV6);
}
else
{
if (trackerEndpointV4 == null)
{
return;
}
await SendRequest(request, trackerEndpointV4);
}
}
private async Task <Packet> WaitForResponse(TrackerRequest request, int minimumResponseLength)
{
if (request == null)
{
return(null);
}
int retryCount = 0;
Packet responsePacket = null;
try
{
while (retryCount < RetryAttempts && (isConnected || request.Action == TrackerUdpAction.Connect))
{
var waitForPacketCancelToken = new CancellationTokenSource();
try
{
int timeout = (15 * (int)Math.Pow(2, retryCount)) * 1000;
lock (cancellationTokens)
{
cancellationTokens.Add(waitForPacketCancelToken);
}
waitForPacketCancelToken.CancelAfter(timeout);
responsePacket = await WaitForPacketArrival(request, waitForPacketCancelToken.Token);
break;
}
catch (OperationCanceledException)
{
++retryCount;
// Try sending the request again
await SendRequest(request);
}
finally
{
// We remove the cancellation token
lock (cancellationTokens)
{
cancellationTokens.Remove(waitForPacketCancelToken);
}
}
}
}
finally
{
// We remove the request from pending requests after this
lock (pendingRequests)
{
pendingRequests.Remove(request.TransactionID);
}
}
if (responsePacket == null)
{
if (!isConnected && request.Action != TrackerUdpAction.Connect)
{
throw new TrackerException(TrackerStatus.Offline, "The request was cancelled, because we are no longer connected to the tracker.");
}
else if (retryCount >= RetryAttempts)
{
isConnected = false;
isConnectedV4 = false;
isConnectedV6 = false;
throw new TrackerException(TrackerStatus.Offline, "The request timed out.");
}
}
// We make sure that there is a packet and that it's large enough to fit the header
if (responsePacket == null || responsePacket.Length < 8)
{
return(null);
}
var responseAction = (TrackerUdpAction)responsePacket.ReadInt32();
int responseTransactionID = responsePacket.ReadInt32();
if (responseTransactionID != request.TransactionID)
{
return(null);
}
if (responseAction == TrackerUdpAction.Error)
{
// The response was an error
int errorMessageLength = responsePacket.Length - responsePacket.Offset;
string errorMessage = responsePacket.ReadString(errorMessageLength);
throw new TrackerException(TrackerStatus.OK, errorMessage);
}
else if (responseAction != request.Action)
{
// The response action is different
return(null);
}
// We make sure that the response packet is of correct size
minimumResponseLength = Math.Max(minimumResponseLength, 8); // The minimum response length can't be lower than 8 bytes
if (responsePacket.Length < minimumResponseLength)
{
return(null);
}
return(responsePacket);
}
