public async Task <IActionResult> CreateSwap([FromBody] SwapRequest model)
{
if (model.Amount1 <= 0 || model.Amount2 <= 0)
{
throw new BackendException("Amount can't be less or equal to zero", ErrorCode.BadInputParameter);
}
await ValidateAddress(model.MultisigCustomer1);
await ValidateAddress(model.MultisigCustomer2);
var asset1 = await _assetRepository.GetItemAsync(model.Asset1);
if (asset1 == null)
{
throw new BackendException("Provided Asset1 is missing in database", ErrorCode.AssetNotFound);
}
var asset2 = await _assetRepository.GetItemAsync(model.Asset2);
if (asset2 == null)
{
throw new BackendException("Provided Asset2 is missing in database", ErrorCode.AssetNotFound);
}
var transactionId = await _builder.AddTransactionId(model.TransactionId, $"Swap: {model.ToJson()}");
await _transactionQueueWriter.AddCommand(transactionId, TransactionCommandType.Swap, new SwapCommand
{
MultisigCustomer1 = model.MultisigCustomer1,
Amount1 = model.Amount1,
Asset1 = model.Asset1,
MultisigCustomer2 = model.MultisigCustomer2,
Amount2 = model.Amount2,
Asset2 = model.Asset2
}.ToJson());
return(Ok(new TransactionIdResponse
{
TransactionId = transactionId
}));
}
private async Task MapSwapRequestIdentitiesAsync(SwapRequest swapRequest, string teamId, ILogger log)
{
log.LogTrace($"{nameof(SenderSwapRequestHandler)}:{nameof(MapSwapRequestIdentitiesAsync)}:Started");
var loadScheduleTasks = DateTime.UtcNow
.Range(_teamOptions.PastWeeks, _teamOptions.FutureWeeks, _teamOptions.StartDayOfWeek)
.Select(w => _scheduleCacheService.LoadScheduleAsync(teamId, w));
var cacheModels = await Task.WhenAll(loadScheduleTasks).ConfigureAwait(false);
var fromShift = FindShift(cacheModels, swapRequest.SenderShiftId);
var toShift = FindShift(cacheModels, swapRequest.RecipientShiftId);
if (fromShift != null)
{
swapRequest.TargetSenderShiftId = fromShift.WfmShiftId;
swapRequest.TargetSenderUserId = fromShift.WfmEmployeeId;
var employee = await _cacheService.GetKeyAsync <EmployeeModel>(ApplicationConstants.TableNameEmployees, swapRequest.SenderUserId).ConfigureAwait(false);
if (employee != null)
{
swapRequest.TargetSenderLoginName = GetTargetLoginName(employee.WfmLoginName);
}
}
if (toShift != null)
{
swapRequest.TargetRecipientShiftId = toShift.WfmShiftId;
swapRequest.TargetRecipientUserId = toShift.WfmEmployeeId;
var employee = await _cacheService.GetKeyAsync <EmployeeModel>(ApplicationConstants.TableNameEmployees, swapRequest.RecipientUserId).ConfigureAwait(false);
if (employee != null)
{
swapRequest.TargetRecipientLoginName = GetTargetLoginName(employee.WfmLoginName);
}
}
}
public Task Swap(SwapRequest swapRequest, CancellationToken cancellationToken) => this.SendAsync <SwapRequest, EmptyResponse>(swapRequest, HttpMethod.Post, "/api/ORCA/v1/swap", cancellationToken);
protected abstract Task SaveChangeResultAsync(SwapRequest swapRequest, HttpStatusCode statusCode = HttpStatusCode.OK, string errorCode = "", string errorMessage = "");
protected async Task SaveChangeDataAsync(SwapRequest swapRequest, ChangeData changeData)
{
var cacheId = GetSwapRequestCacheId(swapRequest);
await _cacheService.SetKeyAsync(ApplicationConstants.TableNameChangeData, cacheId, changeData, true).ConfigureAwait(false);
}
protected async Task DeleteChangeDataAsync(SwapRequest swapRequest)
{
var cacheId = GetSwapRequestCacheId(swapRequest);
await _cacheService.DeleteKeyAsync(ApplicationConstants.TableNameChangeData, cacheId).ConfigureAwait(false);
}
protected static string GetSwapRequestCacheId(SwapRequest swapRequest)
{
return($"{swapRequest.SenderShiftId}_{swapRequest.RecipientShiftId}");
}
/// <summary>
/// Add swap transaction to queue for building
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='model'>
/// </param>
public static object ApiEnqueueTransactionSwapPost(this IBitcoinApi operations, SwapRequest model = default(SwapRequest))
{
return(System.Threading.Tasks.Task.Factory.StartNew(s => ((IBitcoinApi)s).ApiEnqueueTransactionSwapPostAsync(model), operations, System.Threading.CancellationToken.None, System.Threading.Tasks.TaskCreationOptions.None, System.Threading.Tasks.TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
/// <summary>
/// Add swap transaction to queue for building
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='model'>
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async System.Threading.Tasks.Task <object> ApiEnqueueTransactionSwapPostAsync(this IBitcoinApi operations, SwapRequest model = default(SwapRequest), System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken))
{
using (var _result = await operations.ApiEnqueueTransactionSwapPostWithHttpMessagesAsync(model, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
protected override Task SaveChangeResultAsync(SwapRequest swapRequest, HttpStatusCode statusCode = HttpStatusCode.OK, string errorCode = "", string errorMessage = "")
{
// currently nothing to do
return(Task.CompletedTask);
}
public async Task <Request> CreateRequestAsync(string requestType, IFormFile fromImageFile, IFormFile toImageFile, int?userId)
{
var requestRepository = storage.GetRepository <IRequestRepository>();
var requestImageRepository = storage.GetRepository <IRequestImageRepository>();
User user = null;
if (userId.HasValue)
{
var userRepository = storage.GetRepository <IUserRepository>();
user = await userRepository.GetAsync(options =>
{
options.SearchType = UserSearchTypes.ById;
options.UserId = userId.Value;
});
}
Request request;
switch (requestType)
{
case nameof(SwapRequest):
{
if (toImageFile == null)
{
throw new NullReferenceException("If RequestType is Swap, then ToImage cant be a null.");
}
request = new SwapRequest()
{
Discriminator = nameof(SwapRequest)
};
if (user != null)
{
request.UserId = user.UserId;
}
await requestRepository.CreateAsync(request);
RequestImage fromImage = new RequestImage()
{
Request = request
};
await requestImageRepository.CreateAsync(fromImage);
RequestImage toImage = new RequestImage()
{
Request = request
};
await requestImageRepository.CreateAsync(toImage);
await storage.SaveAsync();
fromImage.ImageName = fromImage.ImageId + Path.GetExtension(fromImageFile.FileName);
requestImageRepository.Edit(fromImage);
toImage.ImageName = toImage.ImageId + Path.GetExtension(toImageFile.FileName);
requestImageRepository.Edit(toImage);
await fileService.SaveFileAsync(fromImageFile.OpenReadStream(), Path.Combine(fileService.GlobalRequestImagesPath, fromImage.ImageName));
await fileService.SaveFileAsync(toImageFile.OpenReadStream(), Path.Combine(fileService.GlobalRequestImagesPath, toImage.ImageName));
break;
}
case nameof(CutRequest):
{
request = new CutRequest()
{
Discriminator = nameof(CutRequest)
};
if (user != null)
{
request.UserId = user.UserId;
}
await requestRepository.CreateAsync(request);
RequestImage fromImage = new RequestImage()
{
Request = request
};
await requestImageRepository.CreateAsync(fromImage);
await storage.SaveAsync();
fromImage.ImageName = fromImage.ImageId + Path.GetExtension(fromImageFile.FileName);
requestImageRepository.Edit(fromImage);
await fileService.SaveFileAsync(fromImageFile.OpenReadStream(), Path.Combine(fileService.GlobalRequestImagesPath, fromImage.ImageName));
break;
}
case nameof(DetectRequest):
{
request = new DetectRequest()
{
Discriminator = nameof(DetectRequest)
};
if (user != null)
{
request.UserId = user.UserId;
}
await requestRepository.CreateAsync(request);
RequestImage fromImage = new RequestImage()
{
Request = request
};
await requestImageRepository.CreateAsync(fromImage);
await storage.SaveAsync();
fromImage.ImageName = fromImage.ImageId + Path.GetExtension(fromImageFile.FileName);
requestImageRepository.Edit(fromImage);
await fileService.SaveFileAsync(fromImageFile.OpenReadStream(), Path.Combine(fileService.GlobalRequestImagesPath, fromImage.ImageName));
break;
}
default:
{
throw new KeyNotFoundException($"RequestType is {requestType} not exist.");
}
}
;
await storage.SaveAsync();
return(request);
}
/// <summary>
/// Add swap transaction to queue for building
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='model'>
/// </param>
public static object ApiEnqueueTransactionSwapPost(this IBitcoinApi operations, SwapRequest model = default(SwapRequest))
{
return(operations.ApiEnqueueTransactionSwapPostAsync(model).GetAwaiter().GetResult());
}
