コード例 #1
0
        public FileContentResult Download(string id, string mode, AttachmentRequest request)
        {
            Tuple <Byte[], string> fileTuple;

            if (mode == "http")
            {
                fileTuple = _attachmentHandler.DownloadViaHttpById(id);
            }
            else if (mode == "ws")
            {
                fileTuple = _attachmentHandler.DownloadViaParentWS(id, request.ParentId, request.ParentApplication, request.ParentSchemaId);
            }
            else
            {
                throw new NotImplementedException(String.Format("{0} mode not implemented. Please use 'http' or 'ws'", mode));
            }

            if (fileTuple != null)
            {
                var result = new FileContentResult(fileTuple.Item1, System.Net.Mime.MediaTypeNames.Application.Octet)
                {
                    FileDownloadName = fileTuple.Item2
                };
                return(result);
            }
            else
            {
                return(null);
            }
        }
コード例 #2
0
        public string SaveAttachment(AttachmentRequest request)
        {
            try
            {
                DropNetClient _client = new DropNetClient(AppConstants.DropboxClientId, AppConstants.DropboxClientSecret);


                _client.UserLogin = Storage.Dropbox.Token;

                DropNet.Models.UserLogin login = _client.GetAccessToken();



                Attachment attachment = AppUtility.GetAttachment(request.AttachmentId, request.AuthToken, request.EwsUrl);

                _client.UploadFile("/", attachment.AttachmentName, attachment.AttachmentBytes);
                return("Uploaded Sucessfully.");
            }
            catch (Exception s)
            {
                return(s.Message);
            }

            //return "";
        }
コード例 #3
0
        private async Task <ICollection <Attachment> > UploadAttachments(AttachmentRequest request)
        {
            ICollection <IFormFile>  files    = request.FormFiles;
            ICollection <Attachment> response = new List <Attachment>();
            Attachment model;
            long       size        = files.Sum(f => f.Length);
            string     storagePath = _configuration["StoragePath:Key"];

            foreach (IFormFile formFile in files)
            {
                if (formFile.Length > 0)
                {
                    Guid     g                = Guid.NewGuid();
                    string   guidString       = g.ToString("N");
                    string   originalFilename = ContentDispositionHeaderValue.Parse(formFile.ContentDisposition).FileName.Trim('"');
                    string[] parts            = originalFilename.Split(".");
                    string   filename         = $"{guidString}.{parts[parts.Length - 1]}";
                    using (FileStream stream = File.Create(Path.Combine(storagePath, filename)))
                    {
                        await formFile.CopyToAsync(stream);

                        model = new Attachment
                        {
                            Comment = await _commentRepository.FindById(request.CommentId),
                            Route   = storagePath,
                            Name    = filename
                        };
                    }
                    response.Add(model);
                }
            }
            return(response);
        }
コード例 #4
0
        public byte[] GetAttachment(int id)
        {
            var executor = new ApiRequestExecutor(_baseUrl, _authToken);
            var request  = new AttachmentRequest(id);

            return(executor.Execute <byte[]>(request));
        }
コード例 #5
0
        public HttpResponseMessage UpdateAttachment(AttachmentRequest request)
        {
            try
            {
                var request1       = new AttachmentRequest();
                var httpPostedFile = System.Web.HttpContext.Current.Request.Files["file"];
                var data           = System.Web.HttpContext.Current.Request.Params["file"];
                if (httpPostedFile != null)
                {
                    request1.AttachmentFile   = ReadFully(httpPostedFile.InputStream);
                    request1.AttachmentName   = httpPostedFile.FileName;
                    request1.AttachmentLength = httpPostedFile.ContentLength;
                    request1.AttachmentType   = httpPostedFile.ContentType;
                }

                var result = _attachmentServices.SaveAttachment(request1);
                if (result != 0)
                {
                    return(Request.CreateResponse(HttpStatusCode.OK, new { results = result }));
                }
                return(Request.CreateResponse(HttpStatusCode.NotModified, false));
            }
            catch (Exception exception)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, exception.Message));
            }
        }
コード例 #6
0
        public AttachmentResponse Post([FromBody] AttachmentRequest value)
        {
            //riceve le informazioni dalla chiamata REST attraverso l'oggetto AttachmentRequest e lo passa
            //al metodo che effettua la chiamata al server Exchange
            var resp = GetAttachmentsFromExchangeServerUsingEWSManagedApi(value);

            return(resp);
        }
コード例 #7
0
        /// <summary>
        /// Adds a document to the repository
        /// </summary>
        /// <param name="attachment"></param>
        public void Add(AttachmentRequest attachment)
        {
            //valid attachment type.

            if (ValidateAttachment(attachment, "application/pdf"))
            {
                _documentRepo.Add();
            }
        }
コード例 #8
0
		public async Task<IHttpActionResult> ProcessMailAttachment(AttachmentRequest request)
		{
			if (request.ServiceType == "soap")
			{
				return Ok(await O365AttachmentHelper.GetAttachmentFromEwsAndUpload(request));
			}
			else
			{
				return Ok(await O365AttachmentHelper.GetAttachmentFromO365AndUpload(request));
			}
		}
コード例 #9
0
        public AttachmentResponse GeAttachment(AttachmentRequest request)
        {
            AttachmentResponse response   = new AttachmentResponse();
            Attachment         attachment = attachmentRepository.FindBy(Convert.ToInt16(request.AttachmentViewModel.DocumentID));

            if (attachment != null)
            {
                AttachmentViewModel attachmentViewModel = Mapper.Map <Attachment, AttachmentViewModel>(attachment);
                response.AttachmentViewModel = attachmentViewModel;
            }
            return(response);
        }
コード例 #10
0
 public string SaveAttachment(AttachmentRequest request)
 {
     try
     {
         Attachment attachment = AppUtility.GetAttachment(request.AttachmentId, request.AuthToken, request.EwsUrl);
         return(SaveAttachment(attachment));
     }
     catch (Exception e)
     {
         return("There was an exception: " + e.Message + "\n\n" + e.StackTrace);
     }
 }
コード例 #11
0
		public static async Task<UploadResponse> GetAttachmentFromO365AndUpload(AttachmentRequest request)
		{
			//Debug & StopWatch introduced just to calculate & overview performance with response time. Need remove once have stable.
			Debug.WriteLine("AttachmentUrl={0}{1}", request.ApiUrl, string.Empty);
			Debug.WriteLine("ApiToken=Bearer {0}{1}", request.Token, string.Empty);
			var uri = new Uri(request.ApiUrl);
			using (var client = new HttpClient(new HttpClientHandler { AllowAutoRedirect = false })
			{
				DefaultRequestHeaders = { Authorization = new AuthenticationHeaderValue("Bearer", request.Token) }
			})
			{
				client.DefaultRequestHeaders.Add("x-AnchorMailbox", request.UserEmail);
				var watch = Stopwatch.StartNew();
				using (var response = await client.GetStreamAsync(uri))
				{
					watch.Stop();
					Debug.WriteLine("Time taken to get attachment from o365 reset api {0}ms. AttachmentName={1} Size={2}", watch.ElapsedMilliseconds, request.Attachment.Name, request.Attachment.Size);
					watch = Stopwatch.StartNew();
					using (var streamReader = new StreamReader(response))
					{
						watch.Stop();
						Debug.WriteLine("Time taken to initialize StreamReader {0}ms. AttachmentName={1} Size={2}", watch.ElapsedMilliseconds, request.Attachment.Name, request.Attachment.Size);
						watch = Stopwatch.StartNew();
						using (var jsonTextReader = new JsonTextReader(streamReader))
						{
							watch.Stop();
							Debug.WriteLine("Time taken to initialize JsonTextReader {0}ms. AttachmentName={1} Size={2}", watch.ElapsedMilliseconds, request.Attachment.Name, request.Attachment.Size);
							watch = Stopwatch.StartNew();
							var serializer = new JsonSerializer();
							var attachmentResponse = serializer.Deserialize<AttachmentResponse>(jsonTextReader);
							watch.Stop();
							Debug.WriteLine("Time taken to Deserialize {0}ms. AttachmentName={1} Size={2}", watch.ElapsedMilliseconds, request.Attachment.Name, request.Attachment.Size);
							watch = Stopwatch.StartNew();
							var bytes = Convert.FromBase64String(attachmentResponse.ContentBytes);
							watch.Stop();
							Debug.WriteLine("Time taken to ConvertBase64 to bytes array {0}ms. AttachmentName={1} Size={2}", watch.ElapsedMilliseconds, request.Attachment.Name, request.Attachment.Size);
							watch = Stopwatch.StartNew();
							var byteArrayContent = new ByteArrayContent(bytes);
							watch.Stop();
							Debug.WriteLine("Time taken to prepare to ByteArrayContent {0}ms. AttachmentName={1} Size={2}", watch.ElapsedMilliseconds, request.Attachment.Name, request.Attachment.Size);
							watch = Stopwatch.StartNew();
							var result = await PostDocumentAsync(byteArrayContent, request.DocumentServiceUrl,
								request.DocumentServiceToken);
							watch.Stop();
							Debug.WriteLine("Time taken to post and upload on ncore server {0}ms. AttachmentName={1} Size={2}", watch.ElapsedMilliseconds, request.Attachment.Name, request.Attachment.Size);
							return result;
						}
					}
				}
			}
		}
        public string GetAttachment(AttachmentRequest request)
        {
            try
            {
                Attachment attachment = GetAttachment(request.AttachmentId, request.AuthToken, request.EwsUrl);
                System.IO.File.WriteAllBytes(@"c:\users\alexpark\desktop\temp\" + attachment.AttachmentName, attachment.AttachmentBytes);
            }
            catch (Exception e)
            {
                return("There was an exception: " + e.Message + "\n\n" + e.StackTrace);
            }

            return("Done!");
        }
コード例 #13
0
        public void GivenIHaveANon_PdfToUpload()
        {
            //Given I have a non-pdf to upload
            var attachment = new AttachmentRequest()
            {
                Data = new byte[] { 0x00, 0x21, 0x60, 0x1F, 0xA1, 0xA1 }, FileName = "Chambers.pdf", Type = "application/docx", Location = "A"
            };

            //PS: in real world we don't need the user or shouldn't trust the user to provide the mime type

            // When I send the non-pdf to the API
            _docService.Add(attachment);
            //Then the API does not accept the file and returns the appropriate messaging and status
            //Exception is thrown
        }
コード例 #14
0
        public async Task <HttpResponseMessage> SaveAttachments(string channelName, [FromBody] AttachmentRequest req)
        {
            if (req == null || !ModelState.IsValid)
            {
                return(Request.CreateResponse(HttpStatusCode.BadRequest, ModelState));
            }

            ITelegramPostSaver attachment = new TelegFtpTools(req.FtpUrl, req.FtpUser, req.FtpPassword);
            var manager = new JobAttachmentManager(_cTools, attachment);
            var job     = await manager.CreateJobAsync(channelName, req.FromId, req.ToId);

            HostingEnvironment.QueueBackgroundWorkItem(ct => manager.ExecuteJobAsync(job.Id));

            return(Request.CreateResponse(HttpStatusCode.Accepted, job));
        }
コード例 #15
0
 public HttpResponseMessage UpdateAttachment(AttachmentRequest request)
 {
     try
     {
         var result = _attachmentServices.SaveAttachment(request);
         if (result != 0)
         {
             return(Request.CreateResponse(HttpStatusCode.OK, new { results = result }));
         }
         return(Request.CreateResponse(HttpStatusCode.NotModified, false));
     }
     catch (Exception exception)
     {
         return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, exception.Message));
     }
 }
コード例 #16
0
        public async Task <ActionResult> AttachmentRequest([FromForm] AttachmentRequest model)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return(BadRequest(ModelState));
                }

                return(Ok(await _attachmentService.SaveFiles(model)));
            }
            catch (Exception ex)
            {
                return(BadRequest(ex));
            }
        }
コード例 #17
0
        public void GivenIhaveaPDFtoupload()
        {
            //Given I have a PDF to upload
            var attachment = new AttachmentRequest()
            {
                Data = new byte[] { 0x00, 0x21, 0x60, 0x1F, 0xA1, 0xA1 }, FileName = "Chambers.pdf", Type = "application/pdf"
            };

            //PS: in real world we don't need the user or shouldn't trust the user to provide the mime type

            //    When I send the PDF to the API
            _docService.Add(attachment);

            //    Then it is uploaded successfully
            //no errors. Response from Add will be void.
            Assert.AreEqual(1, 1);
        }
コード例 #18
0
        /// <summary>
        /// Validates if an attachment is of a mime type
        /// </summary>
        /// <param name="attachment"></param>
        /// <param name="applicationPdf"></param>
        private bool ValidateAttachment(AttachmentRequest attachment, string applicationPdf)
        {
            //TODO: the file type needs to be got from the byte array and not the extension as this can be faked.
            //for the test purpose, I'm using the file extension :-)
            if (attachment.Type != applicationPdf)
            {
                throw new NotSupportedException("Invalid file. Only PDF's are supported");
            }

            var MaxFileSize = 5; //move to web.config

            if (GetSizeInMB(attachment.Data) > MaxFileSize)
            {
                throw new NotSupportedException("Max file size is 5 MB");
            }

            return(true);
        }
コード例 #19
0
 public int SaveAttachment(AttachmentRequest _request)
 {
     var entity = Mapper.Map<AttachmentRequest, Attachment>(_request);
     entity.IsDeleted = false;
     entity.CreatedBy = 1;
     entity.CreatedDate = System.DateTime.Now;
     entity.Remark = "None";
     entity.ReportId = 1;
     entity.ModifiedBy = 1;
     entity.ModifiedDate = System.DateTime.Now;
     _attachmentRepository.Add(entity);
     if (_attachmentRepository.Commit())
     {
         return entity.Id;
     }
     else
     {
         return 0;
     }
 }
コード例 #20
0
        public string SaveAttachments(AttachmentRequest request)
        {
            try
            {
                // Get the attachments using the EWS Managed API
                Attachment[] attachments = GetAttachmentsWithManagedApi
                                               (request.AttachmentIds, request.AuthToken, request.EwsUrl);

                // NOTE: The GetAttachmentsWithSOAP method doesn't use the managed
                // API, and instead just builds the SOAP request manually. This is
                // here to illustrate how this can be done without the managed API.
                //Attachment[] attachments = GetAttachmentsWithSOAP(request.AttachmentIds,
                //    request.AuthToken, request.EwsUrl);

                return(SaveAttachments(attachments, request.UserEmail));
            }
            catch (Exception e)
            {
                throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.InternalServerError,
                                                                            "There was an exception: " + e.Message + "\n\n" + e.StackTrace));
            }
        }
コード例 #21
0
ファイル: ExchangeController.cs プロジェクト: undev9/ic_owa
        public IEnumerable <string> Get([FromBody] AttachmentRequest request)
        {
            ExchangeService service = new ExchangeService();

            service.Credentials = new OAuthCredentials(request.AttachmentToken);
            service.Url         = new Uri(request.EWSURL);

            List <string> attachmentIds   = request.Attachments.Select(x => x.ID).ToList();
            List <string> attachmentNames = new List <string>();

            var response = service.GetAttachments(attachmentIds.ToArray(), null, new PropertySet(BasePropertySet.FirstClassProperties, ItemSchema.MimeContent));

            if (response.OverallResult == ServiceResult.Success)
            {
                foreach (var attachmentResponse in response)
                {
                    attachmentNames.Add(attachmentResponse.Attachment.Name);

                    if (attachmentResponse.Attachment is FileAttachment)
                    {
                        FileAttachment a = attachmentResponse.Attachment as FileAttachment;
                        using (Stream ms = new MemoryStream(a.Content))
                            using (FileStream fs = new FileStream($@"C:\Users\Af\Desktop\{attachmentResponse.Attachment.Name}", FileMode.Create, FileAccess.Write))
                            {
                                byte[] bytes = new byte[ms.Length];
                                ms.Read(bytes, 0, (int)ms.Length);
                                fs.Write(bytes, 0, bytes.Length);
                            }
                    }

                    if (attachmentResponse.Attachment is ItemAttachment)
                    {
                        ItemAttachment attachment = attachmentResponse.Attachment as ItemAttachment;
                    }
                }
            }

            return(attachmentNames);
        }
コード例 #22
0
        public string SaveAttachment(AttachmentRequest request)
        {
            try
            {
                DriveRestClient restClient = new DriveRestClient(AppConstants.GoogleDriveClientId, AppConstants.DropboxClientSecret, googledriveRedirectUrl.ToString());


                restClient.Token = Storage.GoogleDrive.Token;


                AttachmentsDemoWeb.Constants.Attachment attachment = AppUtility.GetAttachment(request.AttachmentId, request.AuthToken, request.EwsUrl);

                string uploadText = restClient.UploadFile(attachment.AttachmentName, attachment.AttachmentBytes);
                return("Uploaded Sucessfully.");
            }
            catch (Exception s)
            {
                return(s.Message);
            }

            //return "";
        }
コード例 #23
0
        public async Task <Response> SaveFiles(AttachmentRequest model)
        {
            ICollection <Attachment> attachmentDTO = await UploadAttachments(model);

            int result = await _attachmentRepository.Create(attachmentDTO);

            if (result > 0)
            {
                return(new Response
                {
                    IsSuccess = true,
                    Message = Messages.Created.ToString(),
                    Result = result
                });
            }
            else
            {
                return(new Response
                {
                    IsSuccess = false,
                    Message = Messages.NotCreated.ToString()
                });
            }
        }
コード例 #24
0
 public Task <AttachmentUploadDataResponse> PostCipherAttachmentAsync(string id, AttachmentRequest request)
 {
     return(SendAsync <AttachmentRequest, AttachmentUploadDataResponse>(HttpMethod.Post,
                                                                        $"/ciphers/{id}/attachment/v2", request, true, true));
 }
コード例 #25
0
		public static async Task<UploadResponse> GetAttachmentFromEwsAndUpload(AttachmentRequest request)
		{
			var soapString = string.Format(AttachmentSoapRequest, request.Attachment.Id);
			using (var client = new HttpClient
			{
				DefaultRequestHeaders =
				{
					Authorization = new AuthenticationHeaderValue("Bearer", request.EwsToken)
				},
				Timeout = TimeSpan.FromDays(1)
			})
			{
				client.DefaultRequestHeaders.Add("x-AnchorMailbox", request.UserEmail);
				var uri = new Uri(request.EwsUrl);
				var watch = Stopwatch.StartNew();
				var contentRequest = new StringContent(soapString, Encoding.UTF8, "text/xml");
				using (var response = await client.PostAsync(uri, contentRequest))
				{
					Debug.WriteLine("Time taken to post to EWS {0}ms. AttachmentName={1} Size={2}", watch.ElapsedMilliseconds, request.Attachment.Name, request.Attachment.Size);
					watch = Stopwatch.StartNew();
					using (var stream = await response.Content.ReadAsStreamAsync())
					{
						Debug.WriteLine("Time taken to read Stream {0}ms. AttachmentName={1} Size={2}", watch.ElapsedMilliseconds, request.Attachment.Name, request.Attachment.Size);
						watch = Stopwatch.StartNew();
						ByteArrayContent contentToUpload = null;
						using (var xmlReader = XmlReader.Create(stream))
						{
							Debug.WriteLine("Time create xml reader {0}ms. AttachmentName={1} Size={2}", watch.ElapsedMilliseconds,
								request.Attachment.Name, request.Attachment.Size);
							watch = Stopwatch.StartNew();
							var contentFound = false;
							while (xmlReader.Read())
							{
								if (contentFound && xmlReader.NodeType == XmlNodeType.Text)
								{
									watch.Stop();
									Debug.WriteLine("Time taken to Reach to cotent in xml stream {0}ms. AttachmentName={1} Size={2}",
										watch.ElapsedMilliseconds, request.Attachment.Name, request.Attachment.Size);
									watch = Stopwatch.StartNew();
									var bytes = Convert.FromBase64String(xmlReader.Value);
									watch.Stop();
									Debug.WriteLine("Time taken to ConvertBase64 to bytes array {0}ms. AttachmentName={1} Size={2}",
										watch.ElapsedMilliseconds, request.Attachment.Name, request.Attachment.Size);
									watch = Stopwatch.StartNew();
									contentToUpload = new ByteArrayContent(bytes);
									watch.Stop();
									Debug.WriteLine("Time taken to prepare to ByteArrayContent {0}ms. AttachmentName={1} Size={2}",
										watch.ElapsedMilliseconds, request.Attachment.Name, request.Attachment.Size);
									break;
								}
								if (!xmlReader.Name.Equals("t:Content")) continue;
								contentFound = true;
							}

							watch = Stopwatch.StartNew();
							var result = await PostDocumentAsync(contentToUpload, request.DocumentServiceUrl,
								request.DocumentServiceToken);
							watch.Stop();
							Debug.WriteLine("Time taken to post and upload on ncore server {0}ms. AttachmentName={1} Size={2}", watch.ElapsedMilliseconds, request.Attachment.Name, request.Attachment.Size);
							return result;
						}
					}
				}
			}
		}
コード例 #26
0
        private AttachmentResponse GetAttachmentsFromExchangeServerUsingEWSManagedApi(AttachmentRequest request)
        {
            var attachmentsProcessedCount = 0;
            var attachmentNames           = new List <string>();

            // Creo un oggetto di tipo ExchangeService
            ExchangeService service = new ExchangeService();

            //imposto il token di autenticazione ricevuto dall'add-in
            service.Credentials = new OAuthCredentials(request.attachmentToken);
            //imposto la url del server Exchange
            service.Url = new Uri(request.ewsUrl);

            // Richiede gli allegati al server
            var getAttachmentsResponse = service.GetAttachments(
                request.attachments.Select(a => a.id).ToArray(),
                null,
                new PropertySet(BasePropertySet.FirstClassProperties,
                                ItemSchema.MimeContent));

            if (getAttachmentsResponse.OverallResult == ServiceResult.Success)
            {
                foreach (var attachmentResponse in getAttachmentsResponse)
                {
                    attachmentNames.Add(attachmentResponse.Attachment.Name);

                    if (attachmentResponse.Attachment is FileAttachment)
                    {
                        //mette il contenuto dell'allegato in uno stream
                        FileAttachment fileAttachment = attachmentResponse.Attachment as FileAttachment;
                        Stream         s = new MemoryStream(fileAttachment.Content);

                        // Qui è possibile processare il contenuto dell'allegato
                    }

                    if (attachmentResponse.Attachment is ItemAttachment)
                    {
                        //mette il contenuto dell'allegato in uno stream
                        ItemAttachment itemAttachment = attachmentResponse.Attachment as ItemAttachment;
                        Stream         s = new MemoryStream(itemAttachment.Item.MimeContent.Content);

                        // Qui è possibile processare il contenuto dell'allegato
                    }

                    attachmentsProcessedCount++;
                }
            }

            // La risposta contiene il nome ed il numero degli allegati che sono stati
            // processati dal servizio
            var response = new AttachmentResponse();

            response.attachmentNames      = attachmentNames.ToArray();
            response.attachmentsProcessed = attachmentsProcessedCount;

            return(response);
        }
コード例 #27
0
        private void Send(long contractId, List <long> documentIds)
        {
            //设置接收人,名称、联系方式必填
            List <Receiver> receivers = new List <Receiver>();

            List <StandardStamper> platestampers = new List <StandardStamper>();
            //指定本方签署位置
            StandardStamper sealStamper = new StandardStamper();

            sealStamper.documentId = documentIds[0];
            sealStamper.page       = 1;
            sealStamper.offsetX    = 0.5;
            sealStamper.offsetY    = 0.5;
            sealStamper.type       = StandardSignType.SEAL;

            StandardStamper stStamper = new StandardStamper();

            stStamper.documentId = documentIds[0];
            stStamper.page       = 1;
            stStamper.offsetX    = 0.5;
            stStamper.offsetY    = 0.45;
            stStamper.type       = StandardSignType.SEAL_TIMESTAMP;

            // StandardStamper lpStamper = new StandardStamper();
            // lpStamper.documentId = documentIds[1];
            // lpStamper.page = 1;
            // lpStamper.offsetX = 0.6;
            // lpStamper.offsetY = 0.2;
            // lpStamper.type = StandardSignType.LEGAL_PERSON;

            platestampers.Add(sealStamper);
            platestampers.Add(stStamper);
            //platestampers.Add(lpStamper);

            //需要本方签署,则将本方加入接收者列表
            Receiver platform = new Receiver();

            platform.type                = AccountType.PLATFORM;
            platform.ordinal             = 0;
            platform.stampers            = platestampers; //指定签署位置
            platform.legalPersonRequired = false;         //指定法人签署
            receivers.Add(platform);

            StandardStamper pStamper = new StandardStamper();

            pStamper.documentId = documentIds[0];
            pStamper.page       = 1;
            pStamper.offsetX    = 0.64;
            pStamper.offsetY    = 0.105;
            pStamper.type       = StandardSignType.PERSONAL;

            StandardStamper ptStamper = new StandardStamper();

            ptStamper.documentId = documentIds[0];
            ptStamper.page       = 1;
            ptStamper.offsetX    = 0.655;
            ptStamper.offsetY    = 0.058;
            ptStamper.type       = StandardSignType.PERSONAL_TIMESTAMP;

            StandardStamper pStamper_d = new StandardStamper();

            pStamper_d.documentId = documentIds[0];
            pStamper_d.page       = 1;
            pStamper_d.offsetX    = 0.658;
            pStamper_d.offsetY    = 0.09;
            pStamper_d.type       = StandardSignType.PERSONAL;

            StandardStamper ptStamper_d = new StandardStamper();

            ptStamper_d.documentId = documentIds[0];
            ptStamper_d.page       = 1;
            ptStamper_d.keyword    = null;
            ptStamper_d.offsetX    = 0.662;
            ptStamper_d.offsetY    = 0.05;
            ptStamper_d.type       = StandardSignType.PERSONAL_TIMESTAMP;

            List <StandardStamper> personalStampers = new List <StandardStamper>();

            personalStampers.Add(pStamper);
            personalStampers.Add(ptStamper);
            personalStampers.Add(pStamper_d);
            personalStampers.Add(ptStamper_d);

            Receiver receiver = new Receiver();

            receiver.name      = "张忱昊";
            receiver.mobile    = "17621699044";
            receiver.type      = AccountType.PERSONAL;
            receiver.authLevel = AuthenticationLevel.BASIC;
            receiver.ordinal   = 1;
            receiver.stampers  = personalStampers;//个人签署位置

            List <AttachmentRequest> attachments = new List <AttachmentRequest>();

            AttachmentRequest attachmentRequest1 = new AttachmentRequest();

            attachmentRequest1.title    = "附件名称";
            attachmentRequest1.required = true;
            attachmentRequest1.needSign = false;
            attachments.Add(attachmentRequest1);

            receiver.attachments = attachments;

            receivers.Add(receiver);

            List <DocumentParam> documentParams = new List <DocumentParam>();

            DocumentParam documentParam1 = new DocumentParam();

            documentParam1.documentId = documentIds[0];
            documentParam1.name       = "参数名称";
            documentParam1.value      = "参数默认值";
            documentParam1.receiverNo = 1;
            documentParams.Add(documentParam1);


            SendRequest request = new SendRequest();

            request.contractId = contractId; //指定发起的合同ID
            request.categoryId = null;       //不指定业务分类

            request.receivers      = receivers;
            request.documentParams = documentParams;
            request.receiveType    = ReceiveType.SEQ;//设置签署人顺序签署
            try
            {
                signService.Send(request);
                Console.WriteLine("合同成功发起!");
            }
            catch (Exception e)
            {
                throw e;
            }
        }
コード例 #28
0
 public AttachmentResponse DeleteAttachment(AttachmentRequest request)
 {
     attachmentRepository.DeleteAttachment(request.AttachmentViewModel.DocumentID);
     return(new AttachmentResponse());
 }
コード例 #29
0
        public TicketSaveResponse Save([FromBody] Ticket ticket)
        {
            if (ticket.Attachments != null && ticket.Attachments.Count != 0)
            {
                if (string.IsNullOrEmpty(ticket.AttachmentToken))
                {
                    return(new TicketSaveResponse
                    {
                        Status = "failed",
                        Message = "Attachment token missing",
                        Ticket = ticket
                    });
                }

                if (string.IsNullOrEmpty(ticket.EWSURL))
                {
                    return(new TicketSaveResponse
                    {
                        Status = "failed",
                        Message = "EWS Url missing",
                        Ticket = ticket
                    });
                }

                if (string.IsNullOrEmpty(ticket.EmailId))
                {
                    return(new TicketSaveResponse
                    {
                        Status = "failed",
                        Message = "EmailId missing",
                        Ticket = ticket
                    });
                }

                if (string.IsNullOrEmpty(ticket.ConversationId))
                {
                    return(new TicketSaveResponse
                    {
                        Status = "failed",
                        Message = "ConversationId missing",
                        Ticket = ticket
                    });
                }
            }

            //get attachments
            var selectedAttachments = ticket.Attachments.Where(x => x.Selected);

            if (selectedAttachments.Count() != 0)
            {
                AttachmentRequest attachmentRequest = new AttachmentRequest
                {
                    Attachments     = selectedAttachments.ToArray(),
                    AttachmentToken = ticket.AttachmentToken,
                    EWSURL          = ticket.EWSURL
                };
                ExchangeAttachmentService.GetAttachments(attachmentRequest);
            }

            //save ticket
            ticket.TicketId = 9999;

            return(new TicketSaveResponse
            {
                Status = "success",
                Ticket = ticket
            });
        }