public void SaveFile(string path)
{
SaveFileRequest?.Invoke(this, new FileIOEventArgs()
{
Path = path
});
}
/// <summary>
/// Сохраняет файл
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <SaveFileResponse> Save(SaveFileRequest request)
{
try
{
var path = $"{_options.FilesPath}/{request.DirectoryName.ToString()}/{request.FileName}/";
var savePath = $"{_hostingEnvironment.WebRootPath}{path}";
var directory = Path.GetDirectoryName(savePath);
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
var image = Image.Load(request.UploadedFile.OpenReadStream());
var ratio = image.Height / image.Width;
var smallImage = image.Clone(x => x.Resize(_options.SmallImageSize.Width, _options.SmallImageSize.Heigth * ratio));
var extension = Path.GetExtension(request.UploadedFile.FileName);
image.Save($"{savePath}{ImageSizes.Full.ToString()}{extension}");
smallImage.Save($"{savePath}{ImageSizes.Small.ToString()}{extension}");
var httpContext = _httpContextAccessor.HttpContext.Request;
var url = $"{httpContext.Scheme}://{_httpContextAccessor.HttpContext.Request.Host.Value}{path}";
return(new SaveFileResponse {
Url = url, Extension = extension, Path = savePath
});
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
throw new Exception(ex.Message);
}
}
private async Task <string> SaveAutoPartImageFromNotificationAndDeletePreviousImageIfItExists(
UpdateAutoPartNotification notification,
AutoPart entity)
{
if (!string.IsNullOrEmpty(notification.ImageFileName) && !notification.ImageFileBuffer.IsEmpty)
{
if (!string.IsNullOrEmpty(entity.Image))
{
var deleteFileNotification = new DeleteFileNotification
{
FileName = entity.Image
};
await mediator.Publish(deleteFileNotification)
.ConfigureAwait(false);
}
var saveFileRequest = new SaveFileRequest
{
FileName = notification.ImageFileName,
Buffer = notification.ImageFileBuffer
};
return(await mediator.Send(saveFileRequest)
.ConfigureAwait(false));
}
return(entity.Image);
}
/// <summary>
/// Обновляет объявление
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <bool> Update(UpdateAdvertisementRequest request)
{
using (var transaction = await _dataContext.Database.BeginTransactionAsync(System.Data.IsolationLevel.RepeatableRead))
{
try
{
var advertisement = await _dataContext.Advertisements.FirstOrDefaultAsync(a => a.Id == request.Id);
if (advertisement == null)
{
throw new Exception("Объявление не найдено.");
}
if (_user.Role != UserRoles.Admin && _user.Id != advertisement.UserId)
{
throw new Exception("У вас нет прав редактировать данное объявление.");
}
var filesInfo = new SaveFileResponse {
Url = "", Extension = ""
};
if (request.Image != null)
{
if (Directory.Exists(advertisement.ImagePath))
{
Directory.Delete(advertisement.ImagePath, true);
}
var saveFileReq = new SaveFileRequest
{
FileName = $"{advertisement.Id}",
DirectoryName = FileDirectories.Advertisements,
UploadedFile = request.Image
};
filesInfo = await _fileService.Save(saveFileReq);
}
advertisement.ImageUrl = filesInfo.Url;
advertisement.ImageExtension = filesInfo.Extension;
advertisement.ImagePath = filesInfo.Path;
advertisement.Text = request.Text;
await _dataContext.SaveChangesAsync();
await transaction.CommitAsync();
return(true);
}
catch (Exception exception)
{
await transaction.RollbackAsync();
_logger.LogError(exception.Message);
throw exception;
}
}
}
/// <summary>
/// Добавляет объявление
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <int> Add(AddAdvertisementRequest request)
{
using (var transaction = await _dataContext.Database.BeginTransactionAsync(System.Data.IsolationLevel.Serializable))
{
try
{
var currentCount = await _dataContext.Advertisements.CountAsync(a => a.UserId == _user.Id);
if (currentCount >= _options.MaxAdsPerUser)
{
throw new Exception("Вы исчерпали лимит объявлений.");
}
var id = Guid.NewGuid();
var saveFileRequest = new SaveFileRequest
{
FileName = $"{id}",
DirectoryName = FileDirectories.Advertisements,
UploadedFile = request.Image
};
var filesInfo = request.Image != null ? await _fileService.Save(saveFileRequest) : new SaveFileResponse
{
Url = "", Extension = ""
};
var advertisement = new Data.Entities.Advertisement
{
Id = id,
ImageUrl = filesInfo.Url,
ImageExtension = filesInfo.Extension,
ImagePath = filesInfo.Path,
Text = request.Text,
UserId = _user.Id
};
await _dataContext.AddAsync(advertisement);
await _dataContext.SaveChangesAsync();
await transaction.CommitAsync();
return(advertisement.Number);
}
catch (Exception exception)
{
await transaction.RollbackAsync();
_logger.LogError(exception.Message);
throw exception;
}
}
}
private async Task <string> SaveAutoPartImageFromNotification(CreateAutoPartNotification notification)
{
if (!string.IsNullOrEmpty(notification.ImageFileName) && !notification.ImageFileBuffer.IsEmpty)
{
var saveFileRequest = new SaveFileRequest
{
FileName = notification.ImageFileName,
Buffer = notification.ImageFileBuffer
};
return(await mediator.Send(saveFileRequest)
.ConfigureAwait(false));
}
return(null);
}
private void saveFile()
{
TestText = "save File!!";
SaveFileRequest.Raise(new Confirmation {
Title = "", Content = new FileMessage()
},
(confirmation) =>
{
if (confirmation.Confirmed)
{
var fileMessage = confirmation.Content as FileMessage;
TestText = fileMessage.FileName;
}
}
);
}
private void OnSave()
{
var notification = new SaveFileDialogNotification();
notification.RestoreDirectory = true;
notification.Filter = "DOT files (*.dot)|*.dot|DGML files (*.dgml)|*.dgml|Plainion.GraphViz files (*.pgv)|*.pgv";
notification.FilterIndex = 0;
notification.DefaultExt = ".dot";
SaveFileRequest.Raise(notification,
n =>
{
if (n.Confirmed)
{
Save(n.FileName);
}
});
}
public async Task Handle(CreateManufacturerNotification notification, CancellationToken cancellationToken)
{
var manufacturer = mapper.Map <Manufacturer>(notification);
if (!string.IsNullOrWhiteSpace(notification.ImageFileName) && !notification.ImageFileBuffer.IsEmpty)
{
var saveFileRequest = new SaveFileRequest
{
FileName = notification.ImageFileName,
Buffer = notification.ImageFileBuffer
};
manufacturer.Image = await mediator.Send(saveFileRequest)
.ConfigureAwait(false);
}
var operationResult = await manufacturerRepository.CreateAsync(manufacturer)
.ConfigureAwait(false);
if (operationResult.Status != OperationStatus.Successful)
{
throw new CreateManufacturerException(operationResult);
}
}
public async Task SaveReadDeleteFileAsync()
{
// Save file
var filePath = TestHelper.GetDefaultImagePath();
var saveFileRequest = new SaveFileRequest
{
FieldId = _fieldId,
RecordId = _recordId,
FileStream = File.OpenRead(filePath),
FileName = Path.GetFileName(filePath),
ContentType = "image/png",
ModifiedDate = DateTime.UtcNow,
Notes = "Test file."
};
var saveResponse = await _apiClient.SaveFileAsync(saveFileRequest);
AssertHelper.AssertSuccess(saveResponse);
var fileId = saveResponse.Value.Id;
// Get info
var getFileInfoResponse = await _apiClient.GetFileInfoAsync(_recordId, _fieldId, fileId);
AssertHelper.AssertSuccess(getFileInfoResponse);
// Get raw file back
var getFileResponse = await _apiClient.GetFileAsync(_recordId, _fieldId, fileId);
AssertHelper.AssertSuccess(getFileResponse);
// Delete file
var deleteResponse = await _apiClient.DeleteFileAsync(_recordId, _fieldId, fileId);
AssertHelper.AssertSuccess(deleteResponse);
}
public ActionResult SaveFileText([NotNull][FromBody] SaveFileRequest request)
{
System.IO.File.WriteAllText(Path.Combine(_hostingEnvironment.WebRootPath, $"simple\\src\\app\\{request.FileName}"), request.FileText);
return(Ok());
}
/// <summary>
/// Saves a file.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <ApiResponse <CreatedWithIdResponse <int> > > SaveFileAsync(SaveFileRequest request)
{
Arg.IsNotNull(request, nameof(request));
var streamContent = new StreamContent(request.FileStream);
streamContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue(request.ContentType);
var path = UrlHelper.GetSaveFilePath();
var multiPartContent = new MultipartFormDataContent
{
{ streamContent, "file", request.FileName },
{ new StringContent(request.RecordId.ToString()), nameof(request.RecordId) },
{ new StringContent(request.FieldId.ToString()), nameof(request.FieldId) },
{ new StringContent(request.Notes), nameof(request.Notes) },
};
if (request.ModifiedDate != null)
{
multiPartContent.Add(new StringContent(request.ModifiedDate.ToString()), nameof(request.ModifiedDate));
}
var httpRequest = new HttpRequestMessage(HttpMethod.Post, path)
{
Content = multiPartContent,
};
var httpResponse = await HttpClient.SendAsync(httpRequest);
var apiResponse = await ApiResponseFactory.GetApiResponseAsync <CreatedWithIdResponse <int> >(httpResponse, ClientConfig.JsonSerializer);
return(apiResponse);
}
