public async void TestSetup()
{
m_loggingContext = new LoggingContext(Guid.NewGuid());
var data = TestHelper.CreateApplicationEndpoint();
m_mockEventChannel = data.EventChannel;
m_restfulClient = data.RestfulClient;
ApplicationEndpoint applicationEndpoint = data.ApplicationEndpoint;
await applicationEndpoint.InitializeAsync(m_loggingContext).ConfigureAwait(false);
await applicationEndpoint.InitializeApplicationAsync(m_loggingContext).ConfigureAwait(false);
IConversation conversation = null;
applicationEndpoint.HandleIncomingAudioVideoCall += (sender, args) => conversation = args.NewInvite.RelatedConversation;
TestHelper.RaiseEventsFromFile(m_mockEventChannel, "Event_IncomingAudioCall.json");
TestHelper.RaiseEventsFromFile(m_mockEventChannel, "Event_ConversationConnected_WithAudio.json");
TestHelper.RaiseEventsFromFile(m_mockEventChannel, "Event_AudioVideoConnected.json");
m_restfulClient.HandleRequestProcessed +=
(sender, args) => m_transferOperationId = TestHelper.RaiseEventsOnHttpRequest(args, DataUrls.Transfer, HttpMethod.Post, "Event_TransferStarted.json", m_mockEventChannel);
m_transfer = await conversation.AudioVideoCall.TransferAsync(new SipUri("sip:[email protected]"), null, m_loggingContext).ConfigureAwait(false);
}
public void Supprimer(ITransfer transfer)
{
using (_monFtp = new Ftp())
{
_monFtp.Connect(_maConfig.Host, _maConfig.Port);
_monFtp.Login(_maConfig.Login, _maConfig.MotDePass);
string resteChemin = MethodesGlobales.GetCheminServerSansRacinne(transfer.GetPath(), _maConfig.GetUriChaine());
if (string.IsNullOrEmpty(resteChemin))
{
VariablesGlobales._leLog.LogCustom("Vous ne pouvez supprimer le répertoire racinne !");
MessageBox.Show("Vous ne pouvez supprimer le répertoire racinne !");
}
else
{
if (transfer.EstUnDossier())
{
_monFtp.DeleteFolder(resteChemin);
}
else
{
_monFtp.DeleteFile(resteChemin);
}
}
_monFtp.Close();
}
}
public void Test_Transfer_To_User_Wallet_Successful()
{
SortedDictionary <String, Object> receiver = new SortedDictionary <String, Object>();
receiver.Add("name", "Adny Lee");
receiver.Add("phoneNumber", "+2348131393827");
receiver.Add("type", "USER");
SortedDictionary <String, Object> param = new SortedDictionary <String, Object>();
param.Add("amount", "100");
param.Add("country", "NG");
param.Add("currency", "NGN");
param.Add("reason", "transfer reason message");
param.Add("receiver", receiver);
param.Add("reference", Util.generateTransactionRefrenceNo());
String paramString = Util.mapToJsonString(param);
String signature = Util.calculateHMAC(paramString, PRIVATEKEY);
connectionClient = new ConnectionClient(BASEURL, Util.getHeader(signature, MERCHANTID));
transaction = new Transfer(connectionClient);
JObject response = transaction.transferToWallet(param).Result;
walletTransferUserStatusInput = (JObject)response.GetValue("data");
Assert.AreEqual("SUCCESSFUL", response.GetValue("message").ToString());
}
public void Test_Transfer_To_Bank_Successful()
{
SortedDictionary <String, Object> receiver = new SortedDictionary <String, Object>();
receiver.Add("bankAccountNumber", "22222222222222");
receiver.Add("bankCode", "058");
receiver.Add("name", "test_20191123132233");
SortedDictionary <String, Object> param = new SortedDictionary <String, Object>();
param.Add("amount", "100");
param.Add("country", "NG");
param.Add("currency", "NGN");
param.Add("reason", "transfer reason message");
param.Add("receiver", receiver);
param.Add("reference", Util.generateTransactionRefrenceNo());
String paramString = Util.mapToJsonString(param);
String signature = Util.calculateHMAC(paramString, PRIVATEKEY);
connectionClient = new ConnectionClient(BASEURL, Util.getHeader(signature, MERCHANTID));
transaction = new Transfer(connectionClient);
JObject response = transaction.transferToBank(param).Result;
bankTransferStatusInput = (JObject)response.GetValue("data");
String message = response.GetValue("message").ToString();
Assert.AreEqual(message, "SUCCESSFUL");
}
/// <summary>Add SimpleS3 services to a service collection.</summary>
/// <param name="collection">The service collection</param>
public static IClientBuilder AddAmazonS3(this IServiceCollection collection)
{
ICoreBuilder coreBuilder = SimpleS3CoreServices.AddSimpleS3Core(collection);
coreBuilder.UseAmazonS3();
IHttpClientBuilder httpBuilder = coreBuilder.UseHttpClientFactory();
httpBuilder.UseDefaultHttpPolicy();
coreBuilder.Services.AddSingleton(x =>
{
//We have to call a specific constructor for dependency injection
IObjectClient objectClient = x.GetRequiredService <IObjectClient>();
IBucketClient bucketClient = x.GetRequiredService <IBucketClient>();
IMultipartClient multipartClient = x.GetRequiredService <IMultipartClient>();
IMultipartTransfer multipartTransfer = x.GetRequiredService <IMultipartTransfer>();
ITransfer transfer = x.GetRequiredService <ITransfer>();
ISignedObjectClient?signedObjectClient = x.GetRequiredService <ISignedObjectClient>();
return(new AmazonS3Client(objectClient, bucketClient, multipartClient, multipartTransfer, transfer, signedObjectClient));
});
//Add the client as the interface too
coreBuilder.Services.AddSingleton <ISimpleClient>(x => x.GetRequiredService <AmazonS3Client>());
return(new ClientBuilder(collection, httpBuilder, coreBuilder));
}
public void RemoveDownload(ITransfer transfer)
{
if (transfer.Status == Status.Idle)
{
Transfers.Remove(transfer);
}
}
private bool ValidateTransfer(ITransfer transfer)
{
var isValid = true;
if (transfer.Amount <= 0 || transfer.Amount > 1_000_000_000)
{
_log.Warning("Processed transfer event with invalid amount", context: transfer);
}
if (string.IsNullOrEmpty(transfer.TransactionId))
{
isValid = false;
_log.Warning("Transfer event without transaction id", context: transfer);
}
if (string.IsNullOrEmpty(transfer.AssetSymbol))
{
isValid = false;
_log.Warning("Transfer event without asset symbol", context: transfer);
}
if (string.IsNullOrEmpty(transfer.SenderCustomerId))
{
isValid = false;
_log.Warning("Transfer event without sender id", context: transfer);
}
if (string.IsNullOrEmpty(transfer.ReceiverCustomerId))
{
isValid = false;
_log.Warning("Transfer event without receiver id", context: transfer);
}
return(isValid);
}
private void ValidateTransferRules(ITransfer transferResource, List <ValidationResult> results, bool validateModelForPost)
{
if (transferResource == null)
{
return;
}
if (validateModelForPost)
{
if (string.IsNullOrWhiteSpace(transferResource.Context))
{
results.Add(new ValidationResult("Context must have a value", new[] { "Context" }));
}
}
if (transferResource.DateandTimeOfTransfer.HasValue && transferResource.DateandTimeOfTransfer.Value > DateTime.UtcNow)
{
results.Add(new ValidationResult("Date and Time Of Transfer must be less the current date/time", new[] { "DateandTimeOfTransfer" }));
}
if (transferResource.DateandTimeofTransferAccepted.HasValue && transferResource.DateandTimeofTransferAccepted.Value > DateTime.UtcNow)
{
results.Add(new ValidationResult("Date and Time of Transfer Accepted must be less the current date/time", new[] { "DateandTimeofTransferAccepted" }));
}
if (transferResource.ActualCallbackTime.HasValue && transferResource.ActualCallbackTime.Value > DateTime.UtcNow)
{
results.Add(new ValidationResult("Actual Callback Time must be less the current date/time", new[] { "ActualCallbackTime" }));
}
if (transferResource.LastModifiedDate.HasValue && transferResource.LastModifiedDate.Value > DateTime.UtcNow)
{
results.Add(new ValidationResult("Last Modified Date must be less the current date/time", new[] { "LastModifiedDate" }));
}
}
private void ListerContenuLocal(object sender, EventArgs e)
{
ITransfer unTransferable = (ITransfer)trv_arboLocal.SelectedNode.Tag;
ElementFolder unDossier = null;
if (unTransferable.EstUnDossier())
{
unDossier = (ElementFolder)unTransferable;
lst_itranfertLocal.Items.Clear();
foreach (ITransfer item in unDossier.ListerContenu())
{
ListViewItem uneListItem = new ListViewItem();
uneListItem.Text = item.GetName();
uneListItem.Tag = item;
if (item.EstUnDossier())
{
uneListItem.ImageIndex = 0;
}
else
{
uneListItem.ImageIndex = 1;
}
lst_itranfertLocal.Items.Add(uneListItem);
}
}
}
/// <param name="bootloader"></param>
/// <param name="pin"></param>
public VersionFrm(IBootloader bootloader, ITransfer pin)
{
manager = new Manager(bootloader.Env);
_pin = pin;
InitializeComponent();
Icon = Resource.Package_32;
editorStepGen._.WordWrap = false;
editorStepGen._.IsReadOnly = true;
editorStepGen._.FontSize = 9.25f;
editorStepGen.setBackgroundFromString("#F4F4F4");
editorFinalScript.colorize(TextEditor.ColorSchema.SBEScripts);
editorFinalScript.codeCompletionInit(new Inspector(bootloader), new MSBuild.Parser(bootloader.Env, bootloader.UVariable));
editorFinalScript.CodeCompletionEnabled = true;
editorFinalScript._.WordWrap = false;
tabControlMain.Top = -22;
tabControlMain.Height += 22;
tcRevNumber.SizeMode = TabSizeMode.Fixed;
tcReplType.SizeMode = TabSizeMode.Fixed;
btnPrevStep.Visible = false;
string spath = bootloader.Env.SolutionPath ?? Settings.WPath;
ftbInputNum.Dialog.InitialDirectory = ftbOutputFile.Dialog.InitialDirectory
= ftbReplFile.Dialog.InitialDirectory
= spath.PathFormat();
}
private async Task StartAgentCallAndTransferFlowAsync(ICommunication communication, string agent, string callContext)
{
IAudioVideoInvitation invite = await EstablishCallWithAgentAsync(communication, agent).ConfigureAwait(false);
lock (m_syncRoot)
{
m_outboundAVConversations.Add(invite.RelatedConversation);
}
int result = Interlocked.Exchange(ref m_outboundCallTransferLock, 1);
if (result == 0)
{
//Step 4: do transfer
Logger.Instance.Information("[HuntGroupJob] Transferring call to " + agent);
IAudioVideoCall av = invite.RelatedConversation.AudioVideoCall;
ITransfer t = await av.TransferAsync(null, callContext, LoggingContext).ConfigureAwait(false);
await t.WaitForTransferCompleteAsync().TimeoutAfterAsync(TimeSpan.FromSeconds(30)).ConfigureAwait(false);
Logger.Instance.Information("[HuntGroupJob] Transfer completed successfully!");
}
else
{
// The call is already accepted and transfered by some one else
Logger.Instance.Information("[HuntGroupJob] The call is already accepted and transfered by some one else; cancelling the transfer for " + agent);
await invite.RelatedConversation.DeleteAsync(LoggingContext).ConfigureAwait(false);
}
}
internal static void Bind(this IModel model, ITransfer addr, string route, string queue)
{
var exchange = addr.Exchange;
IDictionary <string, object> args = null;
model.QueueBind(queue, exchange, route, args);
}
public SnapshotPaginationProvider(IFhirStore fhirStore, ITransfer transfer, ILocalhost localhost, ISnapshotPaginationCalculator snapshotPaginationCalculator)
{
this.fhirStore = fhirStore;
this.transfer = transfer;
this.localhost = localhost;
_snapshotPaginationCalculator = snapshotPaginationCalculator;
}
private void OnNodeUpdated(INode node)
{
if (!node.Equals(Source))
{
throw new ArgumentException("Received updated callback for wrong node");
}
Source.Updated -= OnNodeUpdated;
foreach (var child in ((IFolder)node).Children)
{
ITransfer t = Transfers.CreateTransfer(child, Path.Combine(Destination, child.Name), 0);
SubTransfers.Add(t);
}
if (startCalled)
{
Download();
}
else
{
Status = Status.Pending;
listingDone = true;
}
}
/// <param name="bootloader"></param>
/// <param name="pin"></param>
public VersionFrm(IBootloader bootloader, ITransfer pin)
{
manager = new Manager(bootloader.Env);
_pin = pin;
InitializeComponent();
Icon = Resource.Package_32;
editorStepGen._.WordWrap = false;
editorStepGen._.IsReadOnly = true;
editorStepGen._.FontSize = 9.25f;
editorStepGen.setBackgroundFromString("#F4F4F4");
editorFinalScript.colorize(TextEditor.ColorSchema.SBEScripts);
editorFinalScript.codeCompletionInit(new Inspector(bootloader), new MSBuild.Parser(bootloader.Env, bootloader.UVariable));
editorFinalScript.CodeCompletionEnabled = true;
editorFinalScript._.WordWrap = false;
tabControlMain.Top = -22;
tabControlMain.Height += 22;
tcRevNumber.SizeMode = TabSizeMode.Fixed;
tcReplType.SizeMode = TabSizeMode.Fixed;
btnPrevStep.Visible = false;
string spath = bootloader.Env.SolutionPath ?? Settings.WPath;
ftbInputNum.Dialog.InitialDirectory = ftbOutputFile.Dialog.InitialDirectory
= ftbReplFile.Dialog.InitialDirectory
= spath.PathFormat();
}
public EnvDteSniffer(IEnvironment env, ITransfer link)
{
this.env = env;
this.link = link;
InitializeComponent();
Icon = Resource.Package_32;
}
public void Publish <T>(ITransfer addr, T message)
{
Model.CreateExchange(addr);
var route = message.GetType().FullName;
var bytes = Serializer.Serialize(message);
Model.Publish(addr, route, bytes, Id);
}
public EnvDteSniffer(IEnvironment env, ITransfer link)
{
this.env = env;
this.link = link;
InitializeComponent();
Icon = Resource.Package_32;
}
private void ConnectTransfer(object obj)
{
if (obj is ITransfer)
{
ITransfer t = (ITransfer)obj;
t.Connect();
}
}
public void Test_Get_All_Supporting_Countries()
{
connectionClient = new ConnectionClient(BASEURL, Util.getHeader(PUBLICKEY, MERCHANTID));
transaction = new Transfer(connectionClient);
JObject response = transaction.allSupportingCountries().Result;
Assert.AreEqual("SUCCESSFUL", response.GetValue("message").ToString());
}
public DTECommandsFrm(IEnumerable <EnvDTE.Command> commands, ITransfer pin)
{
_commands = commands ?? Enumerable.Empty <EnvDTE.Command>();
_pin = pin;
InitializeComponent();
Icon = Resource.Package_32;
}
private void AddTransferItem(ITransfer t)
{
var ti = new PrototypeTransferItem();
ti.Init(t);
Items.Add(ti);
RefreshStart();
}
internal Transfer(ITransfer transfer)
{
Id = transfer.Id;
TargetUserId = transfer.TargetUserId;
KeyBlobId = transfer.KeyBlobId;
TargetBlobId = transfer.TargetBlobId;
Complete = transfer.Complete;
}
protected void Set(ITransfer transfer)
{
Id = transfer.Id;
TargetUserId = transfer.TargetUserId;
KeyId = transfer.KeyId;
TargetBlobId = transfer.TargetBlobId;
Complete = transfer.Complete;
}
public DTECommandsFrm(IEnumerable<EnvDTE.Command> commands, ITransfer pin)
{
_commands = commands;
this._pin = pin;
InitializeComponent();
Icon = Resource.Package_32;
}
protected void Initialize(IObjectClient objectClient, IBucketClient bucketClient, IMultipartClient multipartClient, IMultipartTransfer multipartTransfer, ITransfer transfer, ISignedObjectClient signedObjectClient)
{
_objectClient = objectClient;
_bucketClient = bucketClient;
_multipartClient = multipartClient;
_multipartTransfer = multipartTransfer;
_transfer = transfer;
_signedObjectClient = signedObjectClient;
}
private void AddTransferItem(ITransfer t)
{
var ti = new PrototypeTransferItem();
ti.Init(t);
Items.Add(ti);
RefreshStart();
}
public TransferNmdcProtocol(ITransfer trans)
: this(trans,
#if !COMPACT_FRAMEWORK
System.AppDomain.CurrentDomain.BaseDirectory
#else
System.IO.Directory.GetCurrentDirectory()
#endif)
{
}
internal static void CreateExchange(this IModel model, ITransfer addr)
{
var exchange = addr.Exchange;
var type = addr.Type;
var durable = false;
var autoDel = true;
IDictionary <string, object> args = null;
model.ExchangeDeclare(exchange, type, durable, autoDel, args);
}
public void Subscribe <I>() where I : IRequest
{
var cid = Client.Id;
var ids = new ITransfer[] { cid.Multi, cid.Uni };
foreach (var id in ids)
{
Client.Subscribe <I>(id, OnRequest);
}
}
public PropertiesFrm(IEnvironment env, ITransfer pin)
{
InitializeComponent();
Icon = Resource.Package_32;
_env = env;
_msbuild = new MSBuild.Parser(_env);
_pin = pin;
_cacheProperties = new ConcurrentDictionary <string, List <MSBuild.PropertyItem> >();
}
public List <ValidationResult> ValidateResource(ITransfer resource, bool validateModelForPost)
{
var context = new ValidationContext(resource, null, null);
var results = new List <ValidationResult>();
Validator.TryValidateObject(resource, context, results, true);
ValidateTransferRules(resource, results, validateModelForPost);
return(results);
}
public PropertiesFrm(IEnvironment env, ITransfer pin)
{
InitializeComponent();
Icon = Resource.Package_32;
_env = env;
_msbuild = new MSBuild.Parser(_env);
_pin = pin;
_cacheProperties = new ConcurrentDictionary<string, List<MSBuild.PropertyItem>>();
}
public PropertiesFrm(IEnvironment env, ITransfer pin)
{
InitializeComponent();
Icon = Resource.Package_32;
_env = env;
_msbuild = MSBuild.MakeEvaluator(_env);
_pin = pin;
_cacheProperties = new ConcurrentDictionary <string, IEnumerable <PropertyItem> >();
}
public ITransfer GetTransfer(string key)
{
ITransfer old = null;
lock (this)
{
transfers.TryGetValue(key, out old);
}
return(old);
}
public void EndTransfer(ITransfer trans)
{
string id = string.Format("{0}{1}", trans.RemoteAddress.Address.ToString(), trans.RemoteAddress.Port);
trans.Disconnect();
lock (this)
{
transfers.Remove(id);
}
}
public static bool Transfer()
{
if (currentCustomer.AccountCount() < 2)
{
ConsoleUtil.DisplayWait(Properties.Resources.TransferRequiresTwoAccounts);
return false;
}
ITransfer from = SelectAccount<ITransfer>(Properties.Resources.SelectAccountTransferFrom);
return Transfer(from);
}
public async Task <TransferResult> ExecuteAsync(TransferCommand transferCommand)
{
BlockchainType blockchainType = await _assetSettingsService.GetNetworkAsync(transferCommand.AssetId);
IBlockchainApiClient blockchainClient = _blockchainClientProvider.Get(blockchainType);
BlockchainTransferCommand cmd = new BlockchainTransferCommand(transferCommand.AssetId);
string lykkeAssetId = transferCommand.AssetId.IsGuid()
? transferCommand.AssetId
: await _lykkeAssetsResolver.GetLykkeId(transferCommand.AssetId);
foreach (var transferCommandAmount in transferCommand.Amounts)
{
decimal balance = await blockchainClient.GetBalanceAsync(transferCommandAmount.Source, lykkeAssetId);
if (transferCommandAmount.Amount == null)
{
if (balance > 0)
{
cmd.Amounts.Add(new TransferAmount
{
Amount = balance,
Source = transferCommandAmount.Source,
Destination = transferCommandAmount.Destination
});
continue;
}
throw new InsufficientFundsException(transferCommandAmount.Source, transferCommand.AssetId);
}
if (transferCommandAmount.Amount > balance)
{
throw new InsufficientFundsException(transferCommandAmount.Source, transferCommand.AssetId);
}
cmd.Amounts.Add(transferCommandAmount);
}
BlockchainTransferResult blockchainTransferResult = await blockchainClient.TransferAsync(cmd);
ITransfer transfer = await _transferRepository.AddAsync(new Transfer
{
AssetId = transferCommand.AssetId,
Blockchain = blockchainTransferResult.Blockchain,
CreatedOn = DateTime.UtcNow,
Amounts = transferCommand.Amounts,
Transactions = Mapper.Map <IEnumerable <TransferTransaction> >(blockchainTransferResult.Transactions)
});
return(Mapper.Map <TransferResult>(transfer));
}
public void Init(ITransfer t)
{
this.ContextMenu = new TransferMenu(t);
transfer = t;
transfer.TransferDone += OnTransferDone;
var icons = IconHandler.Instance;
pauseButton.Image = icons.MediaPlaybackPause;
deleteButton.Image = icons.ProcessStop;
fileName.Text = t.Source.Name;
info.Text = "";
Anchor = AnchorStyles.Left | AnchorStyles.Right;
}
public void Remove(ITransfer transfer)
{
throw new NotImplementedException();
//Use the following event: public event TransferDelegate TransferRemoved;
}
private CloudClient()
{
pipeProxy = GetChannel(channelName).CreateChannel();
}
/// <summary>
/// Initializes a new instance of the <see cref="Transfer"/> class.
/// </summary>
/// <param name="transfer">The transfer.</param>
internal Transfer(ITransfer transfer)
{
Set(transfer);
}
public TransferNmdcProtocol(ITransfer trans, string dir)
{
directory = dir;
this.trans = trans;
MessageReceived = new FmdcEventHandler(OnMessageReceived);
MessageToSend = new FmdcEventHandler(OnMessageToSend);
ChangeDownloadItem = new FmdcEventHandler(OnChangeDownloadItem);
RequestTransfer = new FmdcEventHandler(OnRequestTransfer);
Error = new FmdcEventHandler(OnError);
Update = new FmdcEventHandler(OnUpdate);
TimerCallback timerDelegate = new TimerCallback(OnTimer);
long interval = 10 * 1000; // 10 seconds
timer = new System.Threading.Timer(timerDelegate, trans, interval, interval);
trans.ConnectionStatusChange += new FmdcEventHandler(trans_ConnectionStatusChange);
}
public void AddTransfer(ITransfer trans)
{
string id = string.Format("{0}{1}", trans.RemoteAddress.Address.ToString(), trans.RemoteAddress.Port);
//if (ContainsTransfer(id))
//{
// trans.Disconnect("stop creating stuff");
// return;
//}
RemoveTransfer(id);
trans.ConnectionStatusChange += new FmdcEventHandler(trans_ConnectionStatusChange);
// Add transfer to list.
lock (transfers)
{
transfers.Add(id, trans);
}
}
public bool TransferUpdate(ITransfer obj)
{
var transferDocument = GetDocumentById(TransfersCollection, obj.Id.ToString());
if (transferDocument == null)
return false;
var updatedTransfer = Client.ReplaceDocumentAsync(transferDocument.SelfLink, obj).Result;
return updatedTransfer != null;
}
public TransferZpocProtocol(ITransfer trans, string dir)
: base(trans, dir)
{
}
/// <summary>
/// If connection to remote ip and port already exist that connection will be closed and then the new one will be connected
/// </summary>
/// <param name="trans">Transfer you want to start</param>
public void StartTransfer(ITransfer trans)
{
AddTransfer(trans);
// Connect transfer.
#if !COMPACT_FRAMEWORK
Thread t = new Thread(new ParameterizedThreadStart(ConnectTransfer));
t.IsBackground = true;
t.Start(trans);
#else
Thread t = new Thread(new ThreadStart(ConnectTransfer));
t.IsBackground = true;
t.Start(trans);
#endif
}
public bool TransferDelete(ITransfer obj)
{
var transferDocument = GetDocumentById(TransfersCollection, obj.Id.ToString());
if (transferDocument == null)
return true;
var result = Client.DeleteDocumentAsync(transferDocument.SelfLink);
return true;
}
public void EndTransfer(ITransfer trans)
{
string id = string.Format("{0}{1}", trans.RemoteAddress.Address.ToString(), trans.RemoteAddress.Port);
trans.Disconnect();
lock (transfers)
{
transfers.Remove(id);
}
}
public Transfer(TransferHash previous, ITransfer trans)
: this(previous, trans.DestinyPk)
{
}
public Lock(ITransfer trans)
: base(trans, null)
{
if (trans.Me == null)
throw new System.ArgumentNullException("Transfer.Me can't be null.");
extended = true;
pk = trans.Me.TagInfo.Version.Replace(" ", "").Replace("V:", "") +"ABCABCABCABCABCA";
if (pk.Length > 16)
pk = pk.Substring(0, 16);
MakeRaw();
}
public ITransfer TransferCreate(ITransfer obj)
{
dynamic doc = Client.CreateDocumentAsync(TransfersCollection.SelfLink, obj).Result;
return (Transfer)doc.Resource;
}
public void AddTransfer(ITransfer trans)
{
string id = string.Format("{0}{1}", trans.RemoteAddress.Address.ToString(), trans.RemoteAddress.Port);
RemoveTransfer(id);
trans.ConnectionStatusChange += new FmdcEventHandler(trans_ConnectionStatusChange);
// Add transfer to list.
lock (this)
{
transfers.Add(id, trans);
}
}
private void OnTransferAdded(ITransfer t)
{
AddTransferItem(t);
}
