public async Task <IActionResult> BaseAddClaimAsync(int id, ClaimRequest claimRequest, IList <ClaimRequest> existingClaimsRequest, Func <Task> logFunction = null)
{
var result = await CommonOperationAsync <bool>(async() =>
{
var claim = Mapper.Map <Claim>(claimRequest);
var existingClaims = Mapper.Map <IList <Claim> >(existingClaimsRequest);
var response = await _roleManager.AddClaimAsync(id, claim, existingClaims);
if (!response.Succeeded)
{
foreach (var error in response.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
throw new ArgumentException(ModelState.ModelStateToString(LocalizationService));
}
return(true);
});
if (logFunction != null)
{
await logFunction.Invoke();
}
return(Ok(new ApiResponse(LocalizationService, Logger).Ok(result)));
}
/// <summary>
/// claim bulunur database de varsa o alınır yoksa yeni bir claim yaratılır.
/// transaction tanımında claim varsa alır yoksa mastercard sistemden claim numarası alır.
/// alınan claim transaction uzerine kaydeder.
/// </summary>
/// <param name="mscMcomPool"></param>
/// <param name="chargebackFillRequest"></param>
/// <param name="mscMcomTransactionId"></param>
/// <returns></returns>
private MscMcomClaim GetMscMcomClaim(MscMcomPool mscMcomPool, ChargebackFillRequest chargebackFillRequest, MscMcomTransaction mscMcomTransactionId)
{
MscMcomClaim mscMcomClaim = null;
if (!String.IsNullOrWhiteSpace(mscMcomTransactionId.ClaimId))
{
mscMcomClaim = _iTransactionData.GetClaim(mscMcomTransactionId.ClaimId);
}
if (mscMcomClaim == null)
{
mscMcomClaim = new MscMcomClaim();
var claimRequest = new ClaimRequest();
claimRequest.clearingTransactionId = mscMcomTransactionId.ClearingTransactionId;
claimRequest.disputedAmount = chargebackFillRequest.amount;
claimRequest.disputedCurrency = chargebackFillRequest.currency;
claimRequest.claimType = "Standard";
mscMcomClaim.ClaimId = _iClaims.CreateClaim(mscMcomPool.ClearingRefKey, claimRequest);
mscMcomClaim.ClearingTransactionId = mscMcomTransactionId.ClearingTransactionId;
mscMcomClaim.ClrKey = mscMcomPool.ClearingRefKey;
mscMcomClaim.AuthKey = mscMcomPool.ProvisionRefKey;
mscMcomClaim.ClaimStatu = "OPEN";
_iTransactionData.CreateClaim(mscMcomClaim);
mscMcomTransactionId.ClaimId = mscMcomClaim.ClaimId;
_iTransactionData.UpdateClaimId(mscMcomTransactionId);
}
return(mscMcomClaim);
}
public async Task SubmitClaimAsync_Should_Create_New_Claim_Request()
{
using (var context = new WarblerDbContext(Options))
{
var repo = new SqlClaimRequestRepository(context);
var test = new ClaimRequestService(repo);
var request = new ClaimRequest
{
FirstName = "William",
LastName = "Harris",
University = Test,
PositionTitle = "Admin",
Comments = "none",
Submitter = Bob
};
await test.SubmitAsync(request);
}
using (var context = new WarblerDbContext(Options))
{
var claimRequest = context.ClaimRequests.Single();
Assert.AreEqual(1, context.ClaimRequests.Count());
Assert.AreEqual("William", claimRequest.FirstName);
Assert.AreEqual("Harris", claimRequest.LastName);
Assert.AreEqual(Test, claimRequest.University);
Assert.AreEqual("Admin", claimRequest.PositionTitle);
Assert.AreEqual("none", claimRequest.Comments);
}
}
public override async Task ReplaceClaimAsync(TUser user, Claim claim, Claim newClaim, CancellationToken cancellationToken = default)
{
ThrowIfDisposed();
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (claim == null)
{
throw new ArgumentNullException(nameof(claim));
}
if (newClaim == null)
{
throw new ArgumentNullException(nameof(newClaim));
}
var claimRequest = new ClaimRequest
{
Type = claim.Type,
Value = claim.Value
};
var newClaimRequest = new ClaimRequest
{
Type = newClaim.Type,
Value = newClaim.Value
};
await _authenticationService.ReplaceClaimAsync(user.Id, claimRequest, newClaimRequest);
}
public static string ClaimPolicy(Policy policy)
{
ClaimResponse response;
var url = _apiAddress + $"insurance/claim";
var jsonResponse = string.Empty;
_logger.Info($"Calling Claim Policy in executor API: {url}.\n Policy id: { policy.Id } \n");
try
{
var client = GetWebClient();
var request = new ClaimRequest
{
ProductAddress = policy.ProductAddress,
PolicyId = policy.Id,
ClaimProperties = policy.ClaimProperties,
ProductTypeId = policy.ProductTypeId
};
var jsonRequest = JsonConvert.SerializeObject(request);
jsonResponse = client.UploadString(url, "POST", jsonRequest);
response = JsonConvert.DeserializeObject <ClaimResponse>(jsonResponse);
}
catch (Exception e)
{
_logger.Error($"Error in Claim method. Request to path: {url}.\n Response: { jsonResponse } \n", e);
throw;
}
return(response.TxId);
}
public async Task <TokenRequest> GenerateClaimAsync(ClaimRequest claimRequest)
{
var client = claimRequest.TokenRequest.Client;
var user = claimRequest.TokenRequest.User;
var roles = await GetRoleNameAsync(user);
var scopes = await GetScopeNameAsync(client);
if (client != null)
{
claimRequest.TokenRequest.Claims.Add(new Claim(CSharpClaimsIdentity.ClientKeyClaimType, client.Id));
claimRequest.TokenRequest.Claims.Add(new Claim(CSharpClaimsIdentity.ClientIdClaimType, client.ClientId));
claimRequest.TokenRequest.Claims.Add(new Claim(CSharpClaimsIdentity.ClientNameClaimType, client.ClientName));
claimRequest.TokenRequest.Claims.Add(new Claim(CSharpClaimsIdentity.AudienceClaimType, client.ClientUri));
claimRequest.TokenRequest.Claims.Add(new Claim(CSharpClaimsIdentity.ScopesClaimType,
string.Join(",", scopes)));
}
claimRequest.TokenRequest.Claims.Add(new Claim(CSharpClaimsIdentity.IssuerClaimType, claimRequest.TokenRequest.Issuer));
claimRequest.TokenRequest.Claims.Add(new Claim(CSharpClaimsIdentity.DefaultNameClaimType, user.Id));
claimRequest.TokenRequest.Claims.Add(new Claim(CSharpClaimsIdentity.DefaultRoleClaimType,
string.Join(",", roles)));
claimRequest.TokenRequest.Claims.Add(new Claim(CSharpClaimsIdentity.UserNameClaimType, user.UserName));
return(claimRequest.TokenRequest);
}
public ActionResult DeleteConfirmed(int id)
{
ClaimRequest claim = db.Claims.Find(id);
db.Claims.Remove(claim);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <IActionResult> ClaimPullPayment(string pullPaymentId, ViewPullPaymentModel vm)
{
using var ctx = _dbContextFactory.CreateContext();
var pp = await ctx.PullPayments.FindAsync(pullPaymentId);
if (pp is null)
{
ModelState.AddModelError(nameof(pullPaymentId), "This pull payment does not exists");
}
var ppBlob = pp.GetBlob();
var network = _networkProvider.GetNetwork <BTCPayNetwork>(ppBlob.SupportedPaymentMethods.Single().CryptoCode);
var paymentMethodId = ppBlob.SupportedPaymentMethods.Single();
var payoutHandler = _payoutHandlers.FirstOrDefault(handler => handler.CanHandle(paymentMethodId));
IClaimDestination destination = await payoutHandler?.ParseClaimDestination(paymentMethodId, vm.Destination);
if (destination is null)
{
ModelState.AddModelError(nameof(vm.Destination), $"Invalid destination");
}
if (!ModelState.IsValid)
{
return(await ViewPullPayment(pullPaymentId));
}
var result = await _pullPaymentHostedService.Claim(new ClaimRequest()
{
Destination = destination,
PullPaymentId = pullPaymentId,
Value = vm.ClaimedAmount,
PaymentMethodId = new PaymentMethodId(network.CryptoCode, PaymentTypes.BTCLike)
});
if (result.Result != ClaimRequest.ClaimResult.Ok)
{
if (result.Result == ClaimRequest.ClaimResult.AmountTooLow)
{
ModelState.AddModelError(nameof(vm.ClaimedAmount), ClaimRequest.GetErrorMessage(result.Result));
}
else
{
ModelState.AddModelError(string.Empty, ClaimRequest.GetErrorMessage(result.Result));
}
return(await ViewPullPayment(pullPaymentId));
}
else
{
TempData.SetStatusMessageModel(new StatusMessageModel()
{
Message = $"Your claim request of {_currencyNameTable.DisplayFormatCurrency(vm.ClaimedAmount, ppBlob.Currency)} to {vm.Destination} has been submitted and is awaiting approval.",
Severity = StatusMessageModel.StatusSeverity.Success
});
}
return(RedirectToAction(nameof(ViewPullPayment), new { pullPaymentId = pullPaymentId }));
}
public async Task ResolveClaim([FromBody] ClaimRequest claim)
{
if (claim.IsAccepted ?? false)
{
await UniversityService.ApplyClaimAsync(claim.University, claim.SubmitterId);
}
await ClaimRequestService.UpdateAsync(claim);
}
public async Task <ActionResult> Approve(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ClaimRequest request = db.ClaimRequests.Find(id);
if (request == null)
{
return(HttpNotFound());
}
var company = _companyRepository.GetCompany(request.CompanyId);
var userManager = HttpContext.GetOwinContext().GetUserManager <ApplicationUserManager>();
var newUser = new ApplicationUser {
UserName = request.Email, Email = request.Email
};
var password = Guid.NewGuid().ToString().Substring(0, 8) + "!1jK";
var oldUser = await userManager.FindByNameAsync(newUser.UserName);
var resultOfDelete = await userManager.DeleteAsync(oldUser);
if (resultOfDelete.Succeeded)
{
var result = await userManager.CreateAsync(newUser, password);
if (result.Succeeded)
{
await userManager.AddToRoleAsync(newUser.Id, Constants.CompanyRole);
newUser.CompanyId = company.Id;
await userManager.UpdateAsync(newUser);
var subject = "Company registered";
var body = "Your company is registered. Your account password is " + password;
var emailService = new GoogleEmailService(
company.Email,
subject,
company.Name,
body,
true,
false
);
emailService.SendMail();
}
}
request.ClaimStatus = ClaimStatus.Approved;
request.ApproveTime = DateTime.Now;
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task ReplaceClaimAsync(long userId, ClaimRequest claim, ClaimRequest newClaim)
{
var matchedClaims = await GetByClaimAsync(userId, claim.Value, claim.Type);
foreach (var matchedClaim in matchedClaims)
{
matchedClaim.ClaimValue = newClaim.Value;
matchedClaim.ClaimType = newClaim.Type;
}
}
public ActionResult Edit([Bind(Include = "Id,Title,Description,Type,ClaimDate")] ClaimRequest claim)
{
if (ModelState.IsValid)
{
db.Entry(claim).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(claim));
}
public ActionResult Create([Bind(Include = "Id,Title,Description,Type,ClaimDate")] ClaimRequest claim)
{
if (ModelState.IsValid)
{
db.Claims.Add(claim);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(claim));
}
public string GetHipaaResponse(ClaimRequest request)
{
var hipaaRequest = new HipaaRequest {
ClaimDescription = string.Concat(
request.ClaimStatus,
"//",
request.Locationid.ToString(),
"//",
request.ProviderId.ToString())
};
return(_hipaaClient.GetHipaaResponse(hipaaRequest));
}
// GET: Claims/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ClaimRequest claim = db.Claims.Find(id);
if (claim == null)
{
return(HttpNotFound());
}
return(View(claim));
}
public async Task <IActionResult> Update([FromBody] ClaimRequest claimRequest)
{
int result = 0;
try
{
context.Update(claimRequest);
result = await context.SaveChangesAsync();
}
catch (Exception ex)
{
logger.LogError(ex.ToString());
}
return(Ok(result));
}
public ActionResult Reject(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ClaimRequest claimRequest = db.ClaimRequests.Find(id);
if (claimRequest == null)
{
return(HttpNotFound());
}
claimRequest.ClaimStatus = ClaimStatus.Rejected;
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void Ent_Create_NewClaim_ReturnClaimNumber()
{
//arrange
ClaimRequest claimRequest = new ClaimRequest();
claimRequest.disputedAmount = "100.00";
claimRequest.disputedCurrency = "USD";
claimRequest.claimType = "Standard";
claimRequest.clearingTransactionId = "hqCnaMDqmto4wnL+BSUKSdzROqGJ7YELoKhEvluycwKNg3XTz/faIJhFDkl9hW081B5tTqFFiAwCpcocPdB2My4t7DtSTk63VXDl1CySA8Y";
//act
Claims claim = new Claims(apiController);
var result = claim.CreateClaim(claimRequest);
//assert
Assert.That(result, Is.EqualTo("200002020654"));
}
public void ProcessClaim_WithHipaaExternalClient_ReturnProcessedClaim()
{
//Arrange
var hipaaAdapter = new HipaaExternalAdapter();
_service = new ClaimService(hipaaAdapter);
var request = new ClaimRequest {
ClaimStatus = 1, Locationid = 99, ProviderId = 99
};
//Action
var result = _service.ProcessClaim(request);
//Assert
result.Should().Be("1--99--99--Processed");
}
public async Task <IList <UserResult> > GetUsersByClaimAsync(ClaimRequest claim)
{
var existUserClaims = await _userClaimRepository.Get(x => x.ClaimValue == claim.Value && x.ClaimType == claim.Type)
.Select(x => new UserResult()
{
Id = x.UserId,
DisplayName = x.User.DisplayName,
Lastname = x.User.Lastname,
Firstname = x.User.Firstname,
UserName = x.User.UserName,
Email = x.User.Email,
IsEmailConfirmed = x.User.IsEmailConfirmed,
StatusId = x.User.StatusId
}).ToListAsync();
return(existUserClaims);
}
public Task <Claim> CreateAsync(ClaimRequest request)
{
return(CommonOperationAsync(async() =>
{
var result = Mapper.Map <Claim>(request);
var tempResult = await _uow.Claims.GetByCustomClaimAsync(result.CustomClaim);
tempResult.CheckUniqueValue(AuthorizationConstants.CustomClaim);
_uow.Claims.Add(result, GetLoggedInUserId());
await _uow.SaveChangesAsync();
return result;
}, new BusinessBaseRequest {
MethodBase = MethodBase.GetCurrentMethod()
}));
}
/// <summary>
/// Claim a resource by an allowed user Claim a resource by allowing a user to pick an identifier and receive admin access to that resource if it hasn't already been claimed. This only works for resources specifically marked as "CLAIM". The result will be a new access record listing that user as the admin for this resource.
/// </summary>
/// <param name="body"></param>
/// <returns>ClaimResponse</returns>
public async Task <ClaimResponse> CreateClaim(ClaimRequest body)
{
// verify the required parameter 'body' is set
if (body == null)
{
throw new ArgumentNullException("Missing required parameter 'body'.");
}
var path = "/v1/claims";
var client = await authressHttpClientProvider.GetHttpClientAsync();
using (var response = await client.PostAsync(path, body.ToHttpContent()))
{
await response.ThrowIfNotSuccessStatusCode();
return(await response.Content.ReadAsAsync <ClaimResponse>());
}
}
public Task <Claim> UpdateAsync(int id, ClaimRequest request)
{
return(CommonOperationAsync(async() =>
{
var result = await GetByIdAsync(id);
Mapper.Map(request, result);
var tempResult = await _uow.Claims.GetByCustomClaimAsync(result.CustomClaim);
tempResult.CheckUniqueValueForUpdate(id, AuthorizationConstants.CustomClaim);
_uow.Claims.Update(result, GetLoggedInUserId());
await _uow.SaveChangesAsync();
return result;
}, new BusinessBaseRequest {
MethodBase = MethodBase.GetCurrentMethod()
}));
}
public async Task <IList <RoleResult> > GetRolesForClaimAsync(ClaimRequest claim)
{
var existRoleClaims = await _roleClaimRepository.Get(x => x.ClaimValue == claim.Value && x.ClaimType == claim.Type)
.Select(x => new RoleResult()
{
Id = x.RoleId,
CreatedById = x.Role.CreatedById,
CreatedByName = x.Role.CreatedBy.Lastname + " " + x.Role.CreatedBy.Firstname,
CreatedDate = x.Role.CreatedDate,
Description = x.Role.Description,
Name = x.Role.Name,
UpdatedById = x.Role.UpdatedById,
UpdatedByName = x.Role.UpdatedBy.Lastname + " " + x.Role.UpdatedBy.Firstname,
UpdatedDate = x.Role.UpdatedDate
}).ToListAsync();
return(existRoleClaims);
}
public override async Task <IList <TUser> > GetUsersForClaimAsync(Claim claim, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
ThrowIfDisposed();
if (claim == null)
{
throw new ArgumentNullException(nameof(claim));
}
var claimRequest = new ClaimRequest
{
Type = claim.Type,
Value = claim.Value
};
var claimUsers = await _authenticationService.GetUsersByClaimAsync(claimRequest);
var applicationUserClaims = _mapper.Map <IList <TUser> >(claimUsers);
return(applicationUserClaims);
}
public void Create_NewClaim_ReturnClaimNumber()
{
//arrange
apiController.Setup(f => f.Create <ClaimResponse>(It.IsAny <long>(), It.IsAny <String>(), It.IsAny <ClaimRequest>()))
.Returns(new ClaimResponse()
{
claimId = claimId
});
ClaimRequest claimRequest = new ClaimRequest();
claimRequest.disputedAmount = "100.00";
claimRequest.disputedCurrency = "USD";
claimRequest.claimType = "Standard";
claimRequest.clearingTransactionId = "hqCnaMDqmto4wnL+BSUKSdzROqGJ7YELoKhEvluycwKNg3XTz/faIJhFDkl9hW081B5tTqFFiAwCpcocPdB2My4t7DtSTk63VXDl1CySA8Y";
//act
Claims claim = new Claims(apiController.Object);
var result = claim.CreateClaim(0, claimRequest);
//assert
Assert.That(result, Is.EqualTo(claimId));
}
public async Task <IActionResult> ClaimPullPayment(string pullPaymentId, ViewPullPaymentModel vm)
{
using var ctx = _dbContextFactory.CreateContext();
var pp = await ctx.PullPayments.FindAsync(pullPaymentId);
if (pp is null)
{
ModelState.AddModelError(nameof(pullPaymentId), "This pull payment does not exists");
}
var ppBlob = pp.GetBlob();
var paymentMethodId = ppBlob.SupportedPaymentMethods.FirstOrDefault(id => vm.SelectedPaymentMethod == id.ToString());
var payoutHandler = paymentMethodId is null ? null : _payoutHandlers.FindPayoutHandler(paymentMethodId);
if (payoutHandler is null)
{
ModelState.AddModelError(nameof(vm.SelectedPaymentMethod), "Invalid destination with selected payment method");
return(await ViewPullPayment(pullPaymentId));
}
var destination = await payoutHandler.ParseAndValidateClaimDestination(paymentMethodId, vm.Destination, ppBlob);
if (destination.destination is null)
{
ModelState.AddModelError(nameof(vm.Destination), destination.error ?? "Invalid destination with selected payment method");
return(await ViewPullPayment(pullPaymentId));
}
if (vm.ClaimedAmount == 0)
{
ModelState.AddModelError(nameof(vm.ClaimedAmount), "Amount is required");
}
else
{
var amount = ppBlob.Currency == "SATS" ? new Money(vm.ClaimedAmount, MoneyUnit.Satoshi).ToUnit(MoneyUnit.BTC) : vm.ClaimedAmount;
if (destination.destination.Amount != null && amount != destination.destination.Amount)
{
var implied = _currencyNameTable.DisplayFormatCurrency(destination.destination.Amount.Value, paymentMethodId.CryptoCode);
var provided = _currencyNameTable.DisplayFormatCurrency(vm.ClaimedAmount, ppBlob.Currency);
ModelState.AddModelError(nameof(vm.ClaimedAmount),
$"Amount implied in destination ({implied}) does not match the payout amount provided ({provided}).");
}
}
if (!ModelState.IsValid)
{
return(await ViewPullPayment(pullPaymentId));
}
var result = await _pullPaymentHostedService.Claim(new ClaimRequest()
{
Destination = destination.destination,
PullPaymentId = pullPaymentId,
Value = vm.ClaimedAmount,
PaymentMethodId = paymentMethodId
});
if (result.Result != ClaimRequest.ClaimResult.Ok)
{
if (result.Result == ClaimRequest.ClaimResult.AmountTooLow)
{
ModelState.AddModelError(nameof(vm.ClaimedAmount), ClaimRequest.GetErrorMessage(result.Result));
}
else
{
ModelState.AddModelError(string.Empty, ClaimRequest.GetErrorMessage(result.Result));
}
return(await ViewPullPayment(pullPaymentId));
}
TempData.SetStatusMessageModel(new StatusMessageModel
{
Message = $"Your claim request of {_currencyNameTable.DisplayFormatCurrency(vm.ClaimedAmount, ppBlob.Currency)} to {vm.Destination} has been submitted and is awaiting {(result.PayoutData.State == PayoutState.AwaitingApproval? "approval": "payment")}.",
Severity = StatusMessageModel.StatusSeverity.Success
});
return(RedirectToAction(nameof(ViewPullPayment), new { pullPaymentId }));
}
public async Task UpdateAsync(ClaimRequest claimRequest)
{
Context.Update(claimRequest);
await Context.SaveChangesAsync();
}
public async Task CreateAsync(ClaimRequest claimRequest)
{
await Context.AddAsync(claimRequest);
await Context.SaveChangesAsync();
}
public override void ClaimOfferMoney(IRpcController controller, ClaimRequest request, Action<NoData> done)
{
ProtoOutputBuffer.Write(request.GetType(), request.ToString());
}
public override void ClaimOfferMoney(IRpcController controller, ClaimRequest request, Action<NoData> done)
{
throw new NotImplementedException();
}
public async Task <IActionResult> CreatePayout(string pullPaymentId, CreatePayoutRequest request)
{
if (request is null)
{
return(NotFound());
}
if (!PaymentMethodId.TryParse(request?.PaymentMethod, out var paymentMethodId))
{
ModelState.AddModelError(nameof(request.PaymentMethod), "Invalid payment method");
return(this.CreateValidationError(ModelState));
}
var payoutHandler = _payoutHandlers.FirstOrDefault(handler => handler.CanHandle(paymentMethodId));
if (payoutHandler is null)
{
ModelState.AddModelError(nameof(request.PaymentMethod), "Invalid payment method");
return(this.CreateValidationError(ModelState));
}
await using var ctx = _dbContextFactory.CreateContext();
var pp = await ctx.PullPayments.FindAsync(pullPaymentId);
if (pp is null)
{
return(PullPaymentNotFound());
}
var ppBlob = pp.GetBlob();
IClaimDestination destination = await payoutHandler.ParseClaimDestination(paymentMethodId, request.Destination);
if (destination is null)
{
ModelState.AddModelError(nameof(request.Destination), "The destination must be an address or a BIP21 URI");
return(this.CreateValidationError(ModelState));
}
if (request.Amount is decimal v && (v < ppBlob.MinimumClaim || v == 0.0m))
{
ModelState.AddModelError(nameof(request.Amount), $"Amount too small (should be at least {ppBlob.MinimumClaim})");
return(this.CreateValidationError(ModelState));
}
var cd = _currencyNameTable.GetCurrencyData(pp.GetBlob().Currency, false);
var result = await _pullPaymentService.Claim(new ClaimRequest()
{
Destination = destination,
PullPaymentId = pullPaymentId,
Value = request.Amount,
PaymentMethodId = paymentMethodId
});
switch (result.Result)
{
case ClaimRequest.ClaimResult.Ok:
break;
case ClaimRequest.ClaimResult.Duplicate:
return(this.CreateAPIError("duplicate-destination", ClaimRequest.GetErrorMessage(result.Result)));
case ClaimRequest.ClaimResult.Expired:
return(this.CreateAPIError("expired", ClaimRequest.GetErrorMessage(result.Result)));
case ClaimRequest.ClaimResult.NotStarted:
return(this.CreateAPIError("not-started", ClaimRequest.GetErrorMessage(result.Result)));
case ClaimRequest.ClaimResult.Archived:
return(this.CreateAPIError("archived", ClaimRequest.GetErrorMessage(result.Result)));
case ClaimRequest.ClaimResult.Overdraft:
return(this.CreateAPIError("overdraft", ClaimRequest.GetErrorMessage(result.Result)));
case ClaimRequest.ClaimResult.AmountTooLow:
return(this.CreateAPIError("amount-too-low", ClaimRequest.GetErrorMessage(result.Result)));
case ClaimRequest.ClaimResult.PaymentMethodNotSupported:
return(this.CreateAPIError("payment-method-not-supported", ClaimRequest.GetErrorMessage(result.Result)));
default:
throw new NotSupportedException("Unsupported ClaimResult");
}
return(Ok(ToModel(result.PayoutData, cd)));
}
public override void ClaimBidMoney(Google.ProtocolBuffers.IRpcController controller, ClaimRequest request, Action<bnet.protocol.NoData> done) {
throw new NotImplementedException();
}
