public override byte[] ToBytes()
{
return(TLUtils.Combine(
TLUtils.SignatureToBytes(Signature),
FileToken.ToBytes(),
RequestToken.ToBytes()));
}
public FileResult GetZipFileToken(List <FileToken> fileTokeList)
{
var Result = new FileResult();
var systemFiles = new SystemFiles();
try
{
if (fileTokeList == null || !fileTokeList.Any())
{
throw new Exception("参数集合为空");
}
var token = this.GenerateToken(fileTokeList[0]);
cacheManager.Set(token, string.Join(",", fileTokeList.Select(s => s.FileId)));
var tokenObj = new FileToken()
{
Url = $"{AppConfig.FileCenterDomain}/file/GetZipFile?token={HttpUtility.UrlEncode(token)}"
};
Result.Status = "1";
Result.Message = "SUCCESS";
Result.Result = JsonConvert.SerializeObject(tokenObj);
return(Result);
}
catch (Exception er)
{
Result.Status = "0";
Result.Message = er.Message;
return(Result);
}
}
public string Encode(FileToken token)
{
var pseudoIdBys = NetBitConverter.GetBytes(token.PseudoId);
var fileIdBys = NetBitConverter.GetBytes(token.FileId);
var ownerIdBys = NetBitConverter.GetBytes(token.FileOwnerId);
var mimeBys = NetBitConverter.GetBytes(token.MimeId);
var expireTimeBys = GetBytes(token.ExpireTime);
var fileCreateTimeBys = GetBytes(token.FileCreateTime);
var lstLen = 1 + pseudoIdBys.Length + fileIdBys.Length + ownerIdBys.Length + mimeBys.Length + expireTimeBys.Length + fileCreateTimeBys.Length;
var mdatLst = new List <byte>(lstLen);
mdatLst.Add(CurrentVersion);
mdatLst.AddRange(pseudoIdBys);
mdatLst.AddRange(fileIdBys);
mdatLst.AddRange(ownerIdBys);
mdatLst.AddRange(mimeBys);
mdatLst.AddRange(expireTimeBys);
mdatLst.AddRange(fileCreateTimeBys);
var mdatBys = mdatLst.ToArray();
//签名
var signBys = ArrayUtil.Addition(_appSecretBytes, mdatBys);
var hashBys = Md5(signBys);
//编码成字符串
var encBys = ArrayUtil.Addition(hashBys, mdatBys);
return(_urlDataCodec.Encode(encBys));
}
static void AssertExpectations(string dir, FileToken token)
{
var expectedTokens = new FileToken[]
{
new FileInfo($"{dir}/ref-one.md"),
new FileInfo($"{dir}/ref-two.md"),
new FileInfo($"{dir}/ref-(three).md"),
new FileInfo($"{dir}/ref-four.md"),
new FileInfo($"{dir}/ref-five.md"),
new FileInfo($"{dir}/subdir/ref-six.md"),
new FileInfo($"{dir}/ref-seven.md"),
new FileInfo($"{dir}/image-one.svg"),
new FileInfo($"{dir}/image-two.jpeg"),
new FileInfo($"{dir}/image-three.jpg"),
new FileInfo($"{dir}/image-four.png"),
new FileInfo($"{dir}/media/context/image-five.png"),
new FileInfo($"{dir}/media/tbl-image.png"),
new FileInfo($"{dir}/media/more.jpg"),
new FileInfo($"{dir}/media/serious.png"),
new FileInfo($"{dir}/media/spaces.jpg"),
new FileInfo($"{dir}/media/index/link.png"),
new FileInfo($"{dir}/media/index/linkage.png"),
new FileInfo($"{dir}/media/context/context/seriously-why.png"),
new FileInfo($"{dir}/grandparent/media/csharp logo.png")
};
// Check header metadata
Assert.NotEqual(default, token.Header);
public void AddValidationErrors(CustomValidationContext context)
{
if (!UseGravatarProfilePicture && FileToken.IsNullOrEmpty())
{
throw new ArgumentNullException(nameof(FileToken));
}
}
public override byte[] ToBytes()
{
return(TLUtils.Combine(
TLUtils.SignatureToBytes(Signature),
FileToken.ToBytes(),
Offset.ToBytes(),
Limit.ToBytes()));
}
public Task <string> CreateFileToken(string fileName)
{
FileToken token = new FileToken(TYPE, _fileStoreName);
token.Path = fileName;
return(Task.FromResult(token.ToString()));
}
public async Task <bool> Exists(string fileToken)
{
FileToken token = FileToken.Parse(fileToken, _fileStoreName);
using (var c = GetNewClient())
{
return(await c.FileExistsAsync(token.Path));
}
}
public Task <string> CreateFileToken(string fileName)
{
var now = DateTime.Now;
FileToken token = new FileToken(TYPE, _fileStoreName);
token.Path = Path.Combine(now.Year.ToString(), now.Month.ToString("00"), now.Day.ToString("00"),
fileName).GetFtpPath();
return(Task.FromResult(token.ToString()));
}
internal static IRootScope Convert(FileToken fileToken)
{
var result = ConvertToWeak(fileToken);
var context = TransformerExtensions.NewConversionContext();
var converted = result.Convert(context);
return(converted);
}
public Task Delete(string fileToken)
{
var absolutePath = GetAbsolutePath(FileToken.Parse(fileToken, _fileStoreName));
if (System.IO.File.Exists(absolutePath))
{
System.IO.File.Delete(absolutePath);
}
return(Task.CompletedTask);
}
public Task Delete(string fileToken)
{
var token = FileToken.Parse(fileToken, _fileStoreName);
if (System.IO.File.Exists(token.Path))
{
System.IO.File.Delete(token.Path);
}
return(Task.CompletedTask);
}
public async Task <Stream> OpenRead(string fileToken)
{
var token = FileToken.Parse(fileToken, _fileStoreName);
if (!await Exists(token))
{
throw new FileNotFoundException();
}
return(new FileStream(GetAbsolutePath(FileToken.Parse(fileToken, _fileStoreName)), FileMode.Open));
}
public Task <Stream> OpenWrite(string token)
{
string localPath = GetAbsolutePath(FileToken.Parse(token, _fileStoreName));
string dir = Path.GetDirectoryName(localPath);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
return(Task.FromResult((Stream) new FileStream(localPath, FileMode.Create)));
}
public virtual void CollectSettings()
{
(this.Task.Executor as TaskSettings).FileTokens.Clear();
for (int i = 0; i < dataGridView.RowCount; i++)
{
if (dataGridView.Rows[i].Cells[0].Value == null ||
dataGridView.Rows[i].Cells[1].Value == null)
{
continue;
}
FileToken token = new FileToken
{
Token = dataGridView.Rows[i].Cells[0].Value.ToString(),
Path = dataGridView.Rows[i].Cells[1].Value.ToString(),
Encoding = dataGridView.Rows[i].Cells[2].Value.ToString() == "ANSI" ? EncodingType.ANSI : EncodingType.UTF8
};
switch (dataGridView.Rows[i].Cells[3].Value.ToString())
{
// Random
case "Random":
{
token.Type = FileTokenType.ReadRandomLine;
break;
}
// One by One
case "One by One":
{
token.Type = FileTokenType.ReadLineAfterLine;
break;
}
// One line/Site
case "One line/Site":
{
token.Type = FileTokenType.ReadOneLinePerSite;
break;
}
// Random line/Site
case "Random line/Site":
{
token.Type = FileTokenType.ReadRandomLinePerSite;
break;
}
}
(this.Task.Executor as TaskSettings).FileTokens.Add(token);
}
}
public async Task Delete(string fileToken)
{
FileToken token = FileToken.Parse(fileToken, _fileStoreName);
using (var client = GetNewClient())
{
if (await client.FileExistsAsync(token.Path))
{
await client.DeleteFileAsync(token.Path);
}
}
}
public static bool TryDecode(this IFileTokenCodec codec, string tokenStr, out FileToken token)
{
try
{
token = codec.Decode(tokenStr);
return(true);
}
catch
{
token = null;
return(false);
}
}
public async Task <Stream> OpenWrite(string token)
{
var fileToken = FileToken.Parse(token, _fileStoreName);
string dir = fileToken.Path.GetFtpDirectoryName();
var client = GetNewClient();
if (!await client.DirectoryExistsAsync(dir))
{
await client.CreateDirectoryAsync(dir);
}
return(await _client.OpenFileWriteStreamAsync(fileToken.Path));
}
public async Task <Stream> OpenRead(string token)
{
var fileToken = FileToken.Parse(token, _fileStoreName);
var client = GetNewClient();
string dir = fileToken.Path.GetFtpDirectoryName();
if (!client.DirectoryExists(dir))
{
client.CreateDirectory(dir);
}
return(new FtpStream(client, await client.OpenReadAsync(fileToken.Path)));
}
public IFileStore GetFileStoreFromFileToken(string fileToken)
{
var storeName = FileToken.ParseName(fileToken);
var fileStoreConfig = _config.Stores.FirstOrDefault(x =>
string.Compare(x.Name, storeName, StringComparison.CurrentCultureIgnoreCase) == 0);
if (fileStoreConfig == null)
{
throw new ArgumentException($"No File store named '{storeName}'");
}
return(GetFileStore(fileStoreConfig));
}
public async Task <DataResult <UploadResultData> > UploadBlockAsync(FileOwnerTypeId foti, Stream file, string fileName, string hash, int periodMinute, int curBlock, int blockTotal)
{
try
{
var fileInfo = await _storageSvce.CreateFileBlockAsync(foti, hash, file, fileName, periodMinute, curBlock, blockTotal);
var etAddMinute = periodMinute > 0 ? periodMinute : 52560000; //最大100年
var fToken = new FileToken
{
PseudoId = fileInfo.PseudoId,
FileId = fileInfo.File.Id,
FileOwnerId = fileInfo.Owner.Id,
MimeId = (uint)fileInfo.File.MimeId,
FileCreateTime = fileInfo.File.CreateTime,
ExpireTime = DateTime.Now.AddMinutes(etAddMinute)
};
var fTokenStr = _fileTokenCodec.Encode(fToken);
var urDat = new UploadResultData
{
FileToken = fTokenStr,
Url = $"{GetCurrentScheme()}://{fileInfo.Server.Host}/files/{fTokenStr}",
Name = fileInfo.Owner.Name,
Length = fileInfo.File.Length
};
var signLst = new[]
{
new KeyValuePair <string, object>(nameof(UploadResultData.FileToken), urDat.FileToken),
new KeyValuePair <string, object>(nameof(UploadResultData.Url), urDat.Url),
new KeyValuePair <string, object>(nameof(UploadResultData.Name), urDat.Name),
new KeyValuePair <string, object>(nameof(UploadResultData.Length), urDat.Length)
};
urDat.Sign = _appSecretSigner.Sign(signLst);
return(new DataResult <UploadResultData>(ResultErrorCodes.Success)
{
Data = urDat
});
}
catch (FileNotFoundException)
{
return(new DataResult <UploadResultData>(100, "文件不存在，请直接上传"));
}
catch (Exception ex)
{
_logger.LogError(ex.ToString());
return(new DataResult <UploadResultData>(ResultErrorCodes.SystemError, ex.Message));
}
}
private bool DecodeAndCheckFileToken <TData>(string fileTokenStr, out FileToken fToken, out DataResult <TData> errorResult) where TData : class
{
errorResult = null;
if (!_fileTokenCodec.TryDecode(fileTokenStr, out fToken))
{
errorResult = new DataResult <TData>(ResultErrorCodes.ArgumentBad, "bad fileToken");
return(false);
}
if (fToken.IsExpired)
{
errorResult = new DataResult <TData>(100, "fileToken expired");
return(false);
}
return(true);
}
internal static WeakRootScope ConvertToWeak(FileToken fileToken)
{
var elementMatchingContest = new ElementMatchingContext();
var scopePopulators = elementMatchingContest.ParseFile(fileToken);
var problem = new Tpn.TypeProblem2(new WeakScopeConverter(), scopePopulators, _ => { });
var populateScopeContex = new SetUpContext(problem.builder);
var referanceResolver = scopePopulators.Run(problem.ModuleRoot, populateScopeContex).Resolve;
var solution = problem.Solve();
var res = referanceResolver.Run(solution, new List <Tpn.ITypeProblemNode>());
return(res.GetValue());
}
/// <summary>
/// Create single-use file transfer token
/// </summary>
/// <param name="resource">resource</param>
/// <returns>ApiResultFileToken</returns>
public ApiResultFileToken CreateFileToken(FileToken resource)
{
// verify the required parameter 'resource' is set
if (resource == null)
{
throw new ApiException(400, "Missing required parameter 'resource' when calling CreateFileToken");
}
var path = "/fileTokens";
path = path.Replace("{format}", "json");
var queryParams = new Dictionary <String, String>();
var headerParams = new Dictionary <String, String>();
var formParams = new Dictionary <String, String>();
var fileParams = new Dictionary <String, FileParameter>();
String postBody = null;
postBody = ApiClient.Serialize(resource); // http body (model) parameter
// authentication setting, if any
String[] authSettings = new String[] { "FortifyToken" };
// make the HTTP request
IRestResponse response = (IRestResponse)ApiClient.CallApi(path, Method.POST, queryParams, postBody, headerParams, formParams, fileParams, authSettings);
if (((int)response.StatusCode) >= 400)
{
throw new ApiException((int)response.StatusCode, "Error calling CreateFileToken: " + response.Content, response.Content);
}
else if (((int)response.StatusCode) == 0)
{
throw new ApiException((int)response.StatusCode, "Error calling CreateFileToken: " + response.ErrorMessage, response.ErrorMessage);
}
return((ApiResultFileToken)ApiClient.Deserialize(response.Content, typeof(ApiResultFileToken), response.Headers));
}
private Task <bool> Exists(FileToken fileToken)
{
return(Task.FromResult(System.IO.File.Exists(GetAbsolutePath(fileToken))));
}
private string GetAbsolutePath(FileToken token)
{
return(Path.Combine(_basePath, token.Path));
}
public static async ValueTask InitializeAsync(
this FileToken token,
Options options,
string destination = null)
{
if (token.FileType == FileType.Markdown ||
token.FileType == FileType.Yaml)
{
var found = await FileTokenCacheUtility.TryFindCachedVersionAsync(token, options, destination);
if (!found)
{
var lines = await File.ReadAllLinesAsync(token.FilePath);
var dir = token.DirectoryName;
var type = token.FileType;
if (type == FileType.Markdown && Metadata.TryParse(lines, out var metadata))
{
token.Header = metadata;
}
foreach (var(tokenType, tokenValue, lineNumber) in
lines.SelectMany((line, lineNumber) => FindAllTokensInLine(line, lineNumber + 1, TokenExpressions.FileTypeToExpressionMap[type]))
.Where(tuple => !string.IsNullOrEmpty(tuple.Item2)))
{
if (tokenType == TokenType.CodeFence)
{
token.CodeFenceSlugs[lineNumber] = tokenValue;
continue;
}
if (tokenType == TokenType.Xref)
{
token.Xrefs.Add(tokenValue);
continue;
}
if (tokenType == TokenType.Unrecognizable)
{
continue;
}
var(isFound, fullPath) = await FileFinder.TryFindFileAsync(options, dir, tokenValue);
if (isFound && !string.IsNullOrWhiteSpace(fullPath))
{
var file = new FileInfo(fullPath.NormalizePathDelimitors());
switch (file.GetFileType())
{
case FileType.Image:
token.ImagesReferenced.Add(file.FullName);
break;
case FileType.Markdown:
token.TopicsReferenced.Add(file.FullName);
break;
}
}
}
await FileTokenCacheUtility.CacheTokenAsync(token, options, destination);
}
}
}
public Task <string> GetFileName(string fileToken)
{
FileToken token = FileToken.Parse(fileToken, _fileStoreName);
return(Task.FromResult(token.Path.GetFtpFileName()));
}
public string Encode(FileToken token)
{
throw new NotImplementedException();
}
private string GenerateToken(FileToken fileToken)
{
var token = rsaManager.RSAEncrypt(File.ReadAllText(AppConfig.PublicKeyFilePath), $"{fileToken.Username + fileToken.Password + fileToken.FileId }");
return(token);
}
