void LoadPreviewText(PreviewFile preview)
{
Stream file = null;
try
{
file = VFS.OpenBinaryStream(preview.Entry).AsStream;
if (!TextView.IsTextFile(file))
{
ResetPreviewPane();
return;
}
var enc = EncodingChoice.SelectedItem as Encoding;
if (null == enc)
{
enc = TextView.GuessEncoding(file);
EncodingChoice.SelectedItem = enc;
}
TextView.DisplayStream(file, enc);
ActiveViewer = TextView;
CurrentTextInput = file;
file = null;
}
catch (Exception X)
{
SetStatusText(X.Message);
}
finally
{
if (file != null)
{
file.Dispose();
}
}
}
void SetPreviewImage(PreviewFile preview, BitmapSource bitmap, ImageFormat format)
{
if (bitmap.DpiX != Desktop.DpiX || bitmap.DpiY != Desktop.DpiY)
{
int stride = bitmap.PixelWidth * ((bitmap.Format.BitsPerPixel + 7) / 8);
var pixels = new byte[stride * bitmap.PixelHeight];
bitmap.CopyPixels(pixels, stride, 0);
var fixed_bitmap = BitmapSource.Create(bitmap.PixelWidth, bitmap.PixelHeight,
Desktop.DpiX, Desktop.DpiY, bitmap.Format, bitmap.Palette, pixels, stride);
bitmap = fixed_bitmap;
}
if (!bitmap.IsFrozen)
{
bitmap.Freeze();
}
Dispatcher.Invoke(() =>
{
if (m_current_preview == preview) // compare by reference
{
ActiveViewer = ImageView;
ImageCanvas.Source = bitmap;
ApplyDownScaleSetting();
SetStatusText(string.Format(guiStrings.MsgImageSize, bitmap.PixelWidth,
bitmap.PixelHeight, bitmap.Format.BitsPerPixel, format?.Tag ?? "?"));
}
});
}
protected override void AdjustModel(TPreviewableDomainModel model)
{
base.AdjustModel(model);
var ravenEntityPreviewStorage = SourceContainer.Resolve <TPreviewRepository>();
var destinationModelId = GetDestinationModelId(model);
Stream stream;
var previewFile = ravenEntityPreviewStorage.GetPreviewFile(destinationModelId, out stream);
if (previewFile != null && stream != null)
{
var location = previewFile.Id.Split('/').FirstOrDefault() ?? "unidentified";
previewFile = PreviewFile.Create(previewFile.FileName, previewFile.ContentType, previewFile.ContentLength, location);
using (var ms = new MemoryStream())
{
stream.CopyTo(ms);
_ = ms.Seek(0, SeekOrigin.Begin);
previewFile.SetContent(ms.ToByteArray());
stream.Dispose();
}
SetDestinationModelPreview(model, previewFile);
}
// Fix situation when referenced file can not be retriewed
if (previewFile == null)
{
SetDestinationModelPreview(model, null);
}
}
public async Task DeleteFileAsync(Guid fileId)
{
var fileEntity = await _context
.Files
.FindAsync(fileId);
if (fileEntity == null)
{
return;
}
var blobContainerClient = fileEntity switch
{
CaffFile _ => _caffBlobContainerClient,
PreviewFile _ => _previewBlobContainerClient,
_ => throw new InvalidOperationException()
};
var blobName = GetBlobName(fileEntity);
var blobClient = blobContainerClient.GetBlobClient(blobName);
await blobClient.DeleteIfExistsAsync();
_context.Files.Remove(fileEntity);
await _context.SaveChangesAsync();
}
void UpdatePreviewPane(Entry entry)
{
SetStatusText("");
var vm = ViewModel;
m_current_preview = new PreviewFile {
Path = vm.Path, Name = entry.Name, Entry = entry
};
ImageCanvas.Source = null;
TextView.Clear();
if (!IsPreviewPossible(entry))
{
ActiveViewer = ImageView;
return;
}
if ("image" != entry.Type)
{
LoadPreviewText(m_current_preview);
}
else if (!m_preview_worker.IsBusy)
{
m_preview_worker.RunWorkerAsync(m_current_preview);
}
else
{
m_preview_pending = true;
}
}
public async Task <FileDto> GetFileAsync(Guid fileId)
{
var fileEntity = await _context
.Files
.FindAsync(fileId);
if (fileEntity == null)
{
throw new CaffStoreNotFoundException("File not found");
}
var blobName = GetBlobName(fileEntity);
var blobContainerClient = fileEntity switch
{
CaffFile _ => _caffBlobContainerClient,
PreviewFile _ => _previewBlobContainerClient,
_ => throw new InvalidOperationException()
};
var blobClient = blobContainerClient.GetBlobClient(blobName);
var uri = fileEntity switch
{
CaffFile _ => GenerateSasUri(blobClient.Uri),
PreviewFile _ => blobClient.Uri,
_ => throw new InvalidOperationException()
};
return(new FileDto
{
Id = fileEntity.Id,
FileUri = uri
});
}
void UpdatePreviewPane(Entry entry)
{
SetStatusText("");
var vm = ViewModel;
m_current_preview = new PreviewFile {
Path = vm.Path, Name = entry.Name, Entry = entry
};
if (!IsPreviewPossible(entry))
{
ResetPreviewPane();
return;
}
if ("image" != entry.Type)
{
LoadPreviewText(m_current_preview);
}
else if (!m_preview_worker.IsBusy)
{
m_preview_worker.RunWorkerAsync(m_current_preview);
}
else
{
m_preview_pending = true;
}
}
/// <summary>
/// Method renders new window with passed data, window's title and name
/// </summary>
/// <param name="fielData"></param>
/// <param name="windowTitle"></param>
/// <param name="windowName"></param>
private void RenderNewWindow(List <string> fileData, string windowTitle, string windowName)
{
if (!IsWindowOpen <MetroWindow>(windowName))
{
PreviewFile previewFileWindow = new PreviewFile(fileData, windowTitle);
previewFileWindow.Name = windowName;
previewFileWindow.Show();
}
}
/// <summary>
/// Show file with its content
/// </summary>
private void ShowFile()
{
if (!IsWindowOpen <MetroWindow>(Name.Substring(0, Name.IndexOf('.'))))
{
PreviewFile previewFileWindow = new PreviewFile(fileData, "Podgląd pliku " + Name);
previewFileWindow.Name = Name.Substring(0, Name.IndexOf('.')).Replace(' ', '_');
previewFileWindow.Show();
}
}
public byte[] GetContent(int entityId)
{
PreviewFile previewFile = FindById(entityId)?.Preview;
if (previewFile is null)
{
return(null);
}
else
{
return(previewFile.GetContent());
}
}
public IHttpActionResult Get(int id)
{
Stream stream;
PreviewFile previewFile = _tenantsRepository.GetPreviewFile(entityId: id, out stream);
if (stream == null || previewFile == null)
{
return(NotFound());
}
return(new ContentStreamActionResult(Request,
previewFile.FileName,
previewFile.ContentType,
stream));
}
void LoadPreviewImage(PreviewFile preview)
{
try
{
using (var data = VFS.OpenImage(preview.Entry))
{
SetPreviewImage(preview, data.Image.Bitmap);
}
}
catch (Exception X)
{
SetStatusText(X.Message);
}
}
public void SetPreviewFile(int entityId, PreviewFile previewFile, Stream previewFileStream)
{
var entity = GetEntityById(entityId);
if (entity != null)
{
entity.Preview = null;
entity.Preview = _mapper.Map <Entities.Master.PreviewFile>(previewFile);
entity.Preview.SetContentBytes(previewFileStream.ToByteArray());
_dbContext.Update(entity, post =>
{
//post.MapTo( entity.Preview );
}, _mapper);
}
}
void LoadPreviewImage(PreviewFile preview)
{
try
{
using (var data = VFS.OpenImage(preview.Entry))
{
SetPreviewImage(preview, data.Image.Bitmap, data.SourceFormat);
}
}
catch (Exception X)
{
Dispatcher.Invoke(ResetPreviewPane);
SetStatusText(X.Message);
}
}
public void SetPreviewFile(int userId, PreviewFile previewFile, Stream previewFileStream)
{
var user = FindById(userId);
if (previewFileStream == null || user == null)
{
return;
}
var existingPreviewId = user.Preview?.Id;
if (existingPreviewId != null)
{
_previewFileStorage.DeletePreviewFile(existingPreviewId);
}
user.Preview = previewFile;
_previewFileStorage.UploadPreviewFile(previewFile, previewFileStream);
}
public void SetPreviewFile(int tenantId, PreviewFile previewFile, Stream previewFileStream)
{
var entity = _dbContext.Find <Tenant>(tenantId);
if (previewFileStream == null)
{
return;
}
var existingPreviewId = entity.Preview?.Id;
if (existingPreviewId != null)
{
_previewFileStorage.DeletePreviewFile(existingPreviewId);
}
entity.Preview = previewFile;
_previewFileStorage.UploadPreviewFile(previewFile, previewFileStream);
}
public void OpenFile(string filePath)
{
string fileName = "test";
string ext = string.Empty;
if (filePath.Contains(".pdf"))
{
ext = ".pdf";
}
else
{
ext = ".png";
}
PreviewFile previewFile = new PreviewFile(fileName + ext, filePath);
QLPreviewController previewController = new QLPreviewController();
previewController.DataSource = new PreviewControllerDataSource(previewFile);
UIApplication.SharedApplication.KeyWindow.RootViewController.PresentViewController(previewController, true, HandleAction);
}
public IHttpActionResult Post([FromUri] int id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!Request.Content.IsMimeMultipartContent())
{
return(StatusCode(HttpStatusCode.UnsupportedMediaType));
}
var multipartStreamProvider = Request.Content.ReadAsMultipartAsync().Result;
var sContent = multipartStreamProvider.Contents.SingleOrDefault();
if (sContent == null)
{
return(StatusCode(HttpStatusCode.NotAcceptable));
}
var user = _usersRepository.GetById(id);
if (user == null)
{
return(NotFound());
}
var headers = sContent.Headers;
var previewFile = PreviewFile.Create(
filename: headers.ContentDisposition?.FileName,
contentType: headers.ContentType.MediaType,
contentLength: headers.ContentLength,
location: "users");
using (var contentStream = sContent.ReadAsStreamAsync().Result)
{
_usersRepository.SetPreviewFile(entityId: id, previewFile, contentStream);
}
_usersRepository.SaveChanges();
return(Ok());
}
/// <summary>
/// implementation of the recommended dispose protocol
/// deletes the file if possible.
/// </summary>
/// <param name="disposing">true if this method is called from IDisposable.Dispose() and false if called from Finalizer</param>
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
try
{
if (disposing)
{
PreviewFile.Dispose();
}
// release the native unmanaged resources you added
// in this derived class here.
disposed = true;
}
finally
{
}
}
}
public void UploadPreviewFile(PreviewFile previewFile, Stream previewFileStream)
{
if (previewFileStream == null)
{
return;
}
var metadata = new RavenJObject()
{
{ "XG-File-Id", RavenJToken.FromObject(previewFile.Id) },
{ "XG-File-Name", RavenJToken.FromObject(previewFile.FileName) },
{ "XG-File-Extension", RavenJToken.FromObject(previewFile.FileExtension) },
{ "XG-Content-Type", RavenJToken.FromObject(previewFile.ContentType) },
{ "XG-Content-Length", RavenJToken.FromObject(previewFile.ContentLength) }
};
using (var session = _filesStore.OpenAsyncSession())
{
session.Commands.UploadAsync(previewFile.Id, previewFileStream, metadata).Wait();
}
}
void LoadPreviewImage(PreviewFile preview)
{
try
{
using (var file = OpenPreviewStream(preview))
{
var data = ImageFormat.Read(preview.Name, file);
if (null != data)
{
SetPreviewImage(preview, data.Bitmap);
}
else
{
Trace.WriteLine("Cannot parse image format", preview.Name);
}
}
}
catch (Exception X)
{
SetStatusText(X.Message);
}
}
public void SetPreviewFile(int entityId, PreviewFile previewFile, Stream previewFileStream) => _previewFileStorage.SetPreviewFile(entityId, previewFile, previewFileStream);
Stream OpenPreviewStream(PreviewFile preview)
{
return(VFS.OpenSeekableStream(preview.Entry));
}
