Пример #1
0
        /// <summary>
        /// This method is used by both WS and Cloud implementations of AssembleDocument to convert an AssemblyResult to an AssembleDocumentResult.
        /// </summary>
        /// <param name="template">The template associated with the <c>AssemblyResult</c>.</param>
        /// <param name="asmResult">The <c>AssemblyResult</c> to convert.</param>
        /// <param name="docType">The type of document contained in the result.</param>
        /// <returns>An <c>AssembleDocumentResult</c>, which contains the same document as the <c>asmResult</c>.</returns>
        internal static AssembleDocumentResult ConvertAssemblyResult(Template template, AssemblyResult asmResult, DocumentType docType)
        {
            AssembleDocumentResult result          = null;
            MemoryStream           document        = null;
            StreamReader           ansRdr          = null;
            List <NamedStream>     supportingFiles = new List <NamedStream>();

            // Create the list of pending assemblies.
            IEnumerable <Template> pendingAssemblies =
                asmResult.PendingAssemblies == null
                                ? new List <Template>()
                                : from pa in asmResult.PendingAssemblies
                select new Template(
                    Path.GetFileName(pa.TemplateName), template.Location.Duplicate(), pa.Switches);

            for (int i = 0; i < asmResult.Documents.Length; i++)
            {
                switch (asmResult.Documents[i].Format)
                {
                case OutputFormat.Answers:
                    ansRdr = new StreamReader(new MemoryStream(asmResult.Documents[i].Data));
                    break;

                case OutputFormat.JPEG:
                case OutputFormat.PNG:
                    // If the output document is plain HTML, we might also get additional image files in the
                    // AssemblyResult that we need to pass on to the caller.
                    supportingFiles.Add(new NamedStream(asmResult.Documents[i].FileName, new MemoryStream(asmResult.Documents[i].Data)));
                    break;

                default:
                    document = new MemoryStream(asmResult.Documents[i].Data);
                    if (docType == DocumentType.Native)
                    {
                        docType = Document.GetDocumentType(asmResult.Documents[i].FileName);
                    }
                    break;
                }
            }

            if (document != null)
            {
                result = new AssembleDocumentResult(
                    new Document(template, document, docType, supportingFiles.ToArray(), asmResult.UnansweredVariables),
                    ansRdr == null ? null : ansRdr.ReadToEnd(),
                    pendingAssemblies.ToArray(),
                    asmResult.UnansweredVariables
                    );
            }

            return(result);
        }
        /// <summary>
        ///     Assemble a document from the given template, answers and settings.
        /// </summary>
        /// <param name="template">An instance of the Template class.</param>
        /// <param name="answers">
        ///     Either an XML answer string, or a string containing encoded
        ///     interview answers as posted from a HotDocs browser interview.
        /// </param>
        /// <param name="settings">An instance of the AssembleDocumentResult class.</param>
        /// <include file="../Shared/Help.xml" path="Help/string/param[@name='logRef']" />
        /// <returns>An AssemblyResult object containing all the files and data resulting from the request.</returns>
        public AssembleDocumentResult AssembleDocument(Template template, TextReader answers,
                                                       AssembleDocumentSettings settings, string logRef = "")
        {
            if (template == null)
            {
                throw new ArgumentNullException("template");
            }

            using (var client = new HttpClient())
            {
                AssembleDocumentResult adr  = null;
                var packageTemplateLocation = (PackageTemplateLocation)template.Location;
                var packageId = packageTemplateLocation.PackageID;
                var of        = ConvertFormat(settings.Format);
                var timestamp = DateTime.UtcNow;

                var hmac = HMAC.CalculateHMAC(
                    SigningKey,
                    timestamp,
                    SubscriberId,
                    packageId,
                    template.FileName,
                    false,
                    logRef,
                    of,
                    settings.Settings);

                var urlBuilder =
                    new StringBuilder().AppendFormat("{0}/assemble/{1}/{2}/{3}?" +
                                                     "format={4}&" +
                                                     "encodefilenames={5}&" +
                                                     "billingref={6}{7}",
                                                     HostAddress, SubscriberId, packageId, Uri.EscapeDataString(template.FileName),
                                                     of,
                                                     true,
                                                     Uri.EscapeDataString(logRef),
                                                     GetRetrieveFromHubParam());

                if (settings.Settings != null)
                {
                    foreach (var kv in settings.Settings)
                    {
                        urlBuilder.AppendFormat("&{0}={1}", kv.Key, kv.Value ?? "");
                    }
                }

                var request = new HttpRequestMessage
                {
                    RequestUri = new Uri(urlBuilder.ToString()),
                    Method     = HttpMethod.Post
                };

                request.Headers.Add("x-hd-date", timestamp.ToString("yyyy-MM-ddTHH:mm:ssZ"));
                request.Headers.Authorization = new AuthenticationHeaderValue("basic", hmac);

                var stringContent = answers == null
                    ? new StringContent(string.Empty)
                    : new StringContent(answers.ReadToEnd());

                request.Content = stringContent;

                request.Content.Headers.TryAddWithoutValidation("Content-Type", "text/xml");

                var result = client.SendAsync(request).Result;

                var parser = new MultipartMimeParser();

                HandleStatusCode(result);

                var streamResult = result.Content.ReadAsStreamAsync().Result;

                var streams = new List <MemoryStream>();

                using (var resultsStream = new MemoryStream())
                {
                    // Each part is written to a file whose name is specified in the content-disposition
                    // header, except for the AssemblyResult part, which has a file name of "meta0.xml",
                    // and is parsed into an AssemblyResult object.
                    parser.WritePartsToStreams(
                        streamResult,
                        h =>
                    {
                        var fileName = GetFileNameFromHeaders(h);
                        if (fileName == null)
                        {
                            return(Stream.Null);
                        }

                        if (fileName.Equals("meta0.xml", StringComparison.OrdinalIgnoreCase))
                        {
                            return(resultsStream);
                        }

                        var stream = new MemoryStream();
                        streams.Add(stream);
                        return(stream);
                    },
                        (new ContentType(result.Content.Headers.ContentType.ToString())).Boundary);

                    if (resultsStream.Position <= 0)
                    {
                        return(null);
                    }

                    resultsStream.Position = 0;
                    var serializer = new XmlSerializer(typeof(AssemblyResult));
                    var asmResult  = (AssemblyResult)serializer.Deserialize(resultsStream);

                    if (asmResult == null)
                    {
                        return(adr);
                    }

                    for (var i = 0; i < asmResult.Documents.Length; i++)
                    {
                        asmResult.Documents[i].Data = streams[i].ToArray();
                        streams[i].Dispose();
                    }

                    adr = Util.ConvertAssemblyResult(template, asmResult, settings.Format);
                }

                return(adr);
            }
        }