示例#1
0
        public static DocuSignEnvironment buildEnvironment(DocuSignEnvelopeInformation envelopeInfo)
        {
            DocuSignEnvironment     env           = new DocuSignEnvironment();
            Predicate <CustomField> accountFinder = (CustomField p) => { return(p.Name == "AccountId"); };

            env.AccountId = envelopeInfo.EnvelopeStatus.CustomFields.CustomField.Find(accountFinder).Value;
            Predicate <CustomField> AccountSiteFinder = (CustomField p) => { return(p.Name == "AccountSite"); };

            env.Environment = envelopeInfo.EnvelopeStatus.CustomFields.CustomField.Find(AccountSiteFinder).Value;
            return(env);
        }
示例#2
0
        protected void Page_Load(object sender, EventArgs e)
        {
            if (!EventLog.SourceExists("HCC"))
            {
                EventLog.CreateEventSource("HCC", "Application");
            }

            EventLog.WriteEntry("HCC", "In PageLoad");
            if (Request.ContentType.ToLower().Contains("xml") == false)
            {
                // Look for xml files
                string        filepath = Server.MapPath("/") + "\\";
                DirectoryInfo xmldir   = new DirectoryInfo(filepath);
                FileInfo[]    xmlfiles = xmldir.GetFiles("*.xml");
                if (xmlfiles.Length == 0)
                {
                    this.statusLabel.Text = "No envelopes have been posted";
                    EventLog.WriteEntry("HCC", "No XML Posted");
                }
                else
                {
                    this.statusLabel.Text = "You have received " + xmlfiles.Length + " envelopes";
                    EventLog.WriteEntry("HCC", "Envelopes to list");
                }
            }
            else
            {
                this.statusLabel.Text = "XML Posted. Started Parsing";
                EventLog.WriteEntry("HCC", "XML Posted. Started Parsing");

                StreamReader sr       = new StreamReader(Request.InputStream);
                string       xml      = sr.ReadToEnd();
                string       fileName = Server.MapPath("/") + "\\" + DateTime.Now.Ticks + ".xml";
                EventLog.WriteEntry("HCC", "Writing to " + fileName);
                File.WriteAllText(fileName, xml);

                XmlReader     reader     = new XmlTextReader(new StringReader(xml));
                XmlSerializer serializer = new XmlSerializer(typeof(DocuSignEnvelopeInformation), "http://www.docusign.net/API/3.0");
                DocuSignEnvelopeInformation envelopeInfo = serializer.Deserialize(reader) as DocuSignEnvelopeInformation;


                foreach (DocumentPDF document in envelopeInfo.DocumentPDFs)
                {
                    string filePath = Server.MapPath("/") + "\\" + envelopeInfo.EnvelopeStatus.EnvelopeID + "-" + document.Name + ".pdf";
                    EventLog.WriteEntry("HCC", "writing file " + filePath);

                    File.WriteAllBytes(filePath, document.PDFBytes);
                }

                EventLog.WriteEntry("HCC", "Done!");
                this.statusLabel.Text = "All is well. Wrote " + envelopeInfo.DocumentPDFs.Length + " documents";
            }
        }
        public static string GetEventNames(DocuSignEnvelopeInformation curDocuSignEnvelopeInfo)
        {
            List <string> result = new List <string>();

            //Envelope events
            if (curDocuSignEnvelopeInfo.EnvelopeStatus != null)
            {
                result.Add("Envelope" + curDocuSignEnvelopeInfo.EnvelopeStatus.Status);
            }

            //Recipinent events
            if (curDocuSignEnvelopeInfo.EnvelopeStatus != null &&
                curDocuSignEnvelopeInfo.EnvelopeStatus.RecipientStatuses != null)
            {
                var recipientEvents = curDocuSignEnvelopeInfo.EnvelopeStatus.RecipientStatuses.Select(s => "Recipient" + Enum.GetName(typeof(RecipientStatusCode), s.Status)).Distinct();
                result.AddRange(recipientEvents);
            }
            return(string.Join(",", result));
        }
示例#4
0
        public static Dictionary <string, string> getDocumentProperties(DocuSignEnvelopeInformation envelopeInfo)
        {
            Dictionary <string, string> ecf = new Dictionary <string, string>();

            Predicate <DocumentStatus> docfinder    = (DocumentStatus p) => { return(p.ID == "1"); };
            DocumentStatus             templateName = envelopeInfo.EnvelopeStatus.DocumentStatuses.DocumentStatus.Find(docfinder);
            string docClassNType = templateName == null ? null : templateName.TemplateName;

            ecf.Add(EnvelopeMetaFields.TemplateName, docClassNType);

            Predicate <CustomField> finder      = (CustomField p) => { return(p.Name == EnvelopeMetaFields.AccountId); };
            CustomField             customField = envelopeInfo.EnvelopeStatus.CustomFields.CustomField.Find(finder);
            string accountId = customField == null ? null : customField.Value;

            ecf.Add(EnvelopeMetaFields.AccountId, accountId);

            finder      = (CustomField p) => { return(p.Name == EnvelopeMetaFields.Environment); };
            customField = envelopeInfo.EnvelopeStatus.CustomFields.CustomField.Find(finder);
            string environment = customField == null ? null : customField.Value;

            ecf.Add(EnvelopeMetaFields.Environment, environment);

            finder      = (CustomField p) => { return(p.Name == EnvelopeMetaFields.EID); };
            customField = envelopeInfo.EnvelopeStatus.CustomFields.CustomField.Find(finder);
            string employeeId = customField == null ? null : customField.Value;

            ecf.Add(EnvelopeMetaFields.EID, employeeId);

            finder      = (CustomField p) => { return(p.Name == EnvelopeMetaFields.FirstName); };
            customField = envelopeInfo.EnvelopeStatus.CustomFields.CustomField.Find(finder);
            string firstName = customField == null ? null : customField.Value;

            ecf.Add(EnvelopeMetaFields.FirstName, firstName);

            finder      = (CustomField p) => { return(p.Name == EnvelopeMetaFields.LastName); };
            customField = envelopeInfo.EnvelopeStatus.CustomFields.CustomField.Find(finder);
            string lastName = customField == null ? null : customField.Value;

            ecf.Add(EnvelopeMetaFields.LastName, lastName);

            return(ecf);
        }
示例#5
0
        // POST api/connect
        //[ResponseType(typeof{string})]
        public HttpResponseMessage Post([FromBody] DocuSignEnvelopeInformation dsEnvInfo)
        {
            var dsEnv = ServiceUtil.buildEnvironment(dsEnvInfo);

            Log.Info("Processing envelopeId " + dsEnvInfo.EnvelopeStatus.EnvelopeID);
            Log.Info("Creating HangFire backgoundJob ");
            IDictionary <string, string> localECF = DocumentumServiceUtils.getDocumentProperties(dsEnvInfo);
            var jobId = Hangfire.BackgroundJob.Enqueue(() => DocumentumUploadTask.uploadDocument(localECF,
                                                                                                 dsEnvInfo.EnvelopeStatus.EnvelopeID,
                                                                                                 "combined",
                                                                                                 DocumentOptions.Combined_No_Cert));

            Log.Info("Hangfire JobId created: " + jobId);

            ConnectProcessResponse response = new ConnectProcessResponse(dsEnvInfo.EnvelopeStatus.EnvelopeID, jobId);

            Log.Info("Reply HTTP 200 to DocuSign JobId created: " + jobId);

            return(this.Request.CreateResponse <string>(HttpStatusCode.OK, dsEnvInfo.EnvelopeStatus.EnvelopeID + " : " + jobId));
        }
        public static DocuSignEnvelopeCM_v2 ParseXMLintoCM(DocuSignEnvelopeInformation curDocuSignEnvelopeInfo)
        {
            var result = new DocuSignEnvelopeCM_v2();

            result.EnvelopeId            = curDocuSignEnvelopeInfo.EnvelopeStatus.EnvelopeID;
            result.Status                = Enum.GetName(typeof(EnvelopeStatusCode), curDocuSignEnvelopeInfo.EnvelopeStatus.Status);
            result.StatusChangedDateTime = DateTime.UtcNow;
            result.Subject               = curDocuSignEnvelopeInfo.EnvelopeStatus.Subject;
            result.ExternalAccountId     = curDocuSignEnvelopeInfo.EnvelopeStatus.Email;
            result.SentDate              = curDocuSignEnvelopeInfo.EnvelopeStatus.Sent;
            result.CreateDate            = curDocuSignEnvelopeInfo.EnvelopeStatus.Created;
            //Recipients
            foreach (var recipient in curDocuSignEnvelopeInfo.EnvelopeStatus.RecipientStatuses)
            {
                var docusignRecipient = new DocuSignRecipientStatus()
                {
                    Type           = Enum.GetName(typeof(RecipientTypeCode), recipient.Type),
                    Email          = recipient.Email,
                    Name           = recipient.UserName,
                    RecipientId    = recipient.RecipientId,
                    RoutingOrderId = recipient.RoutingOrder.ToString(),
                    Status         = Enum.GetName(typeof(RecipientStatusCode), recipient.Status)
                };

                //Tabs
                if (recipient.TabStatuses != null)
                {
                    foreach (var dstab in recipient.TabStatuses.Where(a => a.CustomTabType != CustomTabType.Radio && a.CustomTabType != CustomTabType.List))
                    {
                        DocuSignTabStatus tab = ParseTab(dstab);
                        docusignRecipient.Tabs.Add(tab);
                    }

                    ParseTabsWithItems(recipient, docusignRecipient);
                }

                result.Recipients.Add(docusignRecipient);
            }

            foreach (var dstemplate in curDocuSignEnvelopeInfo.EnvelopeStatus.DocumentStatuses)
            {
                var template = new DocuSignTemplate();
                template.DocumentId = dstemplate.ID;
                //sadly Connect gives us only a template name
                template.TemplateId = "";
                template.Name       = dstemplate.TemplateName;
                result.Templates.Add(template);
            }

            // Connect doesn't provide CourentRoutingOrder. let's assume that it's a highest routingOrderId from recipients who completed/signed
            var completedRecipients = curDocuSignEnvelopeInfo.EnvelopeStatus.RecipientStatuses.Where(a => a.Status == RecipientStatusCode.Completed || a.Status == RecipientStatusCode.Signed);

            if (completedRecipients.Count() > 0)
            {
                result.CurrentRoutingOrderId = completedRecipients.OrderByDescending(a => a.RoutingOrder).First().RoutingOrder.ToString();
            }
            else
            {
                result.CurrentRoutingOrderId = curDocuSignEnvelopeInfo.EnvelopeStatus.RecipientStatuses.First().RoutingOrder.ToString();
            }

            return(result);
        }
示例#7
0
        public static Dictionary <string, string> getDocumentProperties(DocuSignEnvelopeInformation envelopeInfo)
        {
            //L
            Dictionary <string, string> ecf    = new Dictionary <string, string>();
            Predicate <CustomField>     finder = (CustomField p) => { return(p.Name == EnvelopeMetaFields.AccountId); };
            CustomField customField            = envelopeInfo.EnvelopeStatus.CustomFields.CustomField.Find(finder);
            string      accountId = customField == null ? null : customField.Value;

            ecf.Add(EnvelopeMetaFields.AccountId, accountId);

            finder      = (CustomField p) => { return(p.Name == EnvelopeMetaFields.Environment); };
            customField = envelopeInfo.EnvelopeStatus.CustomFields.CustomField.Find(finder);
            string environment = customField == null ? null : customField.Value;

            ecf.Add(EnvelopeMetaFields.Environment, environment);

            finder      = (CustomField p) => { return(p.Name == EnvelopeMetaFields.BusinessRecord); };
            customField = envelopeInfo.EnvelopeStatus.CustomFields.CustomField.Find(finder);
            string businessRecord = customField == null ? null : customField.Value;

            ecf.Add(EnvelopeMetaFields.BusinessRecord, businessRecord);

            finder      = (CustomField p) => { return(p.Name == EnvelopeMetaFields.DocumentType); };
            customField = envelopeInfo.EnvelopeStatus.CustomFields.CustomField.Find(finder);
            string documentType = customField == null ? null : customField.Value;

            ecf.Add(EnvelopeMetaFields.DocumentType, documentType);

            finder      = (CustomField p) => { return(p.Name == EnvelopeMetaFields.FolderId); };
            customField = envelopeInfo.EnvelopeStatus.CustomFields.CustomField.Find(finder);
            string folderId = customField == null ? null : customField.Value;

            ecf.Add(EnvelopeMetaFields.FolderId, folderId);

            finder      = (CustomField p) => { return(p.Name == EnvelopeMetaFields.FormDescription); };
            customField = envelopeInfo.EnvelopeStatus.CustomFields.CustomField.Find(finder);
            string formDescription = customField == null ? null : customField.Value;

            ecf.Add(EnvelopeMetaFields.FormDescription, formDescription);

            finder      = (CustomField p) => { return(p.Name == EnvelopeMetaFields.FormID); };
            customField = envelopeInfo.EnvelopeStatus.CustomFields.CustomField.Find(finder);
            string formId = customField == null ? null : customField.Value;

            ecf.Add(EnvelopeMetaFields.FormID, formId);

            finder      = (CustomField p) => { return(p.Name == EnvelopeMetaFields.PolicyNumber); };
            customField = envelopeInfo.EnvelopeStatus.CustomFields.CustomField.Find(finder);
            string policyNumber = customField == null ? null : customField.Value;

            ecf.Add(EnvelopeMetaFields.PolicyNumber, policyNumber);

            finder      = (CustomField p) => { return(p.Name == EnvelopeMetaFields.Repository); };
            customField = envelopeInfo.EnvelopeStatus.CustomFields.CustomField.Find(finder);
            string repository = customField == null ? null : customField.Value;

            ecf.Add(EnvelopeMetaFields.Repository, repository);

            ecf.Add(EnvelopeMetaFields.Subject, envelopeInfo.EnvelopeStatus.EnvelopeID);
            //Author-Creator will have the name of each signers concatenated
            envelopeInfo.EnvelopeStatus.RecipientStatuses.RecipientStatus.ForEach((recipient) => {
                if (ecf.ContainsKey(EnvelopeMetaFields.AuthorCreator))
                {
                    ecf[EnvelopeMetaFields.AuthorCreator] = ecf[EnvelopeMetaFields.AuthorCreator] + "," + recipient.UserName;
                }
                else
                {
                    ecf[EnvelopeMetaFields.AuthorCreator] = recipient.UserName;
                }
            });
            //truncate the author to 255 characters
            ecf[EnvelopeMetaFields.AuthorCreator] = StringExt.Truncate(ecf[EnvelopeMetaFields.AuthorCreator], 255);
            //Author-date should contain the signed date for this envelope
            ecf.Add(EnvelopeMetaFields.AuthoredDate, envelopeInfo.EnvelopeStatus.Completed);
            return(ecf);
        }
示例#8
0
        // POST api/connect
        //[ResponseType(typeof{string})]
        public HttpResponseMessage Post([FromBody] DocuSignEnvelopeInformation dsEnvInfo)
        {
            var dsEnv = ServiceUtil.buildEnvironment(dsEnvInfo);

            Log.Info("Processing envelopeId " + dsEnvInfo.EnvelopeStatus.EnvelopeID);
            // Log.Info("Creating HangFire backgoundJob ");

            //check for valid template
            IDictionary <string, string> localECF    = CMServiceUtils.getDocumentProperties(dsEnvInfo);
            IDictionary <string, string> localParams = localECF;

            string[] classList     = ConfigurationManager.AppSettings["cmValidClassList"].Split('|');
            string[] docParams     = localParams[EnvelopeMetaFields.TemplateName].Split(':');
            string   documentClass = null;
            string   documentType  = null;

            if (docParams.Length > 1)
            {
                documentClass = docParams[0];
                documentType  = docParams[1];
                Log.Info("Doc Class : " + documentClass);
                Log.Info("Doc Type : " + documentType);

                if (!String.IsNullOrEmpty(documentClass) && !String.IsNullOrEmpty(documentType))
                {
                    bool jobCreated = false;
                    var  jobId      = "";

                    foreach (string item in classList)
                    {
                        if (item.Equals(documentClass))
                        {
                            jobId = Hangfire.BackgroundJob.Enqueue(() => ContentManagerUploadTask.uploadDocument(localECF,
                                                                                                                 dsEnvInfo.EnvelopeStatus.EnvelopeID,
                                                                                                                 "combined",
                                                                                                                 DocumentOptions.Combined_No_Cert, documentClass, documentType));

                            Log.Info("Hangfire Job created. Job ID : " + jobId);

                            ConnectProcessResponse response = new ConnectProcessResponse(dsEnvInfo.EnvelopeStatus.EnvelopeID, jobId);
                            Log.Info("Reply HTTP 200 to DocuSign JobId created: " + jobId);
                            jobCreated = true;
                            //save
                            break;
                        }
                    }
                    //    Log.Info("An Invalid Template was sent and ignored by the Connect Application. Document Class : " + documentClass);

                    if (jobCreated)
                    {
                        return(this.Request.CreateResponse <string>(HttpStatusCode.OK, dsEnvInfo.EnvelopeStatus.EnvelopeID + " : " + jobId));
                    }
                    else
                    {
                        return(this.Request.CreateResponse <string>(HttpStatusCode.OK, "INFO :: A Template with an Invalid Document Class was sent and ignored by the Connect Application. Document Class : " + documentClass));
                    }
                }
                else
                {
                    return(this.Request.CreateResponse <string>(HttpStatusCode.OK, "INFO :: An Invalid Template was sent and ignored by the Connect Application. Document Class Or Document Type or both was not found"));
                }
            }
            else
            {
                return(this.Request.CreateResponse <string>(HttpStatusCode.OK, "INFO :: An Invalid Template was sent and ignored by the Connect Application."));
            }
        }