private RecordLockedData CreateLockData(OpenFileItemData itemParam, ref LogicFileInfoData logicFileInfo, Guid userID, DbTransaction trans)
{
RecordLockedData result = null;
FileAccess access = itemParam.FileAccess;
FileMode mode = itemParam.FileMode;
long fileLength = -1;
if (mode == FileMode.Truncate)
{
access |= FileAccess.Write;
fileLength = 0;
}
bool canWrite = (access & FileAccess.Write) != 0;
if (canWrite)
{
if (logicFileInfo == null)
{
logicFileInfo = CreateNewFile(itemParam, userID, trans);
}
else
{
logicFileInfo = UpdateFile(itemParam, logicFileInfo, fileLength, userID, trans);
}
if (logicFileInfo != null)
{
result = Lock(logicFileInfo.ID, userID);
}
}
return(result);
}
private int GetFileVersion(LogicFileInfoData logicFileInfo, DbTransaction trans)
{
int result = 1;
int count = logicFileInfo.PhysicalFileInfos.Count;
if (count > 0)
{
PhysicalFileInfoData fileData = logicFileInfo.PhysicalFileInfos[count - 1];
if (fileData.Version != count)
{
LogicFileInfoItemData itemData = new LogicFileInfoItemData();
itemData.ID = logicFileInfo.ID;
LogicFileInfoData newLogicFileInfo = this.DataProvider.FetchFileInfo(itemData, trans);
if (newLogicFileInfo != null)
{
count = newLogicFileInfo.PhysicalFileInfos.Count;
fileData = newLogicFileInfo.PhysicalFileInfos[count - 1];
}
}
if (fileData != null)
{
result = fileData.Version + 1;
}
}
return(result);
}
protected OpenFileResultItemData OpenFileItem(OpenFileItemData itemParam, Guid userID, DbTransaction trans)
{
OpenFileResultItemData item = new OpenFileResultItemData();
LogicFileInfoData logicFileInfo = this.DataProvider.FetchFileInfo(CreateFetchItemParam(itemParam), trans);
item.LockedData = this.CreateLockData(itemParam, ref logicFileInfo, userID, trans);
item.LogicFileInfo = logicFileInfo;
return(item);
}
/// <summary>
/// 获取链接文件的URL
/// </summary>
/// <param name="logicFileID"></param>
/// <param name="passportID"></param>
/// <returns></returns>
public static string GetFileUrl(Guid logicFileID, string passportID)
{
string result = null;
LogicFileInfoData logicFileInfo = GetFileInfo(logicFileID);
if (logicFileInfo != null)
{
string pid = string.Empty;
result = string.Format(GetFileUrlParam, ApplicationPath, logicFileID, HttpUtility.UrlEncode(passportID), HttpUtility.UrlEncode(Path.GetFileName(logicFileInfo.LogicFileName)));
}
return(result);
}
/// <summary>
/// 获取图片的Url
/// </summary>
/// <param name="logicFileID"></param>
/// <param name="passportID"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <returns></returns>
public static string ThumbImageUrl(Guid logicFileID, string passportID, int width, int height)
{
string result = null;
LogicFileInfoData logicFileInfo = GetFileInfo(logicFileID);
if (logicFileInfo != null)
{
result = string.Format(ThumbImageUrlParam, ApplicationPath, logicFileID,
HttpUtility.UrlEncode(passportID),
HttpUtility.UrlEncode(Path.GetFileName(logicFileInfo.LogicFileName)),
width, height);
}
return(result);
}
private LogicFileInfoData UpdateFile(OpenFileItemData itemParam, LogicFileInfoData logicFileInfo, long fileLength, Guid userID, DbTransaction trans)
{
LogicFileInfoData result = logicFileInfo;
UpdateMode updateMode = itemParam.UpdateMode;
FileMode mode = itemParam.FileMode;
long length = 0;
if (updateMode == UpdateMode.None)
{
updateMode = UpdateMode.Override;
}
if (updateMode == UpdateMode.NewVersion)
{
PhysicalFileInfoData oldFileData = logicFileInfo.PhysicalFileInfos[logicFileInfo.PhysicalFileInfos.Count - 1];
Guid physcicalFileID = CombineGuid.NewComboGuid();
switch (mode)
{
case FileMode.Truncate:
case FileMode.Create:
FileStorageManager.SetFileLength(this.DataProvider, physcicalFileID, result.LogicFileExt, 0);
break;
default:
length = FileStorageManager.CopyFile(this.DataProvider, oldFileData.ID, physcicalFileID, logicFileInfo.LogicFileExt);
break;
}
PhysicalFileInfoData fileData = new PhysicalFileInfoData();
fileData.ID = physcicalFileID;
fileData.LogicFileID = result.ID;
fileData.FileLength = length;
fileData.Version = GetFileVersion(logicFileInfo, trans);
fileData.StoreModeID = FileStorageManager.GetCurrentStoreModeID(this.DataProvider);
this.DataProvider.CreatePhysicalFileInfo(fileData, trans);
result.PhysicalFileInfos.Add(fileData);
result.LatestPhysicalFileID = physcicalFileID;
this.DataProvider.UpdateFileInfo(logicFileInfo, trans);
}
else if (updateMode == UpdateMode.Override)
{
switch (mode)
{
case FileMode.Truncate:
case FileMode.Create:
FileStorageManager.SetFileLength(this.DataProvider, logicFileInfo.LatestPhysicalFileID, result.LogicFileExt, 0);
break;
}
}
return(result);
}
public override LogicFileInfoData CreateFileInfo(LogicFileInfoData logicFileInfo, DbTransaction trans)
{
LogicFileInfoData result = (LogicFileInfoData)logicFileInfo.Clone();
DbCommand dbCmd = this.CreateFileInfoCommand;
GuidEntityWrapper <LogicFileInfoData> wrapper = Utils.CreateWrapperData <LogicFileInfoData>(result, true);
this.Adapter.SetParametersValue(dbCmd.Parameters, wrapper);
if (trans != null)
{
this.Database.ExecuteNonQuery(dbCmd, trans);
}
else
{
this.Database.ExecuteNonQuery(dbCmd);
}
return(result);
}
public override LogicFileInfoData FetchFileInfo(LogicFileInfoItemData fetchParam, DbTransaction trans)
{
LogicFileInfoData result = null;
DbCommand dbCmd = this.FetchFileInfoCommand;
this.Database.SetParameterValue(dbCmd, "p_logic_file_id", fetchParam.ID.ToString().ToUpper());
this.Database.SetParameterValue(dbCmd, "p_physical_file_id", fetchParam.PhysicalFileID.ToString().ToUpper());
if (fetchParam.Version > 0)
{
this.Database.SetParameterValue(dbCmd, "p_VERSION", fetchParam.Version);
}
this.Database.SetParameterValue(dbCmd, "p_with_physical_file", fetchParam.WithPhysicalFileInfo);
IDataReader reader = null;
if (trans != null)
{
reader = this.Database.ExecuteReader(dbCmd, trans);
}
else
{
reader = this.Database.ExecuteReader(dbCmd);
}
if (reader != null)
{
try
{
if (reader.Read())
{
result = new LogicFileInfoData();
FieldLookup looup = this.EntityFactory.CreateFieldLookup(reader);
this.Adapter.SetEntityValue(result, reader, looup);
if (fetchParam.WithPhysicalFileInfo && reader.NextResult())
{
this.EntityFactory.BuildEntityCollection(result.PhysicalFileInfos, reader);
}
}
}
finally
{
reader.Close();
}
}
return(result);
}
public FetchFileInfoResult FetchFileInfo(FetchFileInfoParameter fetchFileInfoParam)
{
FetchFileInfoResult result = new FetchFileInfoResult();
try
{
LogicFileResultItemDataCollection items = result.ExecuteResult;
foreach (LogicFileInfoItemData itemPara in fetchFileInfoParam.InputData)
{
LogicFileInfoData info = this.DataProvider.FetchFileInfo(itemPara, null);
LogicFileResultItemData itemResult = new LogicFileResultItemData();
itemResult.LogicFileInfo = info;
items.Add(itemResult);
}
}
catch (Exception e)
{
Utils.BuilderExecuteResult(result, e);
}
return(result);
}
private LogicFileInfoData CreateNewFile(OpenFileItemData itemParam, Guid userID, DbTransaction trans)
{
LogicFileInfoData result = new LogicFileInfoData();
Guid physcicalFileID = CombineGuid.NewComboGuid();
if (itemParam.FileID != Guid.Empty)
{
result.ID = itemParam.FileID;
}
else
{
result.ID = CombineGuid.NewComboGuid();
}
if (!string.IsNullOrEmpty(itemParam.ClientFileName))
{
result.LogicFileName = Path.GetFileName(itemParam.ClientFileName);
result.LogicFileExt = Path.GetExtension(itemParam.ClientFileName);
}
result.LogicFileStatus = LogicFileStatus.Normal;
result.IsReadOnly = false;
result.LatestPhysicalFileID = physcicalFileID;
result.CurrentUserID = userID;
this.DataProvider.CreateFileInfo(result, trans);
PhysicalFileInfoData fileData = new PhysicalFileInfoData();
fileData.ID = physcicalFileID;
fileData.LogicFileID = result.ID;
fileData.FileLength = 0;
fileData.Version = 1;
fileData.StoreModeID = FileStorageManager.GetCurrentStoreModeID(this.DataProvider);
this.DataProvider.CreatePhysicalFileInfo(fileData, trans);
result.PhysicalFileInfos.Add(fileData);
FileStorageManager.CreateNewFile(this.DataProvider, physcicalFileID, result.LogicFileExt);
return(result);
}
LogicFileInfoData IFileStorageProviderDataProvider.UpdateFileInfo(LogicFileInfoData updateFileInfo, IDbTransaction trans)
{
return(this.UpdateFileInfo(updateFileInfo, trans as DbTransaction));
}
LogicFileInfoData IFileStorageProviderDataProvider.CreateFileInfo(LogicFileInfoData logicFileInfo, IDbTransaction trans)
{
return(this.CreateFileInfo(logicFileInfo, trans as DbTransaction));
}
public abstract LogicFileInfoData UpdateFileInfo(LogicFileInfoData updateFileInfo, DbTransaction trans);
public abstract LogicFileInfoData CreateFileInfo(LogicFileInfoData logicFileInfo, DbTransaction trans);
protected virtual void ThumbImage(HttpContext context)
{
string fileName = this.FileID;
if (!string.IsNullOrEmpty(fileName))
{
int width = 0;
int height = 0;
GetImageSize(out width, out height);
Guid fileID = FileGuid;
SetResponseContentType(context);
SetResponseHeader(context);
Stream imageStream = null;
LogicFileInfoData fileInfo = FileManager.GetFileInfo(fileID);
//先看缓存目录里有没有
string thumbImageDirPath = context.Server.MapPath("~/ThumbImage");
string thumbImagePath = Path.Combine(thumbImageDirPath, string.Format("{0}_{1}_{2}{3}", FileGuid, width, height, fileInfo.LogicFileExt));
if (!Directory.Exists(thumbImageDirPath))
{
Directory.CreateDirectory(thumbImageDirPath);
}
if (File.Exists(thumbImagePath))
{
try
{
imageStream = File.OpenRead(thumbImagePath);
OutputStream(context, imageStream);
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (imageStream != null)
{
imageStream.Dispose();
}
}
}
else
{
try
{
using (Stream stream = FileManager.OpenReadFile(fileID))
{
imageStream = new MemoryStream();
ThumbImageViewer.CopyStream(imageStream, stream);
}
if (width <= 0 || height <= 0)
{
OutputStream(context, imageStream);
}
else
{
using (MemoryStream bufferOutput = new MemoryStream())
{
ThumbImageViewer.OutputImage(bufferOutput, imageStream, this.ClientFileID, width, height, img =>
{
//保存缩列图缓存
if (img != null)
{
try
{
img.Save(thumbImagePath);
}
catch (Exception ex)
{
throw ex;
}
}
});
if (bufferOutput.Length > 0)
{
bufferOutput.Position = 0;
OutputStream(context, bufferOutput);
}
}
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (imageStream != null)
{
imageStream.Dispose();
}
}
}
}
}
