/// <exclude />
public T GetData <T>(IDataId dataId) where T : class, IData
{
if (dataId == null)
{
throw new ArgumentNullException("dataId");
}
CheckInterface(typeof(T));
MediaDataId mediaDataId = dataId as MediaDataId;
if (mediaDataId == null)
{
return(null);
}
if (mediaDataId.MediaType == MediaElementType.Folder)
{
if (typeof(T) != typeof(IMediaFileFolder))
{
throw new ArgumentException("The dataId specifies a IMediaFileFolder, but the generic method was invoked with different type");
}
IMediaFolderData folder = DataFacade.GetData <IMediaFolderData>().FirstOrDefault(x => x.Id == mediaDataId.Id);
if (folder == null)
{
return(null);
}
return(new MediaFileFolder(folder, Store.Id,
_context.CreateDataSourceId(new MediaDataId {
MediaType = MediaElementType.Folder, Id = folder.Id
}, typeof(IMediaFileFolder))) as T);
}
if (mediaDataId.MediaType == MediaElementType.File)
{
if (typeof(T) != typeof(IMediaFile))
{
throw new ArgumentException("The dataId specifies a IMediaFile, but the generic method was invoked with different type");
}
IMediaFileData file = DataFacade.GetData <IMediaFileData>().FirstOrDefault(x => x.Id == mediaDataId.Id);
if (file == null)
{
return(null);
}
string internalPath = Path.Combine(_workingDirectory, file.Id.ToString());
return(new MediaFile(file, Store.Id,
_context.CreateDataSourceId(new MediaDataId {
MediaType = MediaElementType.File, Id = file.Id
}, typeof(IMediaFile)), internalPath) as T);
}
return(Store as T);
}
private void CopyFileData(IMediaFile from, IMediaFileData to)
{
to.CultureInfo = from.Culture;
to.Description = from.Description;
to.FileName = from.FileName;
to.FolderPath = from.FolderPath;
to.Length = from.Length;
to.MimeType = MimeTypeInfo.GetCanonical(from.MimeType);
to.Title = from.Title;
}
public MediaFile(IMediaFileData file, string storeId, DataSourceId dataSourceId, string filePath)
{
_dataSourceId = dataSourceId;
StoreId = storeId;
this.Id = file.Id;
this.FileName = file.FileName;
this.FolderPath = file.FolderPath;
this.Title = file.Title;
this.Description = file.Description;
this.MimeType = file.MimeType;
this.Length = file.Length;
this.IsReadOnly = false;
this.Culture = file.CultureInfo;
this.CreationTime = file.CreationTime;
this.LastWriteTime = file.LastWriteTime;
this.SystemPath = filePath;
}
private void UpdateMediaFile(IMediaFile updatedFile)
{
Guid id = updatedFile.Id;
IMediaFileData currentFileData = DataFacade.GetData <IMediaFileData>(x => x.Id == id).First();
if (updatedFile.FolderPath != currentFileData.FolderPath || updatedFile.FileName != currentFileData.FileName)
{
ValidateMediaFileData(updatedFile);
}
CopyFileData(updatedFile, currentFileData);
currentFileData.LastWriteTime = DateTime.Now;
using (Stream stream = updatedFile.GetReadStream())
{
currentFileData.Length = (int)stream.Length;
}
TransactionFileSystemFileStreamManager.WriteFileToDisk(updatedFile);
DataFacade.Update(currentFileData);
}
public MediaFile(IMediaFileData file, string storeId, DataSourceId dataSourceId, string filePath)
{
_dataSourceId = dataSourceId;
StoreId = storeId;
this.Id = file.Id;
this.FileName = file.FileName;
this.FolderPath = file.FolderPath;
this.Title = file.Title;
this.Description = file.Description;
this.MimeType = file.MimeType;
this.Length = file.Length;
this.IsReadOnly = false;
this.Culture = file.CultureInfo;
this.CreationTime = file.CreationTime;
this.LastWriteTime = file.LastWriteTime;
this.SystemPath = filePath;
}
private IMediaFile AddMediaFile(IMediaFile mediaFile)
{
ValidateMediaFileData(mediaFile);
IMediaFileData fileData = DataFacade.BuildNew <IMediaFileData>();
fileData.Id = Guid.NewGuid();
CopyFileData(mediaFile, fileData);
fileData.LastWriteTime = fileData.CreationTime = DateTime.Now;
IMediaFile internalMediaFile;
using (Stream readStream = mediaFile.GetReadStream())
{
Verify.IsNotNull(readStream, "GetReadStream returned null for type '{0}'", mediaFile.GetType());
fileData.Length = (int)readStream.Length;
string internalPath = Path.Combine(_workingDirectory, fileData.Id.ToString());
internalMediaFile = new MediaFile(fileData, Store.Id, _context.CreateDataSourceId(
new MediaDataId
{
MediaType = MediaElementType.File,
Id = fileData.Id
},
typeof(IMediaFile)), internalPath);
using (Stream writeStream = internalMediaFile.GetNewWriteStream())
{
readStream.CopyTo(writeStream);
}
}
TransactionFileSystemFileStreamManager.WriteFileToDisk(internalMediaFile);
fileData = DataFacade.AddNew <IMediaFileData>(fileData);
return(internalMediaFile);
}
private void finalizeCodeActivity_Finalize_ExecuteCode(object sender, EventArgs e)
{
AddNewTreeRefresher addNewTreeRefresher = this.CreateAddNewTreeRefresher(this.EntityToken);
UploadedFile uploadedFile = this.GetBinding <UploadedFile>("UploadedFile");
string filename;
if (this.BindingExist("Filename"))
{
filename = this.GetBinding <string>("Filename");
}
else
{
filename = uploadedFile.FileName;
}
using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope())
{
IMediaFileStore store = DataFacade.GetData <IMediaFileStore>(x => x.Id == this.StoreId).First();
IMediaFile existingFile = GetExistingFile(this.FolderPath, filename);
if (existingFile == null)
{
WorkflowMediaFile mediaFile = new WorkflowMediaFile();
mediaFile.FileName = System.IO.Path.GetFileName(filename);
mediaFile.FolderPath = this.FolderPath;
mediaFile.Title = this.GetBinding <string>("Title");
mediaFile.Description = this.GetBinding <string>("Description");
mediaFile.Tags = this.GetBinding <string>("Tags");
mediaFile.Culture = C1Console.Users.UserSettings.ActiveLocaleCultureInfo.Name;
mediaFile.Length = uploadedFile.ContentLength;
mediaFile.MimeType = MimeTypeInfo.GetMimeType(uploadedFile);
using (System.IO.Stream readStream = uploadedFile.FileStream)
{
using (System.IO.Stream writeStream = mediaFile.GetNewWriteStream())
{
readStream.CopyTo(writeStream);
}
}
IMediaFile addedFile = DataFacade.AddNew <IMediaFile>(mediaFile, store.DataSourceId.ProviderName);
addNewTreeRefresher.PostRefreshMesseges(addedFile.GetDataEntityToken());
SelectElement(addedFile.GetDataEntityToken());
}
else
{
Guid fileId = existingFile.Id;
IMediaFileData fileData = DataFacade.GetData <IMediaFileData>(file => file.Id == fileId).FirstOrDefault();
fileData.Title = this.GetBinding <string>("Title");
fileData.Description = this.GetBinding <string>("Description");
fileData.Tags = this.GetBinding <string>("Tags");
fileData.MimeType = MimeTypeInfo.GetMimeType(uploadedFile);
fileData.Length = uploadedFile.ContentLength;
using (System.IO.Stream readStream = uploadedFile.FileStream)
{
using (System.IO.Stream writeStream = existingFile.GetNewWriteStream())
{
readStream.CopyTo(writeStream);
}
}
DataFacade.Update(existingFile);
DataFacade.Update(fileData);
addNewTreeRefresher.PostRefreshMesseges(existingFile.GetDataEntityToken());
SelectElement(existingFile.GetDataEntityToken());
}
transactionScope.Complete();
}
}
