public SearchResultItem(string transactionHash, string transactionId,
ProximaxMessagePayloadModel messagePayload)
{
TransactionHash = transactionHash;
TransactionId = transactionId;
MessagePayload = messagePayload;
}
private IObservable <string> CreateAndAnnounceTransaction(UploadParameter uploadParam,
ProximaxMessagePayloadModel messagePayload)
{
return(BlockchainTransactionService.CreateAndAnnounceTransaction(
messagePayload, uploadParam.SignerPrivateKey, uploadParam.RecipientPublicKey,
uploadParam.RecipientAddress,
uploadParam.TransactionDeadline, uploadParam.TransactionMosaics,
uploadParam.UseBlockchainSecureMessage));
}
private DownloadResult CreateCompleteDownloadResult(ProximaxMessagePayloadModel messagePayload,
Func <Stream> byteStreamSupplier, string transactionHash)
{
var data = messagePayload.Data;
return(DownloadResult.Create(transactionHash, messagePayload.PrivacyType, messagePayload.Version,
new DownloadResultData(byteStreamSupplier, data.Digest, data.DataHash, data.Timestamp,
data.Description, data.Name, data.ContentType, data.Metadata)));
}
public IObservable <ProximaxMessagePayloadModel> CreateMessagePayload(UploadParameter uploadParameter,
ProximaxDataModel uploadedData)
{
CheckParameter(uploadParameter != null, "uploadParameter is required");
CheckParameter(uploadedData != null, "uploadedData is required");
return(Observable.Return(ProximaxMessagePayloadModel.Create(
uploadParameter.PrivacyStrategy.GetPrivacyType(),
uploadParameter.Version, uploadedData)));
}
private IObservable <Stream> GetDataByteStream(ProximaxMessagePayloadModel messagePayload, string dataHash,
IPrivacyStrategy privacyStrategy, bool validateDigest, string digest)
{
var resolvedDataHash = messagePayload != null ? messagePayload.Data.DataHash : dataHash;
var resolvedDigest = messagePayload != null ? messagePayload.Data.Digest : digest;
var resolvedContentType = messagePayload?.Data.ContentType;
return(RetrieveProximaxDataService.GetDataByteStream(resolvedDataHash, privacyStrategy, validateDigest,
resolvedDigest, resolvedContentType));
}
public IObservable <string> CreateAndAnnounceTransaction(ProximaxMessagePayloadModel messagePayload,
string signerPrivateKey,
string recipientPublicKey, string recipientAddress, int transactionDeadline,
List <Mosaic> transactionMosaics, bool useBlockchainSecureMessage)
{
CheckParameter(signerPrivateKey != null, "signerPrivateKey is required");
CheckParameter(messagePayload != null, "messagePayload is required");
var message = BlockchainMessageService.CreateMessage(messagePayload, signerPrivateKey,
recipientPublicKey, recipientAddress, useBlockchainSecureMessage);
var recipient = GetRecipient(signerPrivateKey, recipientPublicKey, recipientAddress);
var transaction = CreateTransaction(recipient, transactionDeadline, transactionMosaics, message);
var signedTransaction = NemUtils.SignTransaction(signerPrivateKey, transaction);
TransactionClient.Announce(signedTransaction, NemUtils.GetAddressFromPrivateKey(signerPrivateKey));
return(Observable.Return(signedTransaction.Hash));
}
public IMessage CreateMessage(ProximaxMessagePayloadModel messagePayload, string senderPrivateKey,
string recipientPublicKeyRaw,
string recipientAddress, bool useBlockchainSecureMessage)
{
CheckParameter(messagePayload != null, "messagePayload is required");
var jsonPayload = messagePayload.ToJson();
if (useBlockchainSecureMessage)
{
var recipientPublicKey =
this.GetRecipientPublicKey(senderPrivateKey, recipientPublicKeyRaw, recipientAddress);
return(SecureMessage.Create(jsonPayload, senderPrivateKey, recipientPublicKey));
}
else
{
return(PlainMessage.Create(jsonPayload));
}
}
private bool MatchesSearchCriteria(ProximaxMessagePayloadModel messagePayload, string nameFilter,
string descriptionFilter, string metadataKeyFilter, string metadataValueFilter)
{
if (nameFilter != null)
{
if (!(messagePayload.Data.Name != null &&
messagePayload.Data.Name.Contains(nameFilter)))
{
return(false);
}
}
if (descriptionFilter != null)
{
if (!(messagePayload.Data.Description != null &&
messagePayload.Data.Description.Contains(descriptionFilter)))
{
return(false);
}
}
if (metadataKeyFilter != null)
{
if (metadataValueFilter != null)
{
if (!(messagePayload.Data.Metadata != null &&
metadataValueFilter.Equals(messagePayload.Data.Metadata[metadataKeyFilter])))
{
return(false);
}
}
else
{
if (!(messagePayload.Data.Metadata != null &&
messagePayload.Data.Metadata.ContainsKey(metadataKeyFilter)))
{
return(false);
}
}
}
return(true);
}
private UploadResult CreateUploadResult(ProximaxMessagePayloadModel messagePayload, string transactionHash)
{
return(UploadResult.Create(transactionHash, messagePayload.PrivacyType, messagePayload.Version,
messagePayload.Data));
}
