public ActionResult Create(int id, TransferRequest transferRequest)
{
var rp = Repository.OfType<RegistrationParticipation>().GetNullableById(id);
if (rp == null)
{
Message = "Registration participation could not be loaded, please try again.";
return RedirectToAction("Index", "Admin");
}
transferRequest.User = Repository.OfType<vUser>().Queryable.FirstOrDefault(a => a.LoginId == User.Identity.Name);
transferRequest.RegistrationParticipation = rp;
ModelState.Clear();
transferRequest.TransferValidationMessagesTo(ModelState);
if (ModelState.IsValid)
{
Message = "Transfer request created.";
Repository.OfType<TransferRequest>().EnsurePersistent(transferRequest);
return RedirectToAction("StudentDetails", "Admin", new {id = rp.Registration.Student.Id});
}
var viewModel = TransferRequestViewModel.Create(Repository, rp, User.Identity.Name);
return View(viewModel);
}
void request_OnComplete(TransferRequest request, AssetType type, UUID assetID, byte[] data)
{
AssetType = type;
AssetID = assetID;
AssetData = data;
Status = StatusCode.Done;
completeEvent.Set();
}
public static TransferRequestViewModel Create(IRepository repository, RegistrationParticipation registrationParticipation, string username, TransferRequest transferRequest = null)
{
var viewModel = new TransferRequestViewModel()
{
Ceremonies = repository.OfType<Ceremony>().Queryable.Where(a => a.TermCode == TermService.GetCurrent()),
RegistrationParticipation = registrationParticipation,
TransferRequest = transferRequest ?? new TransferRequest()
};
return viewModel;
}
void request_OnProgress(TransferRequest request, StatusCode status, int received, int size)
{
Console.WriteLine("Progress {0}, {1}/{2}", status, received, size);
}
public int GerarTransferenciaEntreUsuarios(bool primeiroUsuario, bool SegundoUsuario)
{
Random rand = new Random();
Parallel.For(0, 1000, (i, loop) =>
{
if (rand.Next() == 0)
{
loop.Stop();
}
});
TransferRequest transferRequestCard = new TransferRequest();
transferRequestCard.LocalDate = "1204";
transferRequestCard.LocalTime = "0107";
transferRequestCard.TransactionReference = 4000000001010102028L;
transferRequestCard.SenderName = "John Doe";
transferRequestCard.SenderAddress.Line1 = "123 Main Street";
transferRequestCard.SenderAddress.Line2 = "#5A";
transferRequestCard.SenderAddress.City = "Arlington";
transferRequestCard.SenderAddress.CountrySubdivision = "VA";
transferRequestCard.SenderAddress.PostalCode = 22207;
transferRequestCard.SenderAddress.Country = "USA";
transferRequestCard.FundingCard.AccountNumber = 5184680430000006L;
transferRequestCard.FundingCard.ExpiryMonth = 11;
transferRequestCard.FundingCard.ExpiryYear = 2014;
transferRequestCard.FundingUCAF = "MjBjaGFyYWN0ZXJqdW5rVUNBRjU=1111";
transferRequestCard.FundingMasterCardAssignedId = 123456;
transferRequestCard.FundingAmount.Value = 15000;
transferRequestCard.FundingAmount.Currency = rand.Next();
transferRequestCard.ReceiverName = "Jose Lopez";
transferRequestCard.ReceiverAddress.Line1 = "Pueblo Street";
transferRequestCard.ReceiverAddress.Line2 = "PO BOX 12";
transferRequestCard.ReceiverAddress.City = "El PASO";
transferRequestCard.ReceiverAddress.CountrySubdivision = "TX";
transferRequestCard.ReceiverAddress.PostalCode = 79906;
transferRequestCard.ReceiverAddress.Country = "USA";
transferRequestCard.ReceiverPhone = 1800639426;
transferRequestCard.ReceivingCard.AccountNumber = 5184680430000006L;
transferRequestCard.ReceivingAmount.Value = 182206;
transferRequestCard.ReceivingAmount.Currency = 484;
transferRequestCard.Channel = "W";
transferRequestCard.UCAFSupport = false;
transferRequestCard.ICA = "009674";
transferRequestCard.ProcessorId = 9000000442L;
transferRequestCard.RoutingAndTransitNumber = 990442082;
transferRequestCard.CardAcceptor.Name = "My Local Bank";
transferRequestCard.CardAcceptor.City = "Saint Louis";
transferRequestCard.CardAcceptor.State = "MO";
transferRequestCard.CardAcceptor.PostalCode = 63101;
transferRequestCard.CardAcceptor.Country = "USA";
transferRequestCard.TransactionDesc = "P2P";
transferRequestCard.MerchantId = 123456;
Transfer transfer = service.GetTransfer(transferRequestCard);
if (transfer != null)
{
return(Convert.ToInt32(transfer.TransactionReference));
}
return(0);
}
private static TransferRequestMessage GetTransferRequestMessage()
{
//Should be a contract
var vaspKey = EthECKey.GenerateKey();
var message = new Message(
Guid.NewGuid().ToByteArray().ToHex(prefix: false),
Guid.NewGuid().ToByteArray().ToHex(prefix: false),
"1");
var postalAddress = new PostalAddress(
"TestingStreet",
61,
"Test Address Line",
"410000",
"TownN",
Country.List["DE"]
);
var placeOfBirth = new PlaceOfBirth(DateTime.UtcNow, "TownN", Country.List["DE"]);
var vaspInformation = new VaspInformation(
"Test test",
vaspKey.GetPublicAddress(),
vaspKey.GetPubKey().ToHex(prefix: false),
postalAddress,
placeOfBirth,
new NaturalPersonId[]
{
new NaturalPersonId("SomeId2", NaturalIdentificationType.AlienRegistrationNumber,
Country.List["DE"]),
},
new JuridicalPersonId[]
{
new JuridicalPersonId("SomeId1", JuridicalIdentificationType.BankPartyIdentification,
Country.List["DE"]),
},
"DEUTDEFF");
var originator = new Originator("Originator1", "VaaN", postalAddress, placeOfBirth,
new NaturalPersonId[]
{
new NaturalPersonId("SomeId2", NaturalIdentificationType.AlienRegistrationNumber,
Country.List["DE"]),
},
new JuridicalPersonId[]
{
new JuridicalPersonId("SomeId1", JuridicalIdentificationType.BankPartyIdentification,
Country.List["DE"]),
},
"DEUTDEFF");
var beneficiary = new Beneficiary("Ben1", "VaaN");
var transferRequest = new TransferRequest(VirtualAssetType.ETH, TransferType.BlockchainTransfer, "10000000");
var request = new TransferRequestMessage(message, originator, beneficiary, transferRequest, vaspInformation)
{
Comment = "This is test message",
};
return(request);
}
public async Task <ActionResult <TransferResponse> > Post(TransferRequest request)
{
var result = await _transferenciaFacade.Transferir(request);
return(Response(result));
}
public async Task PostAsync_WithoutCallback_ShouldSuccess()
{
// Arrange.
var amount = new PropertyAmount(10);
var destination = TestAddress.Mainnet1;
var req = new TransferRequest
{
Amount = amount,
Destination = destination,
ReferenceAmount = Money.Satoshis(100)
};
var network = ZcoinNetworks.Instance.GetNetwork(this.zcoinConfig.Network.Type);
var tx = Transaction.Create(network);
var property = new Property(this.zcoinConfig.Property.Id, this.zcoinConfig.Property.Type);
var cancellationToken = new CancellationToken(false);
// Build Mock.
this.propertyManagementRpc.Setup(
r => r.SendAsync
(
this.zcoinConfig.Property.Distributor.Address,
destination,
property,
amount,
Money.Satoshis(100),
cancellationToken
)).ReturnsAsync(tx).Verifiable();
this.rawTransactionRpc.Setup(
r => r.SendAsync
(
tx,
cancellationToken
)).ReturnsAsync(tx.GetHash()).Verifiable();
// Mock context.
ControllerTesting <TransfersController> .SetHttpContext(this.subject);
// Act.
var result = await this.subject.PostAsync(req, cancellationToken);
// Assert.
var objResult = result.As <ObjectResult>();
objResult.StatusCode.Should().Be((int)HttpStatusCode.Accepted);
objResult.Value.Should().BeEquivalentTo(new { Tx = tx.GetHash() });
this.propertyManagementRpc.Verify();
this.rawTransactionRpc.Verify();
// Callback should not be created.
this.callbackRepository.Verify
(
r => r.AddAsync
(
It.IsAny <IPAddress>(),
It.IsAny <Uri>(),
It.IsAny <CancellationToken>()
),
Times.Never()
);
// The transaction should not be watched.
this.watcher.Verify
(
r => r.AddTransactionAsync
(
It.IsAny <uint256>(),
It.IsAny <int>(),
It.IsAny <TimeSpan>(),
It.IsAny <Callback>(),
It.IsAny <CallbackResult>(),
It.IsAny <CallbackResult>(),
It.IsAny <CancellationToken>()
),
Times.Never()
);
}
void prot_Update(object sender, FmdcEventArgs e)
{
Hub hubConnection = sender as Hub;
if (hubConnection != null)
{
switch (e.Action)
{
case Actions.IsReady:
bool isReady = (bool)e.Data;
if (isReady)
{
// TODO: Start testing
var usrlst = hubConnection.Userlist;
User usr = null;
// Find usable user.
foreach (KeyValuePair <string, User> item in usrlst)
{
UserInfo me = hubConnection.Me;
usr = item.Value;
// Check so we are not trying to download from our self.
if (me.ID == usr.ID)
{
continue;
}
if (me.TagInfo.Mode == FlowLib.Enums.ConnectionTypes.Passive)
{
if (usr.Tag.Mode == ConnectionTypes.Direct)
{
_hasFoundUser = true;
break;
}
}
else
{
if (usr.Tag.Mode == ConnectionTypes.Passive)
{
_hasFoundUser = true;
break;
}
}
}
if (_hasFoundUser)
{
// Add filelist for a user
ContentInfo info = new ContentInfo(ContentInfo.FILELIST, BaseFilelist.UNKNOWN);
_filelistPath = currentDir + "Filelists" + System.IO.Path.DirectorySeparatorChar + "downloading" + ".filelist";
info.Set(ContentInfo.STORAGEPATH, _filelistPath);
info.Set("HubStoreId", hubConnection.StoreId);
info.Set(UserInfo.STOREID, usr.StoreID);
downloadManager.AddDownload(new DownloadItem(info), new Source(hubConnection.StoreId, usr.StoreID));
_testTimeoutLength += 10;
}
}
break;
case Actions.TransferRequest:
if (e.Data is TransferRequest)
{
_hasTransferRequest = true;
TransferRequest req = (TransferRequest)e.Data;
if (transferManager.GetTransferReq(req.Key) == null)
{
transferManager.AddTransferReq(req);
}
}
break;
case Actions.TransferStarted:
Transfer trans = e.Data as Transfer;
_hasTransferStarted = true;
if (trans != null)
{
// We could add a TransferRequest here if we wanted.
transferManager.StartTransfer(trans);
trans.Protocol.ChangeDownloadItem += new FmdcEventHandler(Protocol_ChangeDownloadItem);
trans.Protocol.RequestTransfer += new FmdcEventHandler(Protocol_RequestTransfer);
}
break;
}
}
}
/// <summary>
/// Requests an image from SecondLife.
/// </summary>
/// <param name="ImageID">The Image's AssetID</param>
public void RequestImageAsync(LLUUID ImageID)
{
if (ImageID == null)
{
throw new Exception("WTF!!! Don't request Image Assets by passing in an ImageID of null");
}
byte[] imgData = CachedImage(ImageID);
if (imgData != null)
{
FireImageRetrieved(ImageID, imgData, true);
}
lock (htDownloadRequests)
{
if (htDownloadRequests.ContainsKey(ImageID) == false)
{
TransferRequest tr = new TransferRequest();
tr.Size = int.MaxValue; // Number of bytes expected
tr.Received = 0; // Number of bytes received
tr.LastPacket = Helpers.GetUnixTime(); // last time we recevied a packet for this request
htDownloadRequests[ImageID] = tr;
Packet packet = ImagePacketHelper.RequestImage(ImageID);
slClient.Network.SendPacket(packet);
}
}
}
private async Task UploadMultipleDocumentsAsync(IRelativityTransferHost relativityTransferHost, CancellationToken cancellationToken)
{
// Search for the first logical file share.
const int logicalFileShareNumber = 1;
RelativityFileShare fileShare = await GetFileShareAsync(relativityTransferHost, logicalFileShareNumber, cancellationToken).ConfigureAwait(false);
// Configure an Aspera specific transfer.
AsperaClientConfiguration configuration = CreateAsperaClientConfiguration();
// Assigning the file share bypasses auto-configuration that will normally use the default workspace repository.
configuration.TargetFileShare = fileShare;
using (ITransferClient client = await CreateClientAsync(relativityTransferHost, configuration, cancellationToken).ConfigureAwait(false))
using (AutoDeleteDirectory directory = new AutoDeleteDirectory())
{
// Create a job-based upload transfer request.
Console2.WriteTapiStartHeader("Advanced Transfer - Upload");
string uploadTargetPath = GetUniqueRemoteTargetPath(fileShare);
IList <TransferPath> localSourcePaths = await SearchLocalSourcePathsAsync(client, uploadTargetPath, cancellationToken).ConfigureAwait(false);
TransferContext context = CreateTransferContext();
TransferRequest uploadJobRequest = TransferRequest.ForUploadJob(uploadTargetPath, context);
uploadJobRequest.Application = "Github Sample";
uploadJobRequest.Name = "Advanced Upload Sample";
// Create a transfer job to upload the local sample data set to the target remote path.
using (ITransferJob job = await client.CreateJobAsync(uploadJobRequest, cancellationToken).ConfigureAwait(false))
{
Console2.WriteDebugLine("Advanced upload started.");
// Paths added to the async job are transferred immediately.
await job.AddPathsAsync(localSourcePaths, cancellationToken).ConfigureAwait(false);
// Await completion of the job.
ITransferResult result = await job.CompleteAsync(cancellationToken).ConfigureAwait(false);
Console2.WriteDebugLine("Advanced upload completed.");
DisplayTransferResult(result);
Console2.WriteTapiEndHeader();
}
// Create a job-based download transfer request.
Console2.WriteTapiStartHeader("Advanced Transfer - Download");
string downloadTargetPath = directory.Path;
TransferRequest downloadJobRequest = TransferRequest.ForDownloadJob(downloadTargetPath, context);
downloadJobRequest.Application = "Github Sample";
downloadJobRequest.Name = "Advanced Download Sample";
Console2.WriteDebugLine("Advanced download started.");
// Create a transfer job to download the sample data set to the target local path.
using (ITransferJob job = await client.CreateJobAsync(downloadJobRequest, cancellationToken).ConfigureAwait(false))
{
IEnumerable <TransferPath> remotePaths = localSourcePaths.Select(localPath => new TransferPath
{
SourcePath = uploadTargetPath + "\\" + Path.GetFileName(localPath.SourcePath),
PathAttributes = TransferPathAttributes.File,
TargetPath = downloadTargetPath
});
await job.AddPathsAsync(remotePaths, cancellationToken).ConfigureAwait(false);
await ChangeDataRateAsync(job, cancellationToken).ConfigureAwait(false);
// Await completion of the job.
ITransferResult result = await job.CompleteAsync(cancellationToken).ConfigureAwait(false);
Console2.WriteDebugLine("Advanced download completed.");
DisplayTransferResult(result);
Console2.WriteTapiEndHeader();
}
}
}
public override async Task <Response> ProcessRequest(Request request)
{
var counterName = request.Path;
if (string.IsNullOrEmpty(counterName))
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, "Path or command is invalid."));
}
if (request.QueryParameters.Count != 2 ||
!request.QueryParameters.ContainsKey(ReservedDimensions.StartTimeDimension) ||
!request.QueryParameters.ContainsKey(ReservedDimensions.EndTimeDimension))
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest,
"Invalid query parameters. Must specify only start and end time."));
}
DateTime start, end;
if (!DateTime.TryParse(request.QueryParameters[ReservedDimensions.StartTimeDimension], out start))
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, "Invalid start time."));
}
if (!DateTime.TryParse(request.QueryParameters[ReservedDimensions.EndTimeDimension], out end))
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, "Invalid end time."));
}
var message = new TransferRequest();
if (request.HasInputBody)
{
message = await request.ReadInputBody <TransferRequest>();
}
var ms = request.GetStream();
// This is a tiered aggregation request, handle it separately.
if (message.Sources != null && message.Sources.Count > 1)
{
try
{
using (var aggregator =
PersistedDataProtocol.CreateAggregatorForSampleType(message.DataType, counterName,
message.Sources, start, end,
dataManager.MemoryStreamManager))
{
if (message.Timeout > 0)
{
aggregator.Timeout = TimeSpan.FromSeconds(message.Timeout);
}
if (message.MaxFanout > 0)
{
aggregator.MaxFanout = (int)message.MaxFanout;
}
// This shouldn't happen, given that one of the servers we want to talk to is.. us.
if (!await aggregator.Run())
{
ms.Dispose();
return(request.CreateErrorResponse(HttpStatusCode.InternalServerError,
"All child requests failed."));
}
if (!aggregator.WriteToStream(ms))
{
// TODO: If we have no results but none of our queries failed we can definitively 404,
// for now lazy.
ms.Dispose();
return(request.CreateErrorResponse(HttpStatusCode.InternalServerError,
"No cntent matched."));
}
}
}
catch (ArgumentException)
{
ms.Dispose();
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, "Request parameters are invalid."));
}
}
else
{
var counter = this.dataManager.GetCounter <Counter>(counterName);
if (counter == null || !counter.SerializeData(start, end, ms))
{
ms.Dispose();
return(request.CreateErrorResponse(HttpStatusCode.NotFound, "The requested data is not available."));
}
}
// after writing the response the server will handle disposing the stream for us.
return(new Response(request, HttpStatusCode.OK, ms)
{
ContentType = ResponseType
});
}
/// <summary>
/// Requests an image from SecondLife and blocks until it's received.
/// </summary>
/// <param name="ImageID">The Image's AssetID</param>
public byte[] RequestImage(LLUUID ImageID)
{
byte[] imgData = CachedImage(ImageID);
if (imgData != null)
{
return imgData;
}
TransferRequest tr;
lock (htDownloadRequests)
{
if (htDownloadRequests.ContainsKey(ImageID) == false)
{
tr = new TransferRequest();
tr.Size = int.MaxValue; // Number of bytes expected
tr.Received = 0; // Number of bytes received
tr.LastPacket = Helpers.GetUnixTime(); // last time we recevied a packet for this request
htDownloadRequests[ImageID] = tr;
Packet packet = ImagePacketHelper.RequestImage(ImageID);
slClient.Network.SendPacket(packet);
}
else
{
tr = htDownloadRequests[ImageID];
}
}
// Wait for transfer to complete.
tr.Completed.WaitOne(20000, false);
if (tr.Status == true)
{
return tr.AssetData;
}
else
{
throw new Exception("RequestImage: " + tr.StatusMsg);
}
}
public async Task Transfer(AccountTransfer data)
{
var transfer = mapper.Map<Transfer>(data);
var request = new TransferRequest { Transfer = transfer };
await accountsWriteClient.TransferAsync(request, HttpContext.CreateHeadersWithFlowId());
}
public IActionResult Transfer([FromBody] TransferRequest transferRequest)
{
return(Result(this._transactionApplication.Transfer(this.UserId.ToString(), transferRequest)));
}
public async Task <IActionResult> TransferGreenCredits([FromBody] TransferRequest request)
{
//TODO: Implement energy credits transfer
return(Ok());
}
/// <summary>
/// Handles incoming messages.
/// </summary>
/// <param name="sender">The <see cref="IMessageConnection"/> instance from which the message originated.</param>
/// <param name="message">The message.</param>
public async void HandleMessageRead(object sender, byte[] message)
{
var connection = (IMessageConnection)sender;
var code = new MessageReader <MessageCode.Peer>(message).ReadCode();
Diagnostic.Debug($"Peer message received: {code} from {connection.Username} ({connection.IPEndPoint}) (id: {connection.Id})");
try
{
switch (code)
{
case MessageCode.Peer.SearchResponse:
var searchResponse = SearchResponseFactory.FromByteArray(message);
if (SoulseekClient.Searches.TryGetValue(searchResponse.Token, out var search))
{
search.TryAddResponse(searchResponse);
}
break;
case MessageCode.Peer.BrowseResponse:
var browseWaitKey = new WaitKey(MessageCode.Peer.BrowseResponse, connection.Username);
try
{
SoulseekClient.Waiter.Complete(browseWaitKey, BrowseResponseFactory.FromByteArray(message));
}
catch (Exception ex)
{
SoulseekClient.Waiter.Throw(browseWaitKey, new MessageReadException("The peer returned an invalid browse response", ex));
throw;
}
break;
case MessageCode.Peer.InfoRequest:
UserInfo outgoingInfo;
try
{
outgoingInfo = await SoulseekClient.Options
.UserInfoResponseResolver(connection.Username, connection.IPEndPoint).ConfigureAwait(false);
}
catch (Exception ex)
{
outgoingInfo = await new SoulseekClientOptions()
.UserInfoResponseResolver(connection.Username, connection.IPEndPoint).ConfigureAwait(false);
Diagnostic.Warning($"Failed to resolve user info response: {ex.Message}", ex);
}
await connection.WriteAsync(outgoingInfo.ToByteArray()).ConfigureAwait(false);
break;
case MessageCode.Peer.BrowseRequest:
BrowseResponse browseResponse;
try
{
browseResponse = await SoulseekClient.Options.BrowseResponseResolver(connection.Username, connection.IPEndPoint).ConfigureAwait(false);
}
catch (Exception ex)
{
browseResponse = await new SoulseekClientOptions()
.BrowseResponseResolver(connection.Username, connection.IPEndPoint).ConfigureAwait(false);
Diagnostic.Warning($"Failed to resolve browse response: {ex.Message}", ex);
}
await connection.WriteAsync(browseResponse.ToByteArray()).ConfigureAwait(false);
break;
case MessageCode.Peer.FolderContentsRequest:
var folderContentsRequest = FolderContentsRequest.FromByteArray(message);
Directory outgoingFolderContents = null;
try
{
outgoingFolderContents = await SoulseekClient.Options.DirectoryContentsResponseResolver(
connection.Username,
connection.IPEndPoint,
folderContentsRequest.Token,
folderContentsRequest.DirectoryName).ConfigureAwait(false);
}
catch (Exception ex)
{
Diagnostic.Warning($"Failed to resolve directory contents response: {ex.Message}", ex);
}
if (outgoingFolderContents != null)
{
var folderContentsResponseMessage = new FolderContentsResponse(folderContentsRequest.Token, outgoingFolderContents);
await connection.WriteAsync(folderContentsResponseMessage.ToByteArray()).ConfigureAwait(false);
}
break;
case MessageCode.Peer.FolderContentsResponse:
var folderContentsResponse = FolderContentsResponse.FromByteArray(message);
SoulseekClient.Waiter.Complete(new WaitKey(MessageCode.Peer.FolderContentsResponse, connection.Username, folderContentsResponse.Token), folderContentsResponse.Directory);
break;
case MessageCode.Peer.InfoResponse:
var incomingInfo = UserInfoResponseFactory.FromByteArray(message);
SoulseekClient.Waiter.Complete(new WaitKey(MessageCode.Peer.InfoResponse, connection.Username), incomingInfo);
break;
case MessageCode.Peer.TransferResponse:
var transferResponse = TransferResponse.FromByteArray(message);
SoulseekClient.Waiter.Complete(new WaitKey(MessageCode.Peer.TransferResponse, connection.Username, transferResponse.Token), transferResponse);
break;
case MessageCode.Peer.QueueDownload:
var queueDownloadRequest = EnqueueDownloadRequest.FromByteArray(message);
var(queueRejected, queueRejectionMessage) =
await TryEnqueueDownloadAsync(connection.Username, connection.IPEndPoint, queueDownloadRequest.Filename).ConfigureAwait(false);
if (queueRejected)
{
await connection.WriteAsync(new EnqueueFailedResponse(queueDownloadRequest.Filename, queueRejectionMessage).ToByteArray()).ConfigureAwait(false);
}
else
{
await TrySendPlaceInQueueAsync(connection, queueDownloadRequest.Filename).ConfigureAwait(false);
}
break;
case MessageCode.Peer.TransferRequest:
var transferRequest = TransferRequest.FromByteArray(message);
if (transferRequest.Direction == TransferDirection.Upload)
{
if (!SoulseekClient.Downloads.IsEmpty && SoulseekClient.Downloads.Values.Any(d => d.Username == connection.Username && d.Filename == transferRequest.Filename))
{
SoulseekClient.Waiter.Complete(new WaitKey(MessageCode.Peer.TransferRequest, connection.Username, transferRequest.Filename), transferRequest);
}
else
{
// reject the transfer with an empty reason. it was probably cancelled, but we can't be sure.
await connection.WriteAsync(new TransferResponse(transferRequest.Token, string.Empty).ToByteArray()).ConfigureAwait(false);
}
}
else
{
var(transferRejected, transferRejectionMessage) = await TryEnqueueDownloadAsync(connection.Username, connection.IPEndPoint, transferRequest.Filename).ConfigureAwait(false);
if (transferRejected)
{
await connection.WriteAsync(new TransferResponse(transferRequest.Token, transferRejectionMessage).ToByteArray()).ConfigureAwait(false);
await connection.WriteAsync(new EnqueueFailedResponse(transferRequest.Filename, transferRejectionMessage).ToByteArray()).ConfigureAwait(false);
}
else
{
await connection.WriteAsync(new TransferResponse(transferRequest.Token, "Queued").ToByteArray()).ConfigureAwait(false);
await TrySendPlaceInQueueAsync(connection, transferRequest.Filename).ConfigureAwait(false);
}
}
break;
case MessageCode.Peer.QueueFailed:
var queueFailedResponse = EnqueueFailedResponse.FromByteArray(message);
SoulseekClient.Waiter.Throw(new WaitKey(MessageCode.Peer.TransferRequest, connection.Username, queueFailedResponse.Filename), new TransferRejectedException(queueFailedResponse.Message));
break;
case MessageCode.Peer.PlaceInQueueResponse:
var placeInQueueResponse = PlaceInQueueResponse.FromByteArray(message);
SoulseekClient.Waiter.Complete(new WaitKey(MessageCode.Peer.PlaceInQueueResponse, connection.Username, placeInQueueResponse.Filename), placeInQueueResponse);
break;
case MessageCode.Peer.PlaceInQueueRequest:
var placeInQueueRequest = PlaceInQueueRequest.FromByteArray(message);
await TrySendPlaceInQueueAsync(connection, placeInQueueRequest.Filename).ConfigureAwait(false);
break;
case MessageCode.Peer.UploadFailed:
var uploadFailedResponse = UploadFailed.FromByteArray(message);
var msg = $"Download of {uploadFailedResponse.Filename} reported as failed by {connection.Username}";
var download = SoulseekClient.Downloads.Values.FirstOrDefault(d => d.Username == connection.Username && d.Filename == uploadFailedResponse.Filename);
if (download != null)
{
SoulseekClient.Waiter.Throw(new WaitKey(MessageCode.Peer.TransferRequest, download.Username, download.Filename), new TransferException(msg));
}
Diagnostic.Debug(msg);
break;
default:
Diagnostic.Debug($"Unhandled peer message: {code} from {connection.Username} ({connection.IPEndPoint}); {message.Length} bytes");
break;
}
}
catch (Exception ex)
{
Diagnostic.Warning($"Error handling peer message: {code} from {connection.Username} ({connection.IPEndPoint}); {ex.Message}", ex);
}
}
private static void PrintTransferRequest(TransferRequest value)
{
Console.WriteLine(
$"Transfer amount {LogicalTypesHack.FromLogicalTypeMoneyDecimal(value.amount.amount)} {value.amount.currencyCode} from {FormatAccount(value.from)} to {FormatAccount(value.to)} on date {LogicalTypesHack.FromLogicalTypeDate(value.date):yyyy-MM-dd}");
}
/// <summary>
/// Creates cash out transaction without signs
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='model'>
/// </param>
public static object ApiTransactionTransferPost(this IBitcoinApi operations, TransferRequest model = default(TransferRequest))
{
return(System.Threading.Tasks.Task.Factory.StartNew(s => ((IBitcoinApi)s).ApiTransactionTransferPostAsync(model), operations, System.Threading.CancellationToken.None, System.Threading.Tasks.TaskCreationOptions.None, System.Threading.Tasks.TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
public TransferResponse CreateTransfer(TransferRequest request)
{
return(new TransferResponse());
}
public async void HandleMessage(object sender, byte[] message)
{
var connection = (IMessageConnection)sender;
var code = new MessageReader <MessageCode.Peer>(message).ReadCode();
Diagnostic.Debug($"Peer message received: {code} from {connection.Username} ({connection.IPAddress}:{connection.Port})");
try
{
switch (code)
{
case MessageCode.Peer.SearchResponse:
var searchResponse = SearchResponseSlim.Parse(message);
if (SoulseekClient.Searches.TryGetValue(searchResponse.Token, out var search))
{
search.AddResponse(searchResponse);
}
break;
case MessageCode.Peer.BrowseResponse:
var browseWaitKey = new WaitKey(MessageCode.Peer.BrowseResponse, connection.Username);
try
{
SoulseekClient.Waiter.Complete(browseWaitKey, BrowseResponse.Parse(message));
}
catch (Exception ex)
{
SoulseekClient.Waiter.Throw(browseWaitKey, new MessageReadException("The peer returned an invalid browse response.", ex));
throw;
}
break;
case MessageCode.Peer.InfoResponse:
var infoResponse = UserInfoResponse.Parse(message);
SoulseekClient.Waiter.Complete(new WaitKey(MessageCode.Peer.InfoResponse, connection.Username), infoResponse);
break;
case MessageCode.Peer.TransferResponse:
var transferResponse = TransferResponse.Parse(message);
Console.WriteLine($"Got response from {connection.Username}: {transferResponse.Token}");
SoulseekClient.Waiter.Complete(new WaitKey(MessageCode.Peer.TransferResponse, connection.Username, transferResponse.Token), transferResponse);
break;
case MessageCode.Peer.QueueDownload:
// the end state here is to wait until there's actually a free slot, then send this request to the peer to
// let them know we are ready to start the actual transfer.
var queueDownloadRequest = QueueDownloadRequest.Parse(message);
var(queueAllowed, queueRejectionMessage) = SoulseekClient.Resolvers.QueueDownloadResponse(connection.Username, connection.IPAddress, connection.Port, queueDownloadRequest.Filename);
if (!queueAllowed)
{
await connection.WriteAsync(new QueueFailedResponse(queueDownloadRequest.Filename, queueRejectionMessage)).ConfigureAwait(false);
}
break;
case MessageCode.Peer.TransferRequest:
var transferRequest = TransferRequest.Parse(message);
if (transferRequest.Direction == TransferDirection.Upload)
{
SoulseekClient.Waiter.Complete(new WaitKey(MessageCode.Peer.TransferRequest, connection.Username, transferRequest.Filename), transferRequest);
}
else
{
var(transferAllowed, transferRejectionMessage) = SoulseekClient.Resolvers.QueueDownloadResponse(connection.Username, connection.IPAddress, connection.Port, transferRequest.Filename);
if (!transferAllowed)
{
await connection.WriteAsync(new TransferResponse(transferRequest.Token, transferRejectionMessage)).ConfigureAwait(false);
await connection.WriteAsync(new QueueFailedResponse(transferRequest.Filename, transferRejectionMessage)).ConfigureAwait(false);
}
else
{
await connection.WriteAsync(new TransferResponse(transferRequest.Token, "Queued.")).ConfigureAwait(false);
}
}
break;
case MessageCode.Peer.QueueFailed:
var queueFailedResponse = QueueFailedResponse.Parse(message);
SoulseekClient.Waiter.Throw(new WaitKey(MessageCode.Peer.TransferRequest, connection.Username, queueFailedResponse.Filename), new TransferRejectedException(queueFailedResponse.Message));
break;
case MessageCode.Peer.PlaceInQueueResponse:
var placeInQueueResponse = PeerPlaceInQueueResponse.Parse(message);
SoulseekClient.Waiter.Complete(new WaitKey(MessageCode.Peer.PlaceInQueueResponse, connection.Username, placeInQueueResponse.Filename), placeInQueueResponse);
break;
case MessageCode.Peer.UploadFailed:
var uploadFailedResponse = PeerUploadFailedResponse.Parse(message);
var msg = $"Download of {uploadFailedResponse.Filename} reported as failed by {connection.Username}.";
var download = SoulseekClient.Downloads.Values.FirstOrDefault(d => d.Username == connection.Username && d.Filename == uploadFailedResponse.Filename);
if (download != null)
{
SoulseekClient.Waiter.Throw(new WaitKey(MessageCode.Peer.TransferRequest, download.Username, download.Filename), new TransferException(msg));
SoulseekClient.Waiter.Throw(download.WaitKey, new TransferException(msg));
}
Diagnostic.Debug(msg);
break;
case MessageCode.Peer.BrowseRequest:
var browseResponse = SoulseekClient.Resolvers.BrowseResponse(connection.Username, connection.IPAddress, connection.Port);
await connection.WriteAsync(browseResponse).ConfigureAwait(false);
break;
default:
Diagnostic.Debug($"Unhandled peer message: {code} from {connection.Username} ({connection.IPAddress}:{connection.Port}); {message.Length} bytes");
break;
}
}
catch (Exception ex)
{
Diagnostic.Warning($"Error handling peer message: {code} from {connection.Username} ({connection.IPAddress}:{connection.Port}); {ex.Message}", ex);
}
}
public async Task <IActionResult> CreateCashout([FromBody] TransferRequest model)
{
if (model.Amount <= 0)
{
throw new BackendException("Amount can't be less or equal to zero", ErrorCode.BadInputParameter);
}
var sourceAddress = OpenAssetsHelper.ParseAddress(model.SourceAddress);
if (sourceAddress == null)
{
throw new BackendException("Invalid source address provided", ErrorCode.InvalidAddress);
}
var destAddress = OpenAssetsHelper.ParseAddress(model.DestinationAddress);
if (destAddress == null)
{
throw new BackendException("Invalid destination address provided", ErrorCode.InvalidAddress);
}
var asset = await _assetRepository.GetAssetById(model.Asset);
if (asset == null)
{
throw new BackendException("Provided asset is missing in database", ErrorCode.AssetNotFound);
}
if (model.Fee.GetValueOrDefault() < 0)
{
throw new BackendException("Fee must be greater than or equal to zero", ErrorCode.BadInputParameter);
}
if (model.Amount <= model.Fee.GetValueOrDefault())
{
throw new BackendException("Amount is less than fee", ErrorCode.BadInputParameter);
}
var transactionId = await _builder.AddTransactionId(model.TransactionId, model.ToJson());
CreateTransactionResponse createTransactionResponse;
if (OpenAssetsHelper.IsBitcoin(asset.Id) && model.Fee.HasValue)
{
createTransactionResponse = await _builder.GetPrivateTransferTransaction(sourceAddress, destAddress, model.Amount,
model.Fee.Value, transactionId);
await _transactionSignRequestRepository.DoNotSign(transactionId);
}
else
{
createTransactionResponse = await _builder.GetTransferTransaction(sourceAddress, destAddress, model.Amount, asset, transactionId, true, true);
}
await _transactionBlobStorage.AddOrReplaceTransaction(transactionId, TransactionBlobType.Initial, createTransactionResponse.Transaction);
return(Ok(new TransactionResponse
{
Transaction = createTransactionResponse.Transaction,
TransactionId = createTransactionResponse.TransactionId,
Fee = (createTransactionResponse as PrivateTransferResponse)?.Fee ?? 0
}));
}
public async Task PostAsync_WithCallback_ShouldSuccess()
{
// Arrange.
var amount = new PropertyAmount(10);
var destination = TestAddress.Mainnet1;
var callerIP = IPAddress.Loopback;
var rawCallbackUrl = "https://zcoin.io/callback";
var callbackUrl = new Uri(rawCallbackUrl);
var req = new TransferRequest
{
Amount = amount,
Destination = destination,
ReferenceAmount = Money.Satoshis(100)
};
var network = ZcoinNetworks.Instance.GetNetwork(this.zcoinConfig.Network.Type);
var tx = Transaction.Create(network);
var property = new Property(this.zcoinConfig.Property.Id, this.zcoinConfig.Property.Type);
var cancellationToken = new CancellationToken(false);
// Build Mock.
this.propertyManagementRpc.Setup(
r => r.SendAsync
(
this.zcoinConfig.Property.Distributor.Address,
destination,
property,
amount,
Money.Satoshis(100),
cancellationToken
)).ReturnsAsync(tx).Verifiable();
this.rawTransactionRpc.Setup(
r => r.SendAsync
(
tx,
cancellationToken
)).ReturnsAsync(tx.GetHash()).Verifiable();
var callback = new Callback(Guid.NewGuid(), callerIP, DateTime.UtcNow, false, callbackUrl);
this.callbackRepository.Setup(
r => r.AddAsync
(
callerIP,
new Uri(rawCallbackUrl),
CancellationToken.None
)).ReturnsAsync(callback).Verifiable();
this.watcher.Setup
(
r => r.AddTransactionAsync
(
tx.GetHash(),
this.apiConfig.Default.RequiredConfirmation,
this.apiConfig.Default.TransactionTimeout,
callback,
It.Is <CallbackResult>(c => c.Status == CallbackResult.StatusSuccess),
It.Is <CallbackResult>(c => c.Status == "tokens-transfer-timeout"),
CancellationToken.None
)
).ReturnsAsync
(
(uint256 _tx, int _confirmations, TimeSpan _waiting, Callback _callback, CallbackResult _success, CallbackResult _timeout, CancellationToken _) =>
new Rule
(
Guid.NewGuid(),
_tx,
_confirmations,
_waiting,
_success,
_timeout,
_callback,
DateTime.UtcNow
)
).Verifiable();
// Mock context.
ControllerTesting <TransfersController> .SetHttpContext(this.subject, context =>
{
context.Connection.RemoteIpAddress = IPAddress.Loopback;
context.Request.Headers.TryAdd("X-Callback-URL", rawCallbackUrl);
});
// Act.
var result = await this.subject.PostAsync(req, cancellationToken);
// Assert.
result.Should().NotBeNull();
var objResult = result.As <ObjectResult>();
objResult.StatusCode.Should().Be((int)HttpStatusCode.Accepted);
objResult.Value.Should().BeEquivalentTo(new { Tx = tx.GetHash() });
this.propertyManagementRpc.Verify();
this.rawTransactionRpc.Verify();
// Callback should be created.
this.callbackRepository.Verify();
// The transaction should be watched.
this.ruleRepository.Verify();
}
/// <summary>
/// Handles incoming messages.
/// </summary>
/// <param name="sender">The <see cref="IMessageConnection"/> instance from which the message originated.</param>
/// <param name="message">The message.</param>
public async void HandleMessage(object sender, byte[] message)
{
var connection = (IMessageConnection)sender;
var code = new MessageReader <MessageCode.Peer>(message).ReadCode();
Diagnostic.Debug($"Peer message received: {code} from {connection.Username} ({connection.IPAddress}:{connection.Port})");
try
{
switch (code)
{
case MessageCode.Peer.SearchResponse:
var searchResponse = SearchResponseSlim.FromByteArray(message);
if (SoulseekClient.Searches.TryGetValue(searchResponse.Token, out var search))
{
search.AddResponse(searchResponse);
}
break;
case MessageCode.Peer.BrowseResponse:
var browseWaitKey = new WaitKey(MessageCode.Peer.BrowseResponse, connection.Username);
try
{
SoulseekClient.Waiter.Complete(browseWaitKey, BrowseResponse.FromByteArray(message));
}
catch (Exception ex)
{
SoulseekClient.Waiter.Throw(browseWaitKey, new MessageReadException("The peer returned an invalid browse response.", ex));
throw;
}
break;
case MessageCode.Peer.InfoRequest:
var outgoingInfo = await new ClientOptions()
.UserInfoResponseResolver(connection.Username, connection.IPAddress, connection.Port).ConfigureAwait(false);
try
{
outgoingInfo = await SoulseekClient.Options
.UserInfoResponseResolver(connection.Username, connection.IPAddress, connection.Port).ConfigureAwait(false);
}
catch (Exception ex)
{
Diagnostic.Warning($"Failed to resolve UserInfoResponse: {ex.Message}", ex);
}
await connection.WriteAsync(outgoingInfo.ToByteArray()).ConfigureAwait(false);
break;
case MessageCode.Peer.BrowseRequest:
var browseResponse = await new ClientOptions()
.BrowseResponseResolver(connection.Username, connection.IPAddress, connection.Port).ConfigureAwait(false);
try
{
browseResponse = await SoulseekClient.Options.BrowseResponseResolver(connection.Username, connection.IPAddress, connection.Port).ConfigureAwait(false);
}
catch (Exception ex)
{
Diagnostic.Warning($"Failed to resolve BrowseResponse: {ex.Message}", ex);
}
await connection.WriteAsync(browseResponse.ToByteArray()).ConfigureAwait(false);
break;
case MessageCode.Peer.InfoResponse:
var incomingInfo = UserInfoResponse.FromByteArray(message);
SoulseekClient.Waiter.Complete(new WaitKey(MessageCode.Peer.InfoResponse, connection.Username), incomingInfo);
break;
case MessageCode.Peer.TransferResponse:
var transferResponse = TransferResponse.FromByteArray(message);
SoulseekClient.Waiter.Complete(new WaitKey(MessageCode.Peer.TransferResponse, connection.Username, transferResponse.Token), transferResponse);
break;
case MessageCode.Peer.QueueDownload:
var queueDownloadRequest = QueueDownloadRequest.FromByteArray(message);
var(queueRejected, queueRejectionMessage) =
await TryEnqueueDownloadAsync(connection.Username, connection.IPAddress, connection.Port, queueDownloadRequest.Filename).ConfigureAwait(false);
if (queueRejected)
{
await connection.WriteAsync(new QueueFailedResponse(queueDownloadRequest.Filename, queueRejectionMessage).ToByteArray()).ConfigureAwait(false);
}
break;
case MessageCode.Peer.TransferRequest:
var transferRequest = TransferRequest.FromByteArray(message);
if (transferRequest.Direction == TransferDirection.Upload)
{
SoulseekClient.Waiter.Complete(new WaitKey(MessageCode.Peer.TransferRequest, connection.Username, transferRequest.Filename), transferRequest);
}
else
{
var(transferRejected, transferRejectionMessage) = await TryEnqueueDownloadAsync(connection.Username, connection.IPAddress, connection.Port, transferRequest.Filename).ConfigureAwait(false);
if (transferRejected)
{
await connection.WriteAsync(new TransferResponse(transferRequest.Token, transferRejectionMessage).ToByteArray()).ConfigureAwait(false);
await connection.WriteAsync(new QueueFailedResponse(transferRequest.Filename, transferRejectionMessage).ToByteArray()).ConfigureAwait(false);
}
else
{
await connection.WriteAsync(new TransferResponse(transferRequest.Token, "Queued.").ToByteArray()).ConfigureAwait(false);
}
}
break;
case MessageCode.Peer.QueueFailed:
var queueFailedResponse = QueueFailedResponse.FromByteArray(message);
SoulseekClient.Waiter.Throw(new WaitKey(MessageCode.Peer.TransferRequest, connection.Username, queueFailedResponse.Filename), new TransferRejectedException(queueFailedResponse.Message));
break;
case MessageCode.Peer.PlaceInQueueResponse:
var placeInQueueResponse = PlaceInQueueResponse.FromByteArray(message);
SoulseekClient.Waiter.Complete(new WaitKey(MessageCode.Peer.PlaceInQueueResponse, connection.Username, placeInQueueResponse.Filename), placeInQueueResponse);
break;
case MessageCode.Peer.UploadFailed:
var uploadFailedResponse = UploadFailed.FromByteArray(message);
var msg = $"Download of {uploadFailedResponse.Filename} reported as failed by {connection.Username}.";
var download = SoulseekClient.Downloads.Values.FirstOrDefault(d => d.Username == connection.Username && d.Filename == uploadFailedResponse.Filename);
if (download != null)
{
SoulseekClient.Waiter.Throw(new WaitKey(MessageCode.Peer.TransferRequest, download.Username, download.Filename), new TransferException(msg));
SoulseekClient.Waiter.Throw(download.WaitKey, new TransferException(msg));
}
Diagnostic.Debug(msg);
break;
default:
Diagnostic.Debug($"Unhandled peer message: {code} from {connection.Username} ({connection.IPAddress}:{connection.Port}); {message.Length} bytes");
break;
}
}
catch (Exception ex)
{
Diagnostic.Warning($"Error handling peer message: {code} from {connection.Username} ({connection.IPAddress}:{connection.Port}); {ex.Message}", ex);
}
}
public async Task TransferAsync(TransferRequest transferRequest, Guid requestUserId)
{
var notificationService = new NotificationService.NotificationService();
// Validation
var validator = new TransferRequestValidator(_operationsDbContext);
var validateResult = validator.Validate(transferRequest);
if (!validateResult.IsValid)
{
throw new TransferException(validateResult.Errors.Select(a => a.ErrorMessage));
}
// Get data for operation
var recipientInvoice = await _operationsDbContext.Invoices
.Include(a => a.Bank)
.Include(a => a.InvoiceType)
.FirstOrDefaultAsync(a => a.Id == transferRequest.RecipientInvoiceId);
if (recipientInvoice == null)
{
throw new TransferException("Получатель не найден.");
}
var senderInvoice = await _operationsDbContext.Invoices
.Include(a => a.Bank)
.FirstOrDefaultAsync(a => a.Id == transferRequest.SenderInvoiceId);
if (senderInvoice == null)
{
throw new TransferException("Отправитель не найден.");
}
var dbMatrix = await _operationsDbContext.Matrices
.FirstOrDefaultAsync(a => a.SenderTypeId == senderInvoice.InvoiceTypeId &&
a.RecipientTypeId == recipientInvoice.InvoiceTypeId);
if (dbMatrix == null)
{
throw new TransferException("Нет матрицы для расчета комиссии.");
}
// Calc interest
var bankInterested = Helpers.CalcBankInterested(senderInvoice.Bank, senderInvoice, recipientInvoice, transferRequest.Ammount);
var transferInterested = Helpers.CalcTransferInterested(dbMatrix, transferRequest.Ammount);
var chargeAmount = transferRequest.Ammount + bankInterested + transferInterested;
if (senderInvoice.Ammount < chargeAmount)
{
throw new TransferException("Недостаточно средств.");
}
var notifications = Helpers.CreateNotifications(recipientInvoice.InvoiceType, senderInvoice.Bank);
// Operation
senderInvoice.Ammount -= chargeAmount;
recipientInvoice.Ammount += transferRequest.Ammount;
var dbTransaction = new DbTransation()
{
Ammount = transferRequest.Ammount,
RecipientInvoiceId = recipientInvoice.Id,
SenderInvoiceId = senderInvoice.Id,
TransferDate = DateTime.UtcNow,
BankInterest = bankInterested,
TransferInterest = transferInterested,
TransferUserId = requestUserId,
};
using (var transaction = _operationsDbContext.Database.BeginTransaction())
{
try
{
_operationsDbContext.Transations.Add(dbTransaction);
await _operationsDbContext.SaveChangesAsync();
await notificationService.SendAsync(notifications);
transaction.Commit();
}
catch (DbUpdateConcurrencyException)
{
transaction.Rollback();
throw new TransferException("Данные обновились ранее.");
}
catch (Exception)
{
transaction.Rollback();
throw new TransferException("Произошла системная ошибка.");
}
}
}
public void Transfer(TransferRequest pTransferRequest)
{
TransferProvider.Transfer(pTransferRequest.Amount, pTransferRequest.FromAccountNumber, pTransferRequest.ToAccountNumber, pTransferRequest.OrderGuid, pTransferRequest.CustomerId);
}
public bool Transfer(DebitUserRecord record, out string errMsg)
{
Redis redis = new Redis();
errMsg = String.Empty;
string key = String.Format("lock_{0}", record.debitId);
string retKey = String.Format("release_{0}", record.debitId);
if (redis.LockTake(key, record.debitId, 300))
{
try
{
string transferResult = redis.StringGet(retKey);
if (!String.IsNullOrEmpty(transferResult))
{
InquiryResponse response = JsonConvert.DeserializeObject <InquiryResponse>(transferResult);
if (response.responseCode == "00")
{
Log.WriteDebugLog("LoanBank::Transfer", "[{0}]早已转帐成功：{1}", record.debitId, response.responseDesc);
return(true);
}
}
else
{
HttpHelper http = new HttpHelper();
Log.WriteDebugLog("LoanBank::Transfer", "[{0}] 准备转帐，查询银行信息。", record.debitId);
//查询，验证转帐的银行信息
InquiryResponse response = null;
response = DuitkuInquiryRequest(record);
Log.WriteDebugLog("LoanBank::Transfer", "[{0}] 核对银行帐号信息：{1}", record.debitId, JsonConvert.SerializeObject(response));
if (response.responseCode == "00")
{
Log.WriteDebugLog("LoanBank::Transfer", "[{0}] 核对银行帐号信息，返回成功。", record.debitId);
Log.WriteDebugLog("LoanBank::Transfer", "[{0}] 核对帐户名称，record：{1} ，response：{2}", record.debitId, record.userName.Trim().ToUpper(), response.accountName.Trim().ToUpper());
string bankUserName = response.accountName.Replace(" ", "").Trim().ToUpper();
string recordUserName = record.userName.Replace(" ", "").Trim().ToUpper();
///相似度匹配
float rate = HttpHelper.Levenshtein(bankUserName, recordUserName);
if (bankUserName.IndexOf(recordUserName) > -1 ||
rate >= 0.7)
{
Log.WriteDebugLog("LoanBank::Transfer", "[{0}] 帐户名称正确，初使化请求准备转帐。相似度：{1}%", record.debitId, rate * 100);
TransferRequest transferRequest = new TransferRequest();
transferRequest.accountName = record.userName.ToUpper();
transferRequest.amountTransfer = response.amountTransfer;
transferRequest.bankCode = response.bankCode.Trim();
transferRequest.custRefNumber = response.custRefNumber.Trim();
transferRequest.disburseId = response.disburseId;
transferRequest.purpose = record.purpose;
transferRequest.bankAccount = record.bankAccount;
transferRequest.InitSingature(record.target);
Log.WriteDebugLog("LoanBank::Transfer", "[{0}] 开始转帐，渠道为：{1}，请求参数为:{2}", record.debitId, record.target, JsonConvert.SerializeObject(transferRequest));
response = http.DuitkuTransferRequest(transferRequest);
Log.WriteDebugLog("LoanBank::Transfer", "[{0}] 转帐结果为：{1}", record.debitId, JsonConvert.SerializeObject(response));
if (response.responseCode == "00")
{
Log.WriteDebugLog("LoanBank::Transfer", "[{0}] 转帐成功,将结果写入缓存，30天内避免重复打款。：{1}", record.debitId, response.responseDesc);
redis.StringSet(retKey, JsonConvert.SerializeObject(response), 60 * 60 * 24 * 30);
return(true);
}
else
{
errMsg = String.Format("{0}({1})", response.responseDesc, response.responseCode);
Log.WriteErrorLog("LoanBank::Transfer", "[{0}] 转帐失败：{1}", record.debitId, response.responseDesc);
return(false);
}
}
else
{
Log.WriteErrorLog("LoanBank::Transfer", "[{0}] 银行卡对应的名字与用户填写的名字不同：{1}!={2}，相似度：{3}", record.debitId, bankUserName, recordUserName, rate);
errMsg = String.Format("Bank Information Incorrect.accountName:{0} incorrect.", record.userName);
return(false);
}
}
else
{
errMsg = String.Format("{0}({1})", response.responseDesc, response.responseCode);
Log.WriteErrorLog("LoanBank::Transfer", "[{0}] 转帐失败：{1}", record.debitId, response.responseDesc);
return(false);
}
}
}
catch (Exception ex)
{
Log.WriteErrorLog("LoanBank::Transfer", "[{0}] 转帐失败，发生异常，渠道：{1}, {2}", record.debitId, record.target, ex.Message);
}
finally
{
redis.LockRelease(key, record.debitId);
}
return(false);
}
else
{
errMsg = "get lock fail.";
return(false);
}
}
void request_OnError(TransferRequest request, StatusCode error)
{
Status = error;
completeEvent.Set();
}
public void SetTransferDevice(TransferRequest req)
{
var json = JsonConvert.SerializeObject(req);
httpPut(Spotify_Endpoint.player_transfer, json);
}
void prot_Update(object sender, FmdcEventArgs e)
{
switch (e.Action)
{
case Actions.TransferRequest:
if (e.Data is TransferRequest)
{
TransferRequest req = (TransferRequest)e.Data;
if (transferManager.GetTransferReq(req.Key) == null)
{
transferManager.AddTransferReq(req);
}
}
break;
case Actions.TransferStarted:
Transfer trans = e.Data as Transfer;
if (trans != null)
{
#if !COMPACT_FRAMEWORK
// Security, Windows Mobile doesnt support SSLStream so we disable this feature for it.
trans.SecureUpdate += new FmdcEventHandler(trans_SecureUpdate);
#endif
transferManager.StartTransfer(trans);
trans.ProtocolChange += new FmdcEventHandler(trans_ProtocolChange);
trans.Protocol.ChangeDownloadItem += new FmdcEventHandler(Protocol_ChangeDownloadItem);
trans.Protocol.RequestTransfer += new FmdcEventHandler(Protocol_RequestTransfer);
trans.Protocol.Error += new FmdcEventHandler(Protocol_Error);
if (Program.DEBUG)
{
trans.Protocol.MessageReceived += new FmdcEventHandler(Trans_Protocol_MessageReceived);
trans.Protocol.MessageToSend += new FmdcEventHandler(Trans_Protocol_MessageToSend);
}
}
break;
case Actions.MainMessage:
MainMessage msgMain = e.Data as MainMessage;
if (CommandHandler.TryHandleMsg(this, msgMain.From, msgMain.Content, Actions.MainMessage))
{
// message will here be converted to right format and then be sent.
//UpdateBase(this, new FlowLib.Events.FmdcEventArgs(FlowLib.Events.Actions.MainMessage, new MainMessage(hubConnection.Me.ID, msg)));
}
else
{
if (!Program.DEBUG)
{
Program.Write(string.Format("[{0}] <{1}> {2}\r\n",
System.DateTime.Now.ToLongTimeString(),
msgMain.From,
msgMain.Content));
}
}
break;
case Actions.PrivateMessage:
PrivateMessage msgPriv = e.Data as PrivateMessage;
if (CommandHandler.TryHandleMsg(this, msgPriv.From, msgPriv.Content.Replace("<" + msgPriv.From + "> ", string.Empty), Actions.PrivateMessage))
{
// message will here be converted to right format and then be sent.
//UpdateBase(this, new FlowLib.Events.FmdcEventArgs(FlowLib.Events.Actions.PrivateMessage, new PrivateMessage(msgPriv.From, hubConnection.Me.ID, msgPM)));
}
else
{
if (!Program.DEBUG)
{
Program.Write(string.Format("[{0}] PM:{1}\r\n",
System.DateTime.Now.ToLongTimeString(),
msgPriv.Content));
}
}
break;
}
}
public async Task <Response> TransferValuesBetweenAccounts([FromBody] TransferRequest request)
{
return(await _mediator.Send(request));
}
/// <summary>
/// Creates cash out transaction without signs
/// </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> ApiTransactionTransferPostAsync(this IBitcoinApi operations, TransferRequest model = default(TransferRequest), System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken))
{
using (var _result = await operations.ApiTransactionTransferPostWithHttpMessagesAsync(model, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
private async Task PayoutBatch(Balance[] balances)
{
// build request
var request = new TransferRequest
{
Destinations = balances
.Where(x => x.Amount > 0)
.Select(x => new TransferDestination
{
Address = x.Address,
Amount = (ulong)Math.Floor(x.Amount * MoneroConstants.SmallestUnit[poolConfig.Coin.Type])
}).ToArray(),
GetTxKey = true
};
if (request.Destinations.Length == 0)
{
return;
}
logger.Info(() => $"[{LogCategory}] Paying out {FormatAmount(balances.Sum(x => x.Amount))} to {balances.Length} addresses");
// send command
var transferResponse = await walletDaemon.ExecuteCmdSingleAsync <TransferResponse>(MWC.Transfer, request);
// gracefully handle error -4 (transaction would be too large. try /transfer_split)
if (transferResponse.Error?.Code == -4)
{
if (walletSupportsTransferSplit)
{
logger.Info(() => $"[{LogCategory}] Retrying transfer using {MWC.TransferSplit}");
var transferSplitResponse = await walletDaemon.ExecuteCmdSingleAsync <TransferSplitResponse>(MWC.TransferSplit, request);
// gracefully handle error -4 (transaction would be too large. try /transfer_split)
if (transferResponse.Error?.Code != -4)
{
HandleTransferResponse(transferSplitResponse, balances);
return;
}
}
// retry paged
logger.Info(() => $"[{LogCategory}] Retrying paged");
var validBalances = balances.Where(x => x.Amount > 0).ToArray();
var pageSize = 10;
var pageCount = (int)Math.Ceiling((double)validBalances.Length / pageSize);
for (var i = 0; i < pageCount; i++)
{
var page = validBalances
.Skip(i * pageSize)
.Take(pageSize)
.ToArray();
// update request
request.Destinations = page
.Where(x => x.Amount > 0)
.Select(x => new TransferDestination
{
Address = x.Address,
Amount = (ulong)Math.Floor(x.Amount * MoneroConstants.SmallestUnit[poolConfig.Coin.Type])
}).ToArray();
logger.Info(() => $"[{LogCategory}] Page {i + 1}: Paying out {FormatAmount(page.Sum(x => x.Amount))} to {page.Length} addresses");
transferResponse = await walletDaemon.ExecuteCmdSingleAsync <TransferResponse>(MWC.Transfer, request);
HandleTransferResponse(transferResponse, page);
if (transferResponse.Error != null)
{
break;
}
}
}
else
{
HandleTransferResponse(transferResponse, balances);
}
}
public void Init()
{
instance = new TransferRequest();
}
public void Post(TransferRequest transferRequest)
{
}
public async Task <WalletApiResponse> Transfer(int userId, [FromBody] TransferRequest convertMoneyRequest)
{
try
{
if (convertMoneyRequest.Sum <= 0)
{
return(new WalletApiErrorResponse("Нельзя создать перевод с суммой меньшей или равной нулю"));
}
if (convertMoneyRequest.SourceWalletId == convertMoneyRequest.TargetWalletId)
{
return(new WalletApiErrorResponse("Нельзя создать перевод в этот же кошлек"));
}
using (var trans = _context.Database.BeginTransaction())
{
var sourceWallet = await _context.Wallets.FirstOrDefaultAsync(x => x.UserId == userId && x.Id == convertMoneyRequest.SourceWalletId);
if (sourceWallet == null)
{
return(new WalletApiErrorResponse($"Не существует кошелька с Id = {convertMoneyRequest.SourceWalletId}"));
}
var targetWallet = await _context.Wallets.FirstOrDefaultAsync(x => x.Id == convertMoneyRequest.TargetWalletId);
if (targetWallet == null)
{
return(new WalletApiErrorResponse($"Не существует кошелька с Id = {convertMoneyRequest.TargetWalletId}"));
}
var convertedSum = _currencyService.Convert(convertMoneyRequest.Sum, sourceWallet.Currency, targetWallet.Currency);
var transactionDate = DateTime.Now;
sourceWallet.CacheSum -= convertMoneyRequest.Sum;
if (sourceWallet.CacheSum < 0)
{
return(new WalletApiErrorResponse("Не хватает денег"));
}
sourceWallet.Operations.Add(new WalletOperation()
{
Mov = -convertMoneyRequest.Sum,
CreateDate = transactionDate,
Comment = $"Перевод на кошелек {targetWallet.Id}"
});
targetWallet.CacheSum += convertedSum;
targetWallet.Operations.Add(new WalletOperation()
{
Mov = convertedSum,
CreateDate = transactionDate,
Comment = $"Перевод с кошелька {sourceWallet.Id}"
});
await _context.SaveChangesAsync();
await trans.CommitAsync();
return(new TransferResponse(sourceWallet, targetWallet));
}
}
catch (DbUpdateConcurrencyException)
{
return(new WalletApiErrorResponse("Ошибка операции, состояние кошелька было изменено, во время операции"));
}
catch (Exception ex)
{
return(new WalletApiErrorResponse(ex));
}
}
/// <summary>
/// This call is similar to CreditCard Create.
/// It is intended to be used server-server for the purpose of migrating credit card information to WePay.
/// If AutoAuthorize is set to true, WePay will automatically test cards transferred to us via CreditCard Transfer by making a $0.00 authorization (in rare instances, the authorization amount may be $1.00 instead).
/// All payment error codes (200X) are possible return values for CreditCard Transfer.
/// PERMISSION REQUIRED
/// </summary>
/// <param name="transferRequest"></param>
/// <param name="useStaging"></param>
/// <returns></returns>
public async Task <StateResponse> TransferAsync(TransferRequest transferRequest,
string accessToken = null,
bool?useStaging = null)
{
return(await PostRequestAsync(transferRequest, EndPointUrls.Transfer, accessToken, useStaging));
}
/// <summary>
/// Requests an image from SecondLife and blocks until it's received.
/// </summary>
/// <param name="ImageID">The Image's AssetID</param>
public byte[] RequestImage(LLUUID ImageID)
{
byte[] imgData = CachedImage(ImageID);
if (imgData != null)
{
return imgData;
}
TransferRequest tr;
lock (htDownloadRequests)
{
if (htDownloadRequests.ContainsKey(ImageID) == false)
{
tr = new TransferRequest();
tr.Size = int.MaxValue; // Number of bytes expected
tr.Received = 0; // Number of bytes received
tr.TimeOfLastPacket = Helpers.GetUnixTime(); // last time we recevied a packet for this request
htDownloadRequests[ImageID] = tr;
Packet packet = ImagePacketHelper.RequestImage(ImageID);
slClient.Network.SendPacket(packet);
}
else
{
tr = htDownloadRequests[ImageID];
}
}
// Wait for transfer to complete.
while( !tr.Completed.WaitOne(10000, false) ) //If it times out, then check, otherwise loop again until WaitOne returns true
{
slClient.Log("Warning long running texture download: " + ImageID.ToStringHyphenated(), Helpers.LogLevel.Warning);
Console.WriteLine("Downloaded : " + tr.Received);
if( (Helpers.GetUnixTime() - tr.TimeOfLastPacket) > 10 )
{
tr.Status = false;
tr.StatusMsg = "Timeout while downloading image.";
slClient.Log(tr.StatusMsg, Helpers.LogLevel.Error);
tr.Completed.Set();
}
}
if (tr.Status == true)
{
return tr.AssetData;
}
else
{
throw new Exception("RequestImage: " + tr.StatusMsg);
}
}
