public CheckFileInfo GetCheckFileInfo(WebDavAccessToken token)
{
var resource = _webDavManager.GetResource(token.FilePath);
var permissions = _webDavAuthorizationService.GetPermissions(ScpContext.User, token.FilePath);
var readOnly = permissions.HasFlag(WebDavPermissions.Write) == false || permissions.HasFlag(WebDavPermissions.OwaEdit) == false;
var cFileInfo = new CheckFileInfo
{
BaseFileName = resource == null?token.FilePath.Split('/').Last() : resource.DisplayName.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries).LastOrDefault(),
OwnerId = ScpContext.User.Login,
Size = resource == null ? 0 : resource.ContentLength,
Version = DateTime.Now.ToString("s"),
SupportsCoauth = true,
SupportsCobalt = true,
SupportsFolders = true,
SupportsLocks = true,
SupportsScenarioLinks = false,
SupportsSecureStore = false,
SupportsUpdate = true,
UserCanWrite = !readOnly,
ReadOnly = readOnly,
RestrictedWebViewOnly = false,
CloseButtonClosesWindow = true
};
if (resource != null)
{
cFileInfo.ClientUrl = _webDavManager.GetFileUrl(token.FilePath);
}
return(cFileInfo);
}
/// <summary>
/// Gets information about a file.
/// </summary>
/// <returns>Object with attributes according to the specification (https://msdn.microsoft.com/en-us/library/hh622920.aspx)</returns>
public virtual CheckFileInfo GetCheckFileInfo()
{
CheckFileInfo cfi = new CheckFileInfo();
string sha256 = "";
using (var sha = SHA256.Create())
{
using (var stream = File.GetReadStream())
{
byte[] checksum = sha.ComputeHash(stream);
sha256 = Convert.ToBase64String(checksum);
}
}
cfi.SHA256 = sha256;
cfi.BaseFileName = File.Name;
cfi.OwnerId = Login;
cfi.UserFriendlyName = Name;
cfi.Version = File.LastWriteTimeUtc.ToString("s");
cfi.SupportsCoauth = true;
cfi.SupportsFolders = true;
cfi.SupportsLocks = true;
cfi.SupportsScenarioLinks = false;
cfi.SupportsSecureStore = false;
cfi.SupportsUpdate = true;
cfi.UserCanWrite = true;
cfi.SupportsCobalt = IsCobaltSession;
lock (File)
{
cfi.Size = File.Exists ? File.Length : 0;
}
return(cfi);
}
public static CheckFileInfo GetCheckFileInfo(this IWopiFile file, ClaimsPrincipal principal, HostCapabilities capabilities)
{
CheckFileInfo CheckFileInfo = new CheckFileInfo();
if (principal != null)
{
CheckFileInfo.UserId = principal.FindFirst(ClaimTypes.NameIdentifier)?.Value;
CheckFileInfo.UserFriendlyName = principal.FindFirst(ClaimTypes.Name)?.Value;
WopiUserPermissions permissions = (WopiUserPermissions)Enum.Parse(typeof(WopiUserPermissions), principal.FindFirst(WopiClaimTypes.UserPermissions).Value);
CheckFileInfo.ReadOnly = permissions.HasFlag(WopiUserPermissions.ReadOnly);
CheckFileInfo.RestrictedWebViewOnly = permissions.HasFlag(WopiUserPermissions.RestrictedWebViewOnly);
CheckFileInfo.UserCanAttend = permissions.HasFlag(WopiUserPermissions.UserCanAttend);
CheckFileInfo.UserCanNotWriteRelative = permissions.HasFlag(WopiUserPermissions.UserCanNotWriteRelative);
CheckFileInfo.UserCanPresent = permissions.HasFlag(WopiUserPermissions.UserCanPresent);
CheckFileInfo.UserCanRename = permissions.HasFlag(WopiUserPermissions.UserCanRename);
CheckFileInfo.UserCanWrite = permissions.HasFlag(WopiUserPermissions.UserCanWrite);
CheckFileInfo.WebEditingDisabled = permissions.HasFlag(WopiUserPermissions.WebEditingDisabled);
}
else
{
CheckFileInfo.IsAnonymousUser = true;
}
CheckFileInfo.OwnerId = file.Owner;
// Set host capabilities
CheckFileInfo.SupportsCoauth = capabilities.SupportsCoauth;
CheckFileInfo.SupportsFolders = capabilities.SupportsFolders;
CheckFileInfo.SupportsLocks = capabilities.SupportsLocks;
CheckFileInfo.SupportsGetLock = capabilities.SupportsGetLock;
CheckFileInfo.SupportsExtendedLockLength = capabilities.SupportsExtendedLockLength;
CheckFileInfo.SupportsEcosystem = capabilities.SupportsEcosystem;
CheckFileInfo.SupportsGetFileWopiSrc = capabilities.SupportsGetFileWopiSrc;
CheckFileInfo.SupportedShareUrlTypes = capabilities.SupportedShareUrlTypes;
CheckFileInfo.SupportsScenarioLinks = capabilities.SupportsScenarioLinks;
CheckFileInfo.SupportsSecureStore = capabilities.SupportsSecureStore;
CheckFileInfo.SupportsUpdate = capabilities.SupportsUpdate;
CheckFileInfo.SupportsCobalt = capabilities.SupportsCobalt;
CheckFileInfo.SupportsRename = capabilities.SupportsRename;
CheckFileInfo.SupportsDeleteFile = capabilities.SupportsDeleteFile;
CheckFileInfo.SupportsUserInfo = capabilities.SupportsUserInfo;
CheckFileInfo.SupportsFileCreation = capabilities.SupportsFileCreation;
using (var stream = file.GetReadStream())
{
byte[] checksum = SHA.ComputeHash(stream);
CheckFileInfo.SHA256 = Convert.ToBase64String(checksum);
}
CheckFileInfo.BaseFileName = file.Name;
CheckFileInfo.FileExtension = "." + file.Extension.TrimStart('.');
CheckFileInfo.Version = file.LastWriteTimeUtc.ToString("s");
CheckFileInfo.LastModifiedTime = file.LastWriteTimeUtc.ToString("o");
CheckFileInfo.Size = file.Exists ? file.Length : 0;
return(CheckFileInfo);
}
public async Task <IActionResult> CheckFileInfo(string id, [FromQuery] string access_token)
{
try
{
Config.logger.LogDebug("CheckFileInfo: id=" + id);
if (string.IsNullOrEmpty(access_token))
{
Config.logger.LogError("status:500 accessToken is null");
return(StatusCode(500));
}
Dictionary <string, Object> token = AccessTokenVerifier.DecodeJWT(access_token);
Dictionary <string, string> user = (Dictionary <string, string>)token["user"];
Dictionary <string, string> metadata = (Dictionary <string, string>)token["metadata"];
if (!AccessTokenVerifier.VerifyAccessToken(id, (string)metadata["id"], (string)token["created"]))
{
Config.logger.LogError("status:500 accessToken is illegal");
return(StatusCode(500)); //access token is illegal
}
var sessionContext = Request.Headers["X-WOPI-SessionContext"];
string idToDownload = id;
string fileName = Config.Folder + "/" + metadata["id"] + "." + metadata["type"];
Session editSession = Session.GetSessionFromRedis(id);
if (editSession == null)
{
FilesService.DownloadFileFromDrive(idToDownload, fileName, user["authorization"]);
editSession = new Session(id, fileName);
editSession.SaveToRedis();
editSession.AddSessionToSetInRedis();
Config.logger.LogDebug("New session added to Redis for id=" + id);
}
if (!editSession.UserIsInSession(user["id"]))
{
Config.logger.LogDebug("add new user to session");
editSession.AddUser(user["id"], user["authorization"], user["permission"], user["name"]);
editSession.SaveToRedis();
Config.logger.LogDebug("Added user {0} to session {1}", user["id"], id);
}
CheckFileInfo checkFileInfo = editSession.GetCheckFileInfo(user["id"], user["name"], metadata["name"]);
return(Ok(checkFileInfo));
}
catch (Exception ex)
{
if (ex is DriveFileNotFoundException)
{
Config.logger.LogError("status:404 CheckFileInfo Drive Error" + ex.Message);
return(StatusCode(404));
}
else
{
Config.logger.LogError("status:500, CheckFileInfo Error:" + ex.Message);
return(StatusCode(500));
}
}
}
public CheckFileInfo GetFileInfo(string name)
{
var fileName = GetFileName(name);
FileInfo info = new FileInfo(fileName);
string sha256 = "";
using (FileStream stream = File.OpenRead(fileName))
using (var sha = SHA256.Create())
{
byte[] checksum = sha.ComputeHash(stream);
sha256 = Convert.ToBase64String(checksum);
}
var rv = new CheckFileInfo
{
BaseFileName = info.Name,
OwnerId = "admin",
Size = info.Length,
SHA256 = sha256,
Version = info.LastWriteTimeUtc.ToString("s")
};
return(rv);
}
/// <summary>
/// Returns a CheckFileInfo model according to https://wopi.readthedocs.io/projects/wopirest/en/latest/files/CheckFileInfo.html
/// </summary>
/// <param name="file">File properties of which should be returned.</param>
/// <param name="principal">A user object which the CheckFileInfo should be correlated with.</param>
/// <param name="capabilities">WOPI host capabilities</param>
/// <returns>CheckFileInfo model</returns>
public static CheckFileInfo GetCheckFileInfo(this IWopiFile file, ClaimsPrincipal principal, HostCapabilities capabilities)
{
if (file is null)
{
throw new ArgumentNullException(nameof(file));
}
if (capabilities is null)
{
throw new ArgumentNullException(nameof(capabilities));
}
var checkFileInfo = new CheckFileInfo();
if (principal is not null)
{
checkFileInfo.UserId = principal.FindFirst(ClaimTypes.NameIdentifier)?.Value.ToSafeIdentity();
checkFileInfo.UserFriendlyName = principal.FindFirst(ClaimTypes.Name)?.Value;
var permissions = (WopiUserPermissions)Enum.Parse(typeof(WopiUserPermissions), principal.FindFirst(WopiClaimTypes.USER_PERMISSIONS).Value);
checkFileInfo.ReadOnly = permissions.HasFlag(WopiUserPermissions.ReadOnly);
checkFileInfo.RestrictedWebViewOnly = permissions.HasFlag(WopiUserPermissions.RestrictedWebViewOnly);
checkFileInfo.UserCanAttend = permissions.HasFlag(WopiUserPermissions.UserCanAttend);
checkFileInfo.UserCanNotWriteRelative = permissions.HasFlag(WopiUserPermissions.UserCanNotWriteRelative);
checkFileInfo.UserCanPresent = permissions.HasFlag(WopiUserPermissions.UserCanPresent);
checkFileInfo.UserCanRename = permissions.HasFlag(WopiUserPermissions.UserCanRename);
checkFileInfo.UserCanWrite = permissions.HasFlag(WopiUserPermissions.UserCanWrite);
checkFileInfo.WebEditingDisabled = permissions.HasFlag(WopiUserPermissions.WebEditingDisabled);
}
else
{
checkFileInfo.IsAnonymousUser = true;
}
checkFileInfo.OwnerId = file.Owner.ToSafeIdentity();
// Set host capabilities
checkFileInfo.SupportsCoauth = capabilities.SupportsCoauth;
checkFileInfo.SupportsFolders = capabilities.SupportsFolders;
checkFileInfo.SupportsLocks = capabilities.SupportsLocks;
checkFileInfo.SupportsGetLock = capabilities.SupportsGetLock;
checkFileInfo.SupportsExtendedLockLength = capabilities.SupportsExtendedLockLength;
checkFileInfo.SupportsEcosystem = capabilities.SupportsEcosystem;
checkFileInfo.SupportsGetFileWopiSrc = capabilities.SupportsGetFileWopiSrc;
checkFileInfo.SupportedShareUrlTypes = capabilities.SupportedShareUrlTypes;
checkFileInfo.SupportsScenarioLinks = capabilities.SupportsScenarioLinks;
checkFileInfo.SupportsSecureStore = capabilities.SupportsSecureStore;
checkFileInfo.SupportsUpdate = capabilities.SupportsUpdate;
checkFileInfo.SupportsCobalt = capabilities.SupportsCobalt;
checkFileInfo.SupportsRename = capabilities.SupportsRename;
checkFileInfo.SupportsDeleteFile = capabilities.SupportsDeleteFile;
checkFileInfo.SupportsUserInfo = capabilities.SupportsUserInfo;
checkFileInfo.SupportsFileCreation = capabilities.SupportsFileCreation;
using (var stream = file.GetReadStream())
{
var checksum = Sha.ComputeHash(stream);
checkFileInfo.Sha256 = Convert.ToBase64String(checksum);
}
checkFileInfo.BaseFileName = file.Name;
checkFileInfo.FileExtension = "." + file.Extension.TrimStart('.');
checkFileInfo.Version = file.LastWriteTimeUtc.ToString("s", CultureInfo.InvariantCulture);
checkFileInfo.LastModifiedTime = file.LastWriteTimeUtc.ToString("o", CultureInfo.InvariantCulture);
checkFileInfo.Size = file.Exists ? file.Length : 0;
return(checkFileInfo);
}
/// <summary>
/// Get CheckFile Info
/// </summary>
/// <param name="file">FileInfo</param>
/// <param name="token">access_token</param>
/// <param name="isShare">Is Share file</param>
/// <returns>Json</returns>
public string GetCheckFileInfo(FileInfo file, string token, bool isShare)
{
try
{
CheckFileInfo checkFileInfo = new CheckFileInfo();
bool onlyRead = false;
if (isShare)
{
onlyRead = true;
checkFileInfo.UserId = "Anonymous";
checkFileInfo.OwnerId = "Anonymous";
checkFileInfo.UserFriendlyName = "Anonymous";
}
else
{
IEASAPIHelper eASAPI = new EASAPIHelper();
var userInfo = eASAPI.UserGetPost(token);
// History file or No edit permission
if (!string.IsNullOrEmpty(CommonHelper.GetDocRev(token)) || !eASAPI.IsCanEditFile(token) || (userInfo.Freezestatus.HasValue && userInfo.Freezestatus.Value))
{
onlyRead = true;
}
else
{
// Locked Info
try
{
var lockInfo = eASAPI.AutolockGetlockinfoPost(token);
// Locked & Not me
if ((lockInfo.Islocked.HasValue && lockInfo.Islocked.Value) && (userInfo.Account != lockInfo.Lockeraccount))
{
onlyRead = true;
}
}
catch
{
onlyRead = true;
}
}
// User Info
try
{
checkFileInfo.UserId = userInfo.Account;
checkFileInfo.OwnerId = userInfo.Userid;
checkFileInfo.UserFriendlyName = userInfo.Name;
}
catch
{
checkFileInfo.UserId = "Anonymous";
checkFileInfo.OwnerId = "Anonymous";
checkFileInfo.UserFriendlyName = "Anonymous";
}
}
// Old Office file
string fileExt = Path.GetExtension(file.Name).ToLower();
if (".doc".Equals(fileExt) || ".xls".Equals(fileExt) || ".ppt".Equals(fileExt))
{
onlyRead = true;
}
string fileName = file.Name;
if (fileName.Contains("\\"))
{
fileName = fileName.Split("\\").LastOrDefault();
}
// Basic info
checkFileInfo.BaseFileName = fileName;
checkFileInfo.Version = file.LastWriteTimeUtc.ToString("s", CultureInfo.InvariantCulture);
checkFileInfo.Size = file.Length;
if (".doc".Equals(fileExt) || ".docx".Equals(fileExt))
{
// SHA256
try
{
using (FileStream stream = file.OpenRead())
{
using (var sha = SHA256.Create())
{
checkFileInfo.SHA256 = Convert.ToBase64String(sha.ComputeHash(stream));
}
stream.Dispose();
}
}
catch
{
checkFileInfo.SHA256 = string.Empty;
}
}
// File attribute
checkFileInfo.ReadOnly = onlyRead;
checkFileInfo.UserCanWrite = !onlyRead;
checkFileInfo.UserCanNotWriteRelative = onlyRead;
checkFileInfo.SupportsLocks = !onlyRead;
checkFileInfo.SupportsGetLock = !onlyRead;
checkFileInfo.SupportsUpdate = !onlyRead;
checkFileInfo.ProtectInClient = onlyRead;
checkFileInfo.RestrictedWebViewOnly = onlyRead;
checkFileInfo.DisablePrint = true;
checkFileInfo.CopyPasteRestrictions = "BlockAll";
return(JsonConvert.SerializeObject(checkFileInfo));
}
catch (Exception ex)
{
throw ex;
}
}
