public ActionResult Edit(AttachmentDto input, HttpPostedFileBase newFile, int courseId) { var fileName = input.AttachmentFileName; if (newFile != null && newFile.ContentLength > 0) { fileName = $"{input.Title.Replace(" ", string.Empty)}_{input.EmployeeId}_{DateTime.Now.ToString("ddMMyyyyhhmmsstt")}.{newFile.FileName.Split('.')[1].Trim()}"; string root = @"C:\Attachments"; if (!Directory.Exists(root)) { Directory.CreateDirectory(root); } root = root + "\\" + fileName; newFile.SaveAs(root); } input.AttachmentFileName = fileName; var updatedSubject = _repository.Edit(input.Id, input); return(RedirectToAction("Index", "Attachments", new { employeeId = input.EmployeeId, courseId = courseId })); }
/// <summary> /// Saves the attachment to disk and updates the location <paramref name="dto"/> /// </summary> private async Task SaveAttachment(IFormFile file, long tenantId, AttachmentDto dto) { string extension = Path.GetExtension(file.FileName); string actualStorePath = $"{_assetSettings.AssetStorePath}/{tenantId}"; string assetName; string assetStorePath; do { assetName = $"{Guid.NewGuid()}{extension}"; assetStorePath = $"{actualStorePath}/{assetName}"; }while (System.IO.File.Exists(assetStorePath)); // there's a chance that the same Guid was generated before if (!Directory.Exists(actualStorePath)) { Directory.CreateDirectory(actualStorePath); } if (file.Length > 0) { using (var stream = new FileStream(assetStorePath, FileMode.Create)) await file.CopyToAsync(stream); } dto.Location = assetStorePath; }
public AttachmentDto Insert(AttachmentInsertDto dto) { AttachmentDto attachmentDto = null; try { var attachment = Mapper.Map <AttachmentInsertDto, Attachment>(dto); attachment.CreatedBy = _appSession.GetUserName(); attachment.IsEnabled = true; _unitOfWork.CreateTransaction(); _unitOfWork.GenericRepository <Attachment>().Insert(attachment); _unitOfWork.Save(); _unitOfWork.Commit(); attachmentDto = Mapper.Map <Attachment, AttachmentDto>(attachment); } catch (Exception ex) { Tracing.SaveException(ex); _unitOfWork.Rollback(); } return(attachmentDto); }
public async Task RemoveAttachmentAsync(AttachmentDto attachmentDto) { var attachment = _mapper.Map <Attachment>(attachmentDto); await _uploadService.DeleteAttachment(attachment); await _transactionManager.SaveAllAsync(); }
public async Task <ResultListDto> GetAllAttachmentsAsync(AttachmentFilterDto attachmentDto) { var attachmentFilter = _mapper.Map <AttachmentFilter>(attachmentDto); var fileList = await _uploadService.GetFilesAsync(attachmentFilter); List <Attachment> attachments = (List <Attachment>)fileList.Results; List <AttachmentDto> attachmentDtos = new List <AttachmentDto>(); attachments?.ForEach(x => { AttachmentDto dto = new AttachmentDto(); dto = _mapper.Map <AttachmentDto>(x); dto.AttachmentType = _mapper.Map <KeyValueDto>(x.AttachmentType); attachmentDtos.Add(dto); }); ResultListDto finalResult = new ResultListDto() { MaxPageRows = fileList.MaxPageRows, TotalRows = fileList.TotalRows, Results = attachmentDtos, }; return(finalResult); }
private static Attachment GetAttachment(AttachmentDto attachment, long messageId) => new Attachment { Hash = attachment.Hash, Payload = attachment.Payload, Type = (short)attachment.Type, MessageId = messageId };
public static AttachmentDto GetAttachment(AttachmentVm attachment) { if (attachment.Payload == null) { return(null); } object payload = attachment.Payload; AttachmentDto attachmentDto = new AttachmentDto { Type = attachment.Type, Hash = attachment.Hash ?? Array.Empty <byte>() }; if (payload is string strPayload) { attachmentDto.Payload = strPayload; } else if (payload is PollVm pollPayload) { attachmentDto.Payload = ObjectSerializer.ObjectToJson(new PollAttachmentInformation { ConversationId = pollPayload.ConversationId.GetValueOrDefault(), ConversationType = pollPayload.ConversationType.GetValueOrDefault(), PollId = pollPayload.PollId.GetValueOrDefault() }); } else { attachmentDto.Payload = ObjectSerializer.ObjectToJson(attachment.Payload); } return(attachmentDto); }
private static void AddToAttachments(ICollection <AttachmentDto> result, AttachmentDto insertingAttachment) { if (insertingAttachment.Fields.Count != 0) { result.Add(insertingAttachment); } }
public async Task <ResultListDto> GetAllFilesAsync(ICollection <IFormFile> filess) { string dtoName = Request.Form["attachmentTypeCategoryID"]; string attachmentDto = Request.Form["attachmentDto"]; string filterDto = Request.Form["filterDto"]; AttachmentFilterDto filter = Newtonsoft.Json.JsonConvert.DeserializeObject <AttachmentFilterDto>(filterDto); AttachmentDto attDto = Newtonsoft.Json.JsonConvert.DeserializeObject <AttachmentDto>(attachmentDto); if (dtoName == ConstAttachmentTypeCategory.Customer.ToString()) { var entity = Newtonsoft.Json.JsonConvert.DeserializeObject <CustomerHeadDto>(attDto.entity.ToString()); filter.CustomerID = entity.ID; } if (dtoName == ConstAttachmentTypeCategory.User.ToString()) { var entity = Newtonsoft.Json.JsonConvert.DeserializeObject <UserDto>(attDto.entity.ToString()); filter.UserID = entity.ID; } if (dtoName == ConstAttachmentTypeCategory.Session.ToString()) { var entity = Newtonsoft.Json.JsonConvert.DeserializeObject <SessionDto>(attDto.entity.ToString()); filter.SessionID = entity.ID; } var result = await _uploadAppService.GetAllAttachmentsAsync(filter); return(result); }
public async Task <ResultObject> UploadUserImage([FromForm] ICollection <IFormFile> filess) { var resultobject = new ResultObject(); var files = Request.Form.Files; string attachmentDto = Request.Form["attachmentDto"]; AttachmentDto attDto = Newtonsoft.Json.JsonConvert.DeserializeObject <AttachmentDto>(attachmentDto); if (files.Any(f => f.Length == 0)) { return(new ResultObject { Result = attDto, ServerErrors = null /*new List<ServerErr>().Add(new ServerErr() { Hint = "هیچ فایلی فرستاده نشده است" })*/ }); } attDto.Path = await _uploadAppService.CreateDirectoryAndFile(attDto.UserID.Value, "UserDto", files[0]); await _uploadAppService.RemoveAllPersonImages(attDto.UserID.Value); attDto.AttachmentTypeID = ConstAttachmentTypes.PersonImage; await _uploadAppService.CreateAttachmentAsync(attDto); resultobject.Result = attDto; resultobject.ServerErrors = null; return(resultobject); }
/// <summary> /// 转换为附件实体 /// </summary> /// <param name="dto">附件数据传输对象</param> public static Attachment ToEntity3(this AttachmentDto dto) { if (dto == null) { return(new Attachment()); } return(AttachmentFactory.Create( attachmentId: dto.Id.ToGuid(), fileName: dto.FileName, fileType: dto.FileType, size: dto.Size, remoteUrl: dto.RemoteUrl, localUrl: dto.LocalUrl, width: dto.Width, height: dto.Height, merchantId: dto.MerchantId, module: dto.Module, creationTime: dto.CreationTime, creatorId: dto.CreatorId, lastModificationTime: dto.LastModificationTime, lastModifierId: dto.LastModifierId, isDeleted: dto.IsDeleted, version: dto.Version )); }
/// <summary> /// 转换为附件实体 /// </summary> /// <param name="dto">附件数据传输对象</param> public static Attachment ToEntity2(this AttachmentDto dto) { if (dto == null) { return(new Attachment()); } return(new Attachment(dto.Id.ToGuid()) { FileName = dto.FileName, FileType = dto.FileType, Size = dto.Size, RemoteUrl = dto.RemoteUrl, LocalUrl = dto.LocalUrl, Width = dto.Width, Height = dto.Height, MerchantId = dto.MerchantId, Module = dto.Module, CreationTime = dto.CreationTime, CreatorId = dto.CreatorId, LastModificationTime = dto.LastModificationTime, LastModifierId = dto.LastModifierId, IsDeleted = dto.IsDeleted, Version = dto.Version, }); }
public static AttachmentViewModel MapToViewModel(this AttachmentDto att) { return(new AttachmentViewModel { Name = att.Name, Size = Math.Round(att.SizeMb, 2) }); }
/// <summary> /// 转换为附件实体 /// </summary> /// <param name="dto">附件数据传输对象</param> public static Attachment ToEntity(this AttachmentDto dto) { if (dto == null) { return(new Attachment()); } return(dto.MapTo(new Attachment(dto.Id.ToGuid()))); }
public async Task Handle_CorrectParams_ShouldUpdateRankAndSendAnwer() { // Arrange var attachment = new AttachmentDto() { Actions = new List <AttachmentActionDto> { new AttachmentActionDto("test", "test") }, }; var originalMessage = new OriginalMessageDto() { Text = "testText", Attachments = new List <AttachmentDto> { attachment }, TimeStamp = It.IsAny <string>() }; var actionParams = new HelpedSlackActionParams() { User = new ItemInfo { Id = "id", Name = "Bob" }, OriginalMessage = originalMessage, Channel = new ItemInfo { Id = "channelId", Name = "channelName" }, ButtonParams = new HelpedAnswerActionButtonParams { AnswerId = "1234", QuestionId = "1234" } }; _questionService .Setup(m => m.AnswerRankUpAsync(It.IsAny <string>(), It.IsAny <string>())) .Returns(Task.CompletedTask); _slackClient .Setup(m => m.UpdateMessageAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <List <AttachmentDto> >())) .Returns(Task.CompletedTask); // Act await _handler.Handle(actionParams); // Assert _questionService.Verify( m => m.AnswerRankUpAsync(actionParams.ButtonParams.QuestionId, actionParams.ButtonParams.AnswerId), Times.Once); _questionService.VerifyNoOtherCalls(); _slackClient.Verify(m => m.UpdateMessageAsync(actionParams.OriginalMessage.TimeStamp, actionParams.Channel.Id, It.IsAny <string>(), It.IsAny <IList <AttachmentDto> >())); _slackClient.VerifyNoOtherCalls(); }
/// <inheritdoc/> public async Task <AttachmentInfoDto> SaveAttachmentAsync(AttachmentDto attachmentDto, CancellationToken cancellationToken) { var fileName = $"{Guid.NewGuid()}.{MimeTypesMap.GetExtension(attachmentDto.ContentType)}"; var path = GetFullFilePath(fileName); await File.WriteAllBytesAsync(path, attachmentDto.Data, cancellationToken); return(new AttachmentInfoDto() { FileKey = path }); }
public async Task DownloadFile(AttachmentDto attachment) { var response = await HttpClient.GetAsync($"{Url}/Attachment/{attachment.Id}"); var directory = Path.Combine(Android.OS.Environment.ExternalStorageDirectory.AbsolutePath, Android.OS.Environment.DirectoryDownloads); var file = Path.Combine(directory, attachment.FileName); var bytes = await response.Content.ReadAsByteArrayAsync(); File.WriteAllBytes(file, bytes); }
public static Attachment ToEntity(this AttachmentDto dto) { return(new Attachment { ID = dto.ID, Name = dto.Name, Description = dto.Description, FullPath = dto.FullPath, AttachmentTypeID = dto.AttachmentTypeID }); }
private static AttachmentVm GetAttachmentVm(AttachmentDto attachment, long?requestorId) { return(attachment == null ? null : new AttachmentVm { Hash = attachment.Hash, Type = attachment.Type, Payload = PayloadStringToObject(attachment.Payload, attachment.Type, requestorId).Result }); }
/// <summary> /// Saves the specified dto. /// </summary> /// <param name="dto">The dto.</param> /// <returns></returns> public AttachmentDto Save(AttachmentDto dto) { try { var retVal = this.dal.Save(dto.Id, dto.FileName, dto.Extension, dto.MimeType, dto.Content, dto.Product.Id).ToDto(); return(retVal); } catch (Exception) { throw; } }
public async Task <ResultObject> UploadFiles([FromForm] ICollection <IFormFile> filess) { var resultobject = new ResultObject(); var files = Request.Form.Files; string attachmentDto = Request.Form["attachmentDto"]; string dtoName = Request.Form["dtoName"]; AttachmentDto attDto = Newtonsoft.Json.JsonConvert.DeserializeObject <AttachmentDto>(attachmentDto); attDto.File = files[0]; if (files.Any(f => f.Length == 0)) { return(new ResultObject { Result = attDto, ServerErrors = null /*new List<ServerErr>().Add(new ServerErr() { Hint = "هیچ فایلی فرستاده نشده است" })*/ }); } if (attDto.AttachmentTypeID == 0) { resultobject.ServerErrors.Add(new ServerErr() { Hint = "نوع فایل را وارد کنید" }); return(resultobject); } string entity = attDto.entity.ToString(); if (dtoName == ConstAttachmentTypeCategory.Customer.ToString()) { CustomerHeadDto customerDto = Newtonsoft.Json.JsonConvert.DeserializeObject <CustomerHeadDto>(entity); attDto.CustomerHeadID = customerDto.ID; attDto.Path = await _uploadAppService.CreateDirectoryAndFile(attDto.CustomerHeadID.Value, "CustomerDto", attDto.File); } else if (dtoName == ConstAttachmentTypeCategory.User.ToString()) { UserDto userDto = Newtonsoft.Json.JsonConvert.DeserializeObject <UserDto>(entity); attDto.UserID = userDto.ID; attDto.Path = await _uploadAppService.CreateDirectoryAndFile(attDto.UserID.Value, "UserDto", attDto.File); } await _uploadAppService.CreateAttachmentAsync(attDto); resultobject.Result = attDto; resultobject.ServerErrors = null; return(resultobject); }
public async Task <VarlikResult <AttachmentDto> > UploadFile(HttpPostedFile file) { var result = new VarlikResult <AttachmentDto>(); StorageClient storageClient = StorageClient.Create(); var createBucketResult = CreateBucket(); if (!createBucketResult.IsSuccess) { result.Status = createBucketResult.Status; return(result); } var bucketName = createBucketResult.Data; var fileName = IdentityHelper.Instance.TokenUser.Mail + "_" + Guid.NewGuid().ToString(); var fileAcl = PredefinedObjectAcl.BucketOwnerFullControl; try { var fileObject = await storageClient.UploadObjectAsync( bucket : bucketName, objectName : fileName, contentType : file.ContentType, source : file.InputStream, options : new UploadObjectOptions { PredefinedAcl = fileAcl } ); AttachmentDto attachmentDto = new AttachmentDto(); attachmentDto.BucketName = bucketName; attachmentDto.IdFileType = file.ContentType; attachmentDto.Path = fileObject.MediaLink; attachmentDto.FileName = file.FileName; var attachmentSaveResult = await SaveAttachment(attachmentDto); attachmentDto.Id = attachmentSaveResult.ObjectId; result.Data = attachmentDto; result.Data.Path = null; result.Status = attachmentSaveResult.Status; result.ObjectId = attachmentSaveResult.ObjectId; return(result); } catch (Exception e) { } return(result); }
public virtual AttachmentDto getAttachment(string attachmentId) { ensureHistoryEnabled(Status.NOT_FOUND); Attachment attachment = engine.TaskService.getTaskAttachment(taskId, attachmentId); if (attachment == null) { throw new InvalidRequestException(Status.NOT_FOUND, "Task attachment with id " + attachmentId + " does not exist for task id '" + taskId + "'."); } return(AttachmentDto.fromAttachment(attachment)); }
public async Task <ActionResult <Attachment> > PostAttachment([FromBody] AttachmentDto attachmentDto) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var attachmentToAdd = _mapper.Map <AttachmentDto, Attachment>(attachmentDto); _context.Attachment.Add(attachmentToAdd); await _context.SaveChangesAsync(); return(CreatedAtAction("GetAttachment", new { id = attachmentToAdd.Id }, attachmentToAdd)); }
public async Task <JsonResult> ProcessTaskItemAssign(TaskItemAssignModel model) { SendMessageResponse rs = null; try { TaskItemAssignDto dto = new TaskItemAssignDto(); //check permission dto = _mapper.Map <TaskItemAssignDto>(model); dto.IsFullControl = false; if (CurrentUser.HavePermission(EnumModulePermission.Task_FullControl)) { dto.IsFullControl = true; } dto.ModifiedBy = CurrentUser.Id; dto.ModifiedDate = DateTime.Now; dto.Attachments = new List <AttachmentDto>(); if (Request.Files.Count > 0) { foreach (string file in Request.Files) { var fileContent = Request.Files[file]; byte[] document = Utility.ReadAllBytes(fileContent); string ext = Path.GetExtension(fileContent.FileName).Replace(".", ""); AttachmentDto attachmentDto = new AttachmentDto() { Id = Guid.NewGuid(), CreateByFullName = CurrentUser.FullName, CreatedBy = CurrentUser.Id, CreatedDate = DateTime.Now, FileExt = ext, FileContent = document, FileName = fileContent.FileName, FileSize = fileContent.ContentLength, ProjectId = dto.Id, Source = Entities.Source.TaskItemAssign, }; dto.Attachments.Add(attachmentDto); } } rs = await _taskItemAssignService.UpdateProcessTaskAssign(dto); } catch (Exception ex) { _loggerServices.WriteError(ex.ToString()); } return(Json(rs, JsonRequestBehavior.AllowGet)); }
public static AttachmentDto ToDto(this Attachment e) { if (e == null) { return(null); } var res = new AttachmentDto(); res.Id = e.Id; res.Name = e.Name; res.Size = e.Size; res.IdResource = e.IdResource; return(res); }
public async Task <AttachmentDto> UploadAttachment(IFormFile file, Guid guid, string comment = "") { Guard.ArgumentNotNull(file, "File cannot be null"); Guard.ArgumentNotNull(comment, "Comment can not be null but empty"); Guard.IsGreaterThanZero(file.Length); var s3FileInfo = await _awsS3Service.UploadFileAsync(_awsConfig.S3BucketForFiles, guid.ToString(), file); var attachmentId = CreateAttachmentProperties(s3FileInfo, comment); var attachmentDto = new AttachmentDto { Id = attachmentId, s3File = s3FileInfo }; return(attachmentDto); }
public async Task AddAttachment(AttachmentDto attachmentDto, string userId) { if (attachmentDto != null) { var newAttachment = mapper.Map <Attachment>(attachmentDto); newAttachment.CreatorId = userId; await attachmentRepository.SaveAttachment(newAttachment); await attachmentRepository.SaveChanges(); } else { throw new Exception("Error occured while saving, please try later"); } }
/// <summary> /// Creates the specified dto. /// </summary> /// <param name="dto">The dto.</param> /// <returns></returns> /// <exception cref="ArgumentException">File name, extension and Content must be provided</exception> public AttachmentDto Create(AttachmentDto dto) { try { if (string.IsNullOrEmpty(dto.FileName) || string.IsNullOrEmpty(dto.Extension) || dto.Content.Length == 0) { throw new ArgumentException("File name, extension and Content must be provided"); } var retVal = this.dal.Create(dto.FileName, dto.Extension, dto.MimeType, dto.Content, dto.Product.Id).ToDto(); return(retVal); } catch (Exception) { throw; } }
private void dgAttachments_SelectionChanged(object sender, EventArgs e) { DataGridView dg = (DataGridView)sender; DataGridViewRow row = dg.CurrentRow; if (bsAttachments.DataSource != null) { if (dgAttachments.Rows.Count > 0) { AttachmentDto selectedAttachment = (AttachmentDto)row.DataBoundItem; if (selectedAttachment != null) { _selectedAttachmentDTO = selectedAttachment; } } } }
public AttachmentDto getDto(IList<QueryModel> qmlist) { SqlConnection cn = null; AttachmentDto pm = new AttachmentDto(); try { cn = DbHelperSQL.getConnection(); pm = dal.getDto(cn, null, qmlist); } catch (SqlException sqlex) { throw new MakeException(ExpSort.普通, sqlex.Message); } finally { DbHelperSQL.closeConnection(cn); } return pm; }