public static BasicBlobContainer BlobToBasicBlobContainer(Blob blob)
{
var basicBlob = new BasicBlobContainer()
{
Name = blob.Name,
Url = blob.Url,
Container = blob.Container,
BlobType = BlobEntryType.Blob
};
return basicBlob;
}
public static string ComputeId(Blob blob)
{
using (var md = new MessageDigest())
{
byte[] data = Encoding.Default.GetBytes(string.Format("blob {0}\0", blob.Size));
md.Update(data);
md.Update(blob.Data);
var digest = md.Digest();
return Helper.ByteArrayToId(digest);
}
}
public void WriteBlob()
{
using (var repo = GetTrashRepository())
{
var blob = Blob.CreateFromFile(repo, "Resources/single_file_commit/i-am-a-file");
Assert.AreEqual("95ea6a6859af6791464bd8b6de76ad5a6f9fad81", blob.Hash);
Assert.AreEqual(File.ReadAllText("Resources/single_file_commit/i-am-a-file"), blob.Data);
var same_blob = new Blob(repo, blob.Hash);
Assert.AreEqual(File.ReadAllBytes("Resources/single_file_commit/i-am-a-file"), same_blob.RawData);
blob = Blob.Create(repo, "and this is the data in me\r\n\r\n");
Assert.AreEqual("95ea6a6859af6791464bd8b6de76ad5a6f9fad81", blob.Hash);
blob = Blob.Create(repo, Encoding.UTF8.GetBytes("and this is the data in me\r\n\r\n"));
Assert.AreEqual("95ea6a6859af6791464bd8b6de76ad5a6f9fad81", blob.Hash);
}
}
public string ReadAsText(Blob blob, string encoding)
{
return null;
}
public void SetMetadata(string blobName, IDictionary<string, string> metadata, string leaseId)
{
Blob existing;
if (!_items.TryRemove(blobName, out existing))
{
throw new InvalidOperationException();
}
if (leaseId == null)
{
existing.ThrowIfLeased();
}
else
{
existing.ThrowIfLeaseMismatch(leaseId);
}
_items[blobName] = new Blob(existing.BlobType, existing.Contents, metadata, existing.LeaseId,
existing.LeaseExpires);
}
public void ReadAsBinaryString(Blob filedata)
{
}
public void CommitHonorsConfigCommitEncoding()
{
string workingDirectory = Path.Combine(trash.FullName, Path.GetRandomFileName());
// Creating a new repo
using (var repo = Repository.Init(workingDirectory))
{
// Setting the in-memory commitencoding configuration entry
repo.Config["i18n.commitencoding"] = "ISO-8859-2";
// Adding a new file to the filesystem
string filepath = Path.Combine(workingDirectory, "a file.txt");
File.WriteAllText(filepath, "content");
// Adding the new file to index
repo.Index.Add(filepath);
// Committing
string message = "Jak se máš?\n\nMám se dobře.";
Commit c = repo.Commit(message, new Author("nulltoken", "*****@*****.**")); //How are you? I'm fine.
// Loading the commit
var commit = new Commit(repo, c.Hash);
Assert.AreEqual("ISO-8859-2", commit.Encoding.WebName.ToUpperInvariant());
var blob = new Blob(repo, c.Hash);
var messageBytes = new byte[message.Length];
Array.Copy(blob.RawData, 190, messageBytes, 0, message.Length);
Assert.IsTrue(Encoding.GetEncoding("ISO-8859-2").GetBytes(message).SequenceEqual(messageBytes));
}
}
public void ReadAsText(Blob blob, string label)
{
}
private static bool InternalCopyBlob(Blob blobDst, Blob blobSrc)
{
blobDst.CloudBlockBlob.StartCopyFromBlob(blobSrc.CloudBlockBlob);
// requesting operation status
// todo: measure copy speed, and fetch attributes with less frequency based on avg speed
while (true)
{
blobDst.CloudBlockBlob.FetchAttributes();
if (blobDst.CloudBlockBlob.CopyState.Status != CopyStatus.Pending)
break;
// sleeping 1 second per remaining 50-megabytes (this is the rate of a commong hard drive)
var sleep = (blobDst.CloudBlockBlob.CopyState.TotalBytes ?? 0 - blobDst.CloudBlockBlob.CopyState.BytesCopied ?? 0) /
(50 * 1024000.0);
if (sleep > 60)
Thread.Sleep(TimeSpan.FromSeconds(60));
else if (sleep > 0.1)
Thread.Sleep(TimeSpan.FromSeconds(sleep));
}
var isCopyOk = blobDst.CloudBlockBlob.CopyState.Status == CopyStatus.Success;
return isCopyOk;
}
private static IEnumerable<Blob> EnumerateFiles(string directory, bool includeDeleted, bool orderByDate, Stream singlePackage)
{
if ((directory == null) == (singlePackage == null)) throw new ArgumentException();
IEnumerable<string> packages;
if (directory != null)
{
directory = Path.GetFullPath(directory);
packages =
#if NET35
Directory.GetFiles(
#else
Directory.EnumerateFiles(
#endif
directory, "*.shaman-blobs");
if (orderByDate)
{
packages = packages.Select(x => new { Path = x, Date = File.GetCreationTimeUtc(x) }).OrderBy(x => x.Date).Select(x => x.Path);
}
}
else
{
packages = new string[1];
}
foreach (var pkg in packages)
{
using (var fs = singlePackage ?? File.Open(pkg, FileMode.Open, FileAccess.Read, FileShare.Delete | FileShare.ReadWrite))
{
Blob previous = null;
var packagePath = pkg;
while (true)
{
var first = fs.ReadByte();
if (first == -1) break;
var len = 0;
len |= first << 0;
len |= ReadByteChecked(fs) << 8;
len |= ReadByteChecked(fs) << 16;
len |= ReadByteChecked(fs) << 24;
var nl = 0;
nl |= ReadByteChecked(fs) << 0;
var d = ReadByteChecked(fs);
// var wasNameCorrupted = false;
// if (!SupportCorruptedFileNameLengths)
{
nl |= d << 8;
}
/* else
{
if (d != 0)
{
wasNameCorrupted = true;
Console.WriteLine("Fixing corrupted entry...");
fs.Seek(-1, SeekOrigin.Current);
fs.WriteByte(0);
}
}*/
var closedCleanly = ReadByteChecked(fs) == 1;
var deleted = ReadByteChecked(fs) == 1;
var nameBytes = new byte[nl];
while (nl != 0)
{
nl -= fs.Read(nameBytes, nameBytes.Length - nl, nl);
}
var name = Encoding.UTF8.GetString(nameBytes);
var next = fs.Position + len;
var blob = new Blob()
{
PackageFileName = directory != null ? Path.GetFileName(pkg) : null,
PackagePath = packagePath,
Length = len,
Name = name,
Path = directory != null ? Path.Combine(directory, name) : null,
ClosedCleanly = closedCleanly,
DataStartOffset = (int)fs.Position,
fileStream = fs,
Deleted = deleted,
};
if (previous != null) previous.fileStream = null;
previous = blob;
if (!deleted || includeDeleted)
yield return blob;
fs.Seek(next, SeekOrigin.Begin);
}
if (previous != null) previous.fileStream = null;
}
}
if (directory != null)
{
var additional = new List<Blob>();
lock (_lock)
{
var dir = GetDirectory(directory);
foreach (var file in dir.locationsToAdd)
{
FileLocation mostRecent;
dir.locations.TryGetValue(file.BlobName, out mostRecent);
if (mostRecent == file)
{
additional.Add(new Blob()
{
DataStartOffset = file.DataStartOffset,
PackageFileName = file.PackageFileName,
Name = file.BlobName,
ClosedCleanly = true,
Length = file.Length,
Path = Path.Combine(directory, file.BlobName)
});
}
}
}
foreach (var item in additional)
{
yield return item;
}
}
}
public void ReadAsBinaryString(Blob filedata)
{
}
public void ReadAsDataURL(Blob blob)
{
}
/// <summary>
/// Flushes the current block of data.
/// </summary>
private void FlushBlock()
{
if (_currentEntities.Count == 0) { return; }
// encode into block.
var block = new PrimitiveBlock();
Encoder.Encode(block, _reverseStringTable, _currentEntities);
_currentEntities.Clear();
_reverseStringTable.Clear();
// serialize.
_buffer.SetLength(0);
_runtimeTypeModel.Serialize(_buffer, block);
var blockBytes = _buffer.ToArray();
_buffer.SetLength(0);
if (_compress)
{ // compress buffer.
throw new NotSupportedException();
}
// create blob.
var blob = new Blob();
blob.raw = blockBytes;
_runtimeTypeModel.Serialize(_buffer, blob);
// create blobheader.
var blobHeader = new BlobHeader();
blobHeader.datasize = (int)_buffer.Length;
blobHeader.indexdata = null;
blobHeader.type = Encoder.OSMData;
_runtimeTypeModel.SerializeWithLengthPrefix(_stream, blobHeader, _blobHeaderType, ProtoBuf.PrefixStyle.Fixed32BigEndian, 0);
// serialize to stream.
_buffer.Seek(0, SeekOrigin.Begin);
_buffer.CopyTo(_stream);
}
public void ReadAsArrayBuffer(Blob blob)
{
}
/// <summary>
/// Initializes this target.
/// </summary>
public override void Initialize()
{
_currentEntities.Clear();
// write the mandatory header.
_buffer.Seek(0, SeekOrigin.Begin);
// create header block.
var blockHeader = new HeaderBlock();
blockHeader.required_features.Add("OsmSchema-V0.6");
blockHeader.required_features.Add("DenseNodes");
_runtimeTypeModel.Serialize(_buffer, blockHeader);
var blockHeaderData = _buffer.ToArray();
_buffer.SetLength(0);
// create blob.
var blob = new Blob();
blob.raw = blockHeaderData;
_runtimeTypeModel.Serialize(_buffer, blob);
// create blobheader.
var blobHeader = new BlobHeader();
blobHeader.datasize = (int)_buffer.Length;
blobHeader.indexdata = null;
blobHeader.type = Encoder.OSMHeader;
_runtimeTypeModel.SerializeWithLengthPrefix(_stream, blobHeader, _blobHeaderType, ProtoBuf.PrefixStyle.Fixed32BigEndian, 0);
// flush to stream.
_buffer.Seek(0, SeekOrigin.Begin);
_buffer.CopyTo(_stream);
}
private void PerformRequest(HttpContext context, Stream output, bool json, string controllerName)
{
HttpRequest request = context.Request;
HttpResponse response = context.Response;
ControllerConfiguration config = null;
try
{
config = DataControllerBase.CreateConfigurationInstance(GetType(), controllerName);
}
catch (Exception )
{
response.StatusCode = 404;
return;
}
if (!(AuthorizeRequest(request, config)))
{
response.StatusCode = 404;
return;
}
// analyze route segments
bool isHttpGetMethod = (HttpMethod == "GET");
string view = null;
string key = null;
string fieldName = null;
string actionGroupId = null;
string actionId = null;
string commandName = null;
AnalyzeRouteValues(request, response, isHttpGetMethod, config, out view, out key, out fieldName, out actionGroupId, out actionId, out commandName);
if (response.StatusCode == 404)
return;
bool keyIsAvailable = !(String.IsNullOrEmpty(key));
if (String.IsNullOrEmpty(view))
if (isHttpGetMethod)
view = Controller.GetSelectView(controllerName);
else
if (commandName == "Insert")
view = Controller.GetInsertView(controllerName);
else
if (commandName == "Update")
view = Controller.GetUpdateView(controllerName);
else
if (commandName == "Delete")
view = Controller.GetDeleteView(controllerName);
if (SelectView(config, view) == null)
{
response.StatusCode = 404;
return;
}
XPathNavigator dataFieldNode = null;
XPathNavigator fieldNode = null;
if (!(String.IsNullOrEmpty(fieldName)))
{
dataFieldNode = SelectDataField(config, view, fieldName);
fieldNode = SelectField(config, fieldName);
if ((dataFieldNode == null) || (fieldNode == null))
{
response.StatusCode = 404;
return;
}
}
// create a filter
List<string> filter = new List<string>();
// process key fields
if (keyIsAvailable)
{
string[] values = key.Split(new char[] {
','}, StringSplitOptions.RemoveEmptyEntries);
XPathNodeIterator keyIterator = config.Select("/c:dataController/c:fields/c:field[@isPrimaryKey=\'true\']");
int index = 0;
while (keyIterator.MoveNext())
{
filter.Add(String.Format("{0}:={1}", keyIterator.Current.GetAttribute("name", String.Empty), values[index]));
index++;
}
}
// process quick find
string quickFind = request.Params["_q"];
if (!(String.IsNullOrEmpty(quickFind)))
filter.Add(String.Format("{0}:~{1}", config.SelectSingleNode("/c:dataController/c:views/c:view[@id=\'{0}\']/.//c:dataField[1]/@fieldName", view).Value, quickFind));
// process filter parameters
if (!(keyIsAvailable))
foreach (string filterName in request.Params.Keys)
if (SelectDataField(config, view, filterName) != null)
filter.Add(String.Format("{0}:={1}", filterName, request.Params[filterName]));
else
{
Match m = BusinessRules.SqlFieldFilterOperationRegex.Match(filterName);
string filterFieldName = m.Groups["Name"].Value;
if (m.Success && (SelectDataField(config, view, filterFieldName) != null))
{
string operation = m.Groups["Operation"].Value;
RowFilterOperation filterOperation = ((RowFilterOperation)(TypeDescriptor.GetConverter(typeof(RowFilterOperation)).ConvertFromString(operation)));
string filterValue = request.Params[filterName];
if ((filterOperation == RowFilterOperation.Includes) || (filterOperation == RowFilterOperation.DoesNotInclude))
filterValue = Regex.Replace(filterValue, ",", "$or$");
else
if (filterOperation == RowFilterOperation.Between)
filterValue = Regex.Replace(filterValue, ",", "$and$");
filter.Add(String.Format("{0}:{1}{2}", filterFieldName, RowFilterAttribute.ComparisonOperations[Convert.ToInt32(filterOperation)], filterValue));
}
}
// execute request
if (isHttpGetMethod)
if (fieldNode != null)
{
string style = "o";
if (request.QueryString["_style"] == "Thumbnail")
style = "t";
string blobPath = String.Format("~/Blob.ashx?{0}={1}|{2}", fieldNode.GetAttribute("onDemandHandler", String.Empty), style, key);
context.RewritePath(blobPath);
Blob blobHandler = new Blob();
((IHttpHandler)(blobHandler)).ProcessRequest(context);
}
else
ExecuteHttpGetRequest(request, response, output, json, controllerName, view, filter, keyIsAvailable);
else
ExecuteActionRequest(request, response, output, json, config, controllerName, view, key, filter, actionGroupId, actionId);
}
public void ReadAsDataURL(Blob blob)
{
}
private static void DeleteBlob(Blob blob, StringBuilder sb, BlobFactory blobFactory)
{
// Deleting
if (blob != null)
{
DeleteBlob(blob.ID, sb, blobFactory);
}
}
public void ReadAsText(Blob blob)
{
}
public BlobWriter(Blob blob)
: this(blob.Buffer, blob.Start, blob.Length)
{
}
public void Send(Blob data)
{
}
/// <summary>
/// Gets a blob reference to work with.
/// </summary>
/// <param name="fileLocation">Location of the blob to get a blob object for.</param>
/// <param name="fetchAttributes">Whether to fetch blob attributes or not.</param>
/// <param name="createContainer">Whether to create the container or not.</param>
/// <returns>Return the blob object for the given file location.</returns>
private Blob GetCloudBlockBlob(string fileLocation, bool fetchAttributes = false, bool createContainer = false)
{
// getting the object representing the blob
Container container = null;
Blob blob;
if (!this.blobsMap.TryGetValue(fileLocation, out blob))
{
// Gets the object representing the container.
var containerName = GetContainerName(fileLocation);
if (!this.containersMap.TryGetValue(containerName, out container))
{
var storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString"));
var blobClient = storageAccount.CreateCloudBlobClient();
var containerRef = blobClient.GetContainerReference(containerName);
this.containersMap[containerName]
= container
= new Container { CloudBlobContainer = containerRef };
}
var blobName = GetBlobName(fileLocation);
var blobRef = container.CloudBlobContainer.GetBlockBlobReference(blobName);
this.blobsMap[fileLocation]
= blob
= new Blob { CloudBlockBlob = blobRef, Container = container, };
}
if (container == null)
container = blob.Container;
// creating container if needed
if (createContainer && container.Exists != true)
{
if (container.CloudBlobContainer.CreateIfNotExists())
{
container.CloudBlobContainer.SetPermissions(
new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Off });
blob.Exists = false;
}
container.Exists = true;
}
// fetching blob attributes
if (fetchAttributes && blob.Exists != false && blob.AttributesFetched != true)
{
bool ok = false;
try
{
blob.CloudBlockBlob.FetchAttributes();
ok = true;
}
catch (StorageClientException e)
{
if (e.ErrorCode != StorageErrorCode.ResourceNotFound)
throw;
}
blob.Exists = ok;
blob.AttributesFetched = ok;
}
return blob;
}
public static string CreateObjectURL(Blob blob)
{
return null;
}
protected virtual string GetBlobImageFile(Blob image)
{
var imageStream = image.GetStream();
var ext = ".bmp";
switch (image.MimeType)
{
case "image/png":
ext = ".png";
break;
case "image/bmp":
ext = ".bmp";
break;
case "image/jpg":
ext = ".jpg";
break;
}
using (var tmpFile = File.OpenWrite(ReportingHost.TempService.CreateWithExtension(ext)))
{
imageStream.WriteAllTo(tmpFile);
return tmpFile.Name.Replace('\\', '/');
}
}
public CloudBlobStream OpenWriteBlock(string blobName, IDictionary<string, string> metadata)
{
if (_items.ContainsKey(blobName))
{
_items[blobName].ThrowIfLeased();
}
return new MemoryCloudBlockBlobStream((bytes) => _items[blobName] =
new Blob(StorageBlobType.BlockBlob, bytes, metadata, null, null));
}
public void ReadAsText(Blob blob, string label)
{
}
public void ReadAsText(Blob blob)
{
}
public ArrayBuffer ReadAsArrayBuffer(Blob blob)
{
return default(ArrayBuffer);
}
public string ReadAsBinaryString(Blob blob)
{
return null;
}
public static string CreateObjectURL(Blob blob, ObjectUrlOptions options)
{
return null;
}
public string ReadAsDataURL(Blob blob)
{
return null;
}
public CloudBlobStream OpenWritePage(string blobName, long? size, IDictionary<string, string> metadata)
{
if (!size.HasValue)
{
throw new NotImplementedException();
}
if (size.Value % 512 != 0)
{
throw new InvalidOperationException();
}
if (_items.ContainsKey(blobName))
{
_items[blobName].ThrowIfLeased();
}
return new MemoryCloudPageBlobStream((bytes) => _items[blobName] =
new Blob(StorageBlobType.PageBlob, bytes, metadata, null, null));
}
public string ReadAsText(Blob blob)
{
return null;
}
private void DoTest(GenericAsyncClient client, TimeStampAuthorityClient tsaClient)
{
//Create common input with info about the requestor, must match SAML
CommonInputType commonInput = new CommonInputType();
commonInput.InputReference = "TADM1234567890";
commonInput.Request = new RequestType();
commonInput.Request.IsTest = true;
commonInput.Origin = new OrigineType();
commonInput.Origin.Package = new PackageType();
commonInput.Origin.Package.Name = "eH-I Test";
commonInput.Origin.Package.License = new LicenseType();
commonInput.Origin.Package.License.Username = "******"; //provide you own license
commonInput.Origin.Package.License.Password = "******"; //provide your own password
commonInput.Origin.SiteID = "01"; //CareNet Gateway ID.
commonInput.Origin.CareProvider = new CareProviderType();
commonInput.Origin.CareProvider.Nihii = new NihiiType();
commonInput.Origin.CareProvider.Nihii.Quality = "hospital";
commonInput.Origin.CareProvider.Nihii.Value = "71022212000";
commonInput.Origin.CareProvider.Organization = new IdType();
commonInput.Origin.CareProvider.Organization.Nihii = commonInput.Origin.CareProvider.Nihii;
//create blob value
Stream raw = new MemoryStream(Encoding.ASCII.GetBytes(RandomString(1024*1024))); //you might use a file instead
MemoryStream deflated = new MemoryStream();
DeflateStream deflater = new DeflateStream(deflated, CompressionMode.Compress, true);
raw.CopyTo(deflater);
deflater.Flush();
deflater.Close();
//create blob
Blob blob = new Blob();
blob.MessageName = "ADM";
blob.Id = "_" + Guid.NewGuid().ToString();
blob.ContentType = "text/plain";
blob.Value = deflated.ToArray();
//Create Xml with the blob inside it to sign.
XmlDocument signDoc;
using(MemoryStream signDocStream = new MemoryStream()) {
XmlWriter signDocWriter = XmlWriter.Create(signDocStream);
signDocWriter.WriteStartElement("root");
XmlSerializer serializer = new XmlSerializer(typeof(Blob), new XmlRootAttribute("Detail"));
serializer.Serialize(signDocWriter, blob);
signDocWriter.WriteEndElement();
signDocWriter.Flush();
signDocStream.Seek(0, SeekOrigin.Begin);
signDoc = new XmlDocument();
signDoc.PreserveWhitespace = true;
signDoc.Load(signDocStream);
}
//create the xades-t
var xigner = new XadesCreator(sign);
xigner.TimestampProvider = new EHealthTimestampProvider(tsaClient);
xigner.DataTransforms.Add(new XmlDsigBase64Transform());
xigner.DataTransforms.Add(new OptionalDeflateTransform());
XmlElement xades = xigner.CreateXadesT(signDoc, blob.Id);
//conver the xades-t to byte array
MemoryStream xadesSteam = new MemoryStream();
using (var writer = XmlWriter.Create(xadesSteam))
{
xades.WriteTo(writer);
}
//Create the Base64 structure
base64Binary xadesParam = new base64Binary();
xadesParam.contentType = "text/xml";
xadesParam.Value = xadesSteam.ToArray();
//Send the message
Thread.Sleep(1000); //sleep to let the eID recover :(
TAck nipAck = client.post(commonInput, blob, xadesParam);
//check if the messages was correctly send
Assert.AreEqual("urn:nip:tack:result:major:success", nipAck.ResultMajor);
//Get any waiting responses
MsgQuery msgQuery = new MsgQuery();
msgQuery.Max = 1; //best to specify to avoid quota exceeds or memory issues
msgQuery.Include = true;
Query tackQuery = new Query();
tackQuery.Max = 10; //best to specify, but since they are smaller we can handle more
tackQuery.Include = true;
//Get the messages & tACK
Thread.Sleep(1000); //sleep to let the eID recover :(
Responses rsp = client.get(commonInput.Origin, msgQuery, tackQuery);
//Collect the hash values of the messages & the tack
//Should be a list of bytes arrays, but WCF isn't that smart so you need to do the encoding (base64, sperated by spaces)
StringBuilder msgHashValues = new StringBuilder();
if (rsp.MsgResponse != null)
{
foreach (MsgResponse msgRsp in rsp.MsgResponse)
{
//Parse the xades, and rework it to a doc that contains the detail & xades.
XmlDocument verifyDoc;
using (MemoryStream verifyDocStream = new MemoryStream())
{
//Create new doc with element root
XmlWriter verifyDocWriter = XmlWriter.Create(verifyDocStream);
verifyDocWriter.WriteStartElement("root", "urn:dummy");
//Add blob (detail)
XmlSerializer serializer = new XmlSerializer(typeof(Blob), "urn:be:cin:types:v1");
serializer.Serialize(verifyDocWriter, msgRsp.Detail);
//Add xades-T
XmlDocument xadesDoc = new XmlDocument();
xadesDoc.PreserveWhitespace = true;
xadesDoc.Load(new MemoryStream(msgRsp.Xadest.Value));
xadesDoc.DocumentElement.WriteTo(verifyDocWriter);
verifyDocWriter.WriteEndElement();
verifyDocWriter.Flush();
//Reload the result
verifyDocStream.Seek(0, SeekOrigin.Begin);
verifyDoc = new XmlDocument();
verifyDoc.PreserveWhitespace = true;
verifyDoc.Load(verifyDocStream);
//Validate the doc
XmlElement prop = (XmlElement) XadesTools.FindXadesProperties(verifyDoc.DocumentElement)[0];
XadesVerifier verifier = new XadesVerifier();
verifier.RevocationMode = X509RevocationMode.NoCheck; //only for testing
verifier.TrustedTsaCerts.Add(tsaTrust);
SignatureInfo info = verifier.Verify(verifyDoc, prop);
//check info (time & certificate) to your own rules.
}
if (msgHashValues.Length != 0) msgHashValues.Append(" ");
msgHashValues.Append(Convert.ToBase64String(msgRsp.Detail.HashValue));
}
}
List<String> resend = new List<string>();
StringBuilder tackContents = new StringBuilder();
if (rsp.TAckResponse != null)
{
foreach (TAckResponse tackRsp in rsp.TAckResponse)
{
//Parse the xades, and rework it to a doc that contains the detail & xades.
XmlDocument verifyDoc;
using (MemoryStream verifyDocStream = new MemoryStream())
{
//Create new doc with element root
XmlWriter verifyDocWriter = XmlWriter.Create(verifyDocStream);
verifyDocWriter.WriteStartElement("root", "urn:dummy");
//Add blob (detail)
XmlSerializer serializer = new XmlSerializer(typeof(TAck), "urn:be:cin:nip:async:generic");
serializer.Serialize(verifyDocWriter, tackRsp.TAck);
//Add xades-T
XmlDocument xadesDoc = new XmlDocument();
xadesDoc.PreserveWhitespace = true;
xadesDoc.Load(new MemoryStream(tackRsp.Xadest.Value));
xadesDoc.DocumentElement.WriteTo(verifyDocWriter);
verifyDocWriter.WriteEndElement();
verifyDocWriter.Flush();
//Reload the result
verifyDocStream.Seek(0, SeekOrigin.Begin);
verifyDoc = new XmlDocument();
verifyDoc.PreserveWhitespace = true;
verifyDoc.Load(verifyDocStream);
//Validate the doc
XmlElement prop = (XmlElement)XadesTools.FindXadesProperties(verifyDoc.DocumentElement)[0];
XadesVerifier verifier = new XadesVerifier();
verifier.RevocationMode = X509RevocationMode.NoCheck; //only for testing
verifier.TrustedTsaCerts.Add(tsaTrust);
SignatureInfo info = verifier.Verify(verifyDoc, prop);
//check info (time & certificate) to your own rules.
}
//send failed, resend later.
if ("urn:nip:tack:result:major:success" != tackRsp.TAck.ResultMajor)
{
resend.Add(tackRsp.TAck.AppliesTo);
}
if (tackContents.Length != 0) tackContents.Append(" ");
tackContents.Append(Convert.ToBase64String(tackRsp.TAck.Value)); //the content of the tAck is already a hash...
}
}
//Confirm the received messages & tack
Thread.Sleep(1000); //sleep to let the eID recover :(
client.confirm(commonInput.Origin, msgHashValues.ToString(), tackContents.ToString());
//We should not have anything to resend
Assert.AreEqual(0, resend.Count);
}
public void ReadAsArrayBuffer(Blob blob)
{
}
