public async Task Read_TextFileWithoutHeaders_ReturnsFileDataWithCustomHeaders()
{
var parseOptions = new FileParseOptionsDto()
{
FullName = TAB_TEXTFILE_PATH,
Delimiter = "\t",
HasHeaders = false
};
var expectedData = new FileDataDto()
{
FullName = TAB_TEXTFILE_PATH,
Delimiter = "\t",
Headers = new List <string>()
{
"col_0", "col_1", "col_2"
},
Rows = new List <string[]>()
{
new string[] { "Name", "Site", "Email" },
new string[] { "Betty J. Brown", "OEMJobs.com", "*****@*****.**" },
new string[] { "John D. Ginter", "keepclicker.com", "*****@*****.**" },
new string[] { "Roger I. Clinton", "tastrons.com", "*****@*****.**" }
}
};
var resultData = await _fileProcessor.Read(parseOptions);
Assert.IsTrue(IsFileDataDtoEquals(resultData, expectedData));
}
public Task <FileDataDto> SaveAsync(FileDataDto value)
{
var rightMethodInfo = GetType().GetMethod(nameof(SaveAsync), new Type[] { typeof(string), typeof(byte[]) });
var wrongMethodInfo = GetType().GetMethod(nameof(SaveAsync), new Type[] { typeof(FileDataDto) });
throw new NotSupportedException($"Use {rightMethodInfo} instead of {wrongMethodInfo}");
}
public IActionResult UploadVideo(FileDataDto fileDataDto)
{
var file = Request.Form.Files["FileData"];
var id = string.Empty;
string[] mimeTypes = new[] { "video/mp4", "video/webm" };
if (mimeTypes.Contains(file.ContentType))
{
var fileData = new FileData()
{
ContentType = file.ContentType,
Author = User.Identities.First().Name,
TagsArray = fileDataDto.Tags?.Split(DELIMITER),
Hero = fileDataDto.Hero
};
using (var ms = new MemoryStream())
{
file.CopyTo(ms);
var fileBytes = ms.ToArray();
var parsedContentDisposition = ContentDispositionHeaderValue.Parse(file.ContentDisposition);
fileData.FileName = parsedContentDisposition.FileName.ToString().Trim('"');
fileData.FileContents = fileBytes;
}
id = _videoService.AddAsync(fileData).Result;
}
return(Ok(id));
}
private bool IsFileDataDtoEquals(FileDataDto first, FileDataDto second)
{
if (first == null && second == null)
{
return(true);
}
if (first == null || second == null)
{
return(false);
}
if (first.FullName != second.FullName ||
first.Delimiter != second.Delimiter ||
!first.Headers.SequenceEqual(second.Headers) ||
first.Rows.Count != second.Rows.Count)
{
return(false);
}
for (int index = 0; index < first.Rows.Count; index++)
{
if (!first.Rows[index].SequenceEqual(second.Rows[index]))
{
return(false);
}
}
return(true);
}
public virtual bool UploadFileData(FileDataDto vm, out FileDataParamDto fileDataParam)
{
bool result = false;
fileDataParam = null;
UserInfo user = SessionUtils.UserInfo;
if (vm != null && user.File.OpenType == FileOpenType.Write && user.File.Stream != null)
{
if (vm.Data != null && vm.Data.Length > 0 && vm.Length >= vm.Data.Length)
{
user.File.Stream.Seek(vm.Index, SeekOrigin.Begin);
user.File.Stream.Write(vm.Data, 0, vm.Length);
user.File.Stream.Flush();
}
user.File.Position = user.File.Stream.Position;
fileDataParam = new FileDataParamDto()
{
Index = user.File.Position,
Size = ConfigUtils.MAX_FILE_DATA_SIZE
};
result = true;
}
return(result);
}
public async Task UpdateData_InvalidDto_ThrowValidationException(FileDataDto value)
{
var fileService = CreateFileService(TEST_ROOT_FOLDER_PATH);
Func <Task> act = () => fileService.UpdateData(value);
await Assert.ThrowsExceptionAsync <ValidationException>(act);
}
public async Task UpdateData(FileDataDto fileData)
{
FileDataDtoValidator.ValidateAndThrow(fileData);
CheckRootPath(fileData.FullName);
var fileProcessor = GetFileProcessor(fileData.FullName);
await fileProcessor.Update(fileData);
}
public async Task Update_NonexistentTextFile_ThrowFileNotFoundException()
{
var fileData = new FileDataDto()
{
FullName = Guid.NewGuid().ToString(),
Delimiter = " ",
};
Func <Task> act = () => _fileProcessor.Update(fileData);
await Assert.ThrowsExceptionAsync <FileNotFoundException>(act);
}
public async Task Update_TextFile_OverwriteFileAndReturnsTask()
{
string tempFile = Path.Combine(Path.GetTempPath(), $"temp_file_{Guid.NewGuid().ToString()}.txt");
File.WriteAllText(tempFile, string.Empty);
var firstDataToWrite = new FileDataDto()
{
FullName = tempFile,
Delimiter = "\t",
Headers = new List <string>()
{
"1", "2"
},
Rows = new List <string[]>()
{
new string[] { "A", "B" }
}
};
var secondDataToWrite = new FileDataDto()
{
FullName = tempFile,
Delimiter = "\t",
Headers = new List <string>()
{
"COL_1", "COL_2"
},
Rows = new List <string[]>()
{
new string[] { "A", "B" },
new string[] { "A1", "B1" }
}
};
var parseOptions = new FileParseOptionsDto()
{
FullName = tempFile,
Delimiter = "\t",
HasHeaders = true
};
await _fileProcessor.Update(firstDataToWrite);
await _fileProcessor.Update(secondDataToWrite);
var resultData = await _fileProcessor.Read(parseOptions);
File.Delete(tempFile);
Assert.IsTrue(IsFileDataDtoEquals(resultData, secondDataToWrite));
}
public ActionResult UploadFileData(FileDataDto vm)
{
if (vm != null && this.UserInfo.File.OpenType == FileOpenType.Write)
{
FileDataParamDto fileDataParam = null;
var fileService = this.GetService <IFileService>();
if (fileService.UploadFileData(vm, out fileDataParam))
{
return(Success(fileDataParam));
}
}
return(Error());
}
public async Task UpdateData_InvalidRootPath_ThrowBusinessLogicException()
{
var fileData = new FileDataDto()
{
FullName = @"C:\text.txt",
Headers = new List <string>()
{
"test"
}
};
var fileService = CreateFileService(TEST_ROOT_FOLDER_PATH);
Func <Task> act = () => fileService.UpdateData(fileData);
await Assert.ThrowsExceptionAsync <BusinessLogicException>(act);
}
public async Task Update(FileDataDto fileData)
{
CheckFileExist(fileData.FullName);
var strBuilder = new StringBuilder();
strBuilder.AppendLine(string.Join(fileData.Delimiter, fileData.Headers));
foreach (var row in fileData.Rows)
{
strBuilder.AppendLine(string.Join(fileData.Delimiter, row));
}
using (StreamWriter writer = new StreamWriter(fileData.FullName, false, Encoding.Default))
{
await writer.WriteAsync(strBuilder.ToString());
}
}
public async Task Read_EmptyTextFile_ReturnsEmptyFileData()
{
var parseOptions = new FileParseOptionsDto()
{
FullName = EMPTY_TEXTFILE_PATH,
Delimiter = " ",
HasHeaders = false
};
var expectedData = new FileDataDto()
{
FullName = EMPTY_TEXTFILE_PATH,
Delimiter = " "
};
var resultData = await _fileProcessor.Read(parseOptions);
Assert.IsTrue(IsFileDataDtoEquals(resultData, expectedData));
}
public async Task UpdateData_ValidFile_UpdateCalledOnFileProcessor()
{
var fileData = new FileDataDto()
{
FullName = $"{TEST_ROOT_FOLDER_PATH}\\text.txt",
Headers = new List <string>()
{
"test"
}
};
var fileProcFactory = new Mock <IFileProcessorFactory>();
var fileProcessor = new Mock <IFileProcessor>();
fileProcFactory.Setup(x => x.Create("txt")).Returns(fileProcessor.Object);
var fileService = CreateFileService(TEST_ROOT_FOLDER_PATH, fileProcFactory.Object);
await fileService.UpdateData(fileData);
fileProcessor.Verify(x => x.Update(fileData), Times.Once());
}
public async Task <FileDataDto> Read(FileParseOptionsDto parseOptions)
{
CheckFileExist(parseOptions.FullName);
var result = new FileDataDto()
{
FullName = parseOptions.FullName,
Delimiter = parseOptions.Delimiter
};
using (var stream = new FileStream(parseOptions.FullName, FileMode.Open, FileAccess.Read, FileShare.Read, DefaultBufferSize, DefaultOptions))
using (var reader = new StreamReader(stream, Encoding.Default))
{
string line;
while ((line = await reader.ReadLineAsync()) != null)
{
result.Rows.Add(line.Split(new string[] { parseOptions.Delimiter }, StringSplitOptions.None));
}
}
if (result.Rows.Count == 0)
{
return(result);
}
if (parseOptions.HasHeaders)
{
result.Headers.AddRange(result.Rows[0]);
result.Rows.RemoveAt(0);
}
else
{
var maxColumnsCount = result.Rows.Max(x => x.Length);
result.Headers.AddRange(Enumerable.Range(0, maxColumnsCount).Select(x => $"col_{x}"));
}
return(result);
}
public virtual FileDataDto GetFileData(FileDataParamDto vm)
{
FileDataDto m = null;
UserInfo user = SessionUtils.UserInfo;
if (user != null && vm != null && user.File.OpenType == FileOpenType.Read && user.File.Stream != null)
{
user.File.Stream.Seek(vm.Index, SeekOrigin.Begin);
m = new FileDataDto()
{
Index = vm.Index
};
long len = user.File.Stream.Length - user.File.Position;
if (vm.Size > len)
{
vm.Size = Convert.ToInt32(len);
}
m.Data = new byte[vm.Size];
m.Length = user.File.Stream.Read(m.Data, 0, vm.Size);
}
return(m);
}
public async Task GetData_ValidFile_ReturnsFileData()
{
var parseOptions = new FileParseOptionsDto()
{
FullName = $"{TEST_ROOT_FOLDER_PATH}\\text.txt"
};
var expectedData = new FileDataDto()
{
FullName = $"{TEST_ROOT_FOLDER_PATH}\\text.txt"
};
var fileProcFactory = new Mock <IFileProcessorFactory>();
var fileProcessor = new Mock <IFileProcessor>();
fileProcessor.Setup(x => x.Read(parseOptions)).Returns(Task.FromResult(expectedData));
fileProcFactory.Setup(x => x.Create("txt")).Returns(fileProcessor.Object);
var fileService = CreateFileService(TEST_ROOT_FOLDER_PATH, fileProcFactory.Object);
var resultFileData = await fileService.GetData(parseOptions);
Assert.ReferenceEquals(resultFileData, expectedData);
}
public virtual bool GetFile(FileInfoDto m, string saveFullDirectory, string name, FilePositionCallback call = null)
{
bool result = false;
bool isopen = false;
try
{
if (m != null && m.Type == FileInfoType.File && !string.IsNullOrEmpty(saveFullDirectory) && this.Client.IsLogin)
{
if (!Directory.Exists(saveFullDirectory))
{
Directory.CreateDirectory(saveFullDirectory);
}
if (this.Client.Host == "127.0.0.1" || this.Client.Host == "localhost")
{
result = this.GetLocalFile(m, saveFullDirectory, call);
}
else
{
long position = 0;
this.OnFilePositionCallback(call, m.Length, position);
var fs = this.CreateFile(m, saveFullDirectory, name, out position);
if (m.Length == position && fs == null)
{
this.OnFilePositionCallback(call, m.Length, position);
result = true;
}
else if (fs != null)
{
using (fs)
{
isopen = this.Client.Request <bool, int>(MsgCmd.OpenFile, m.Id);
if (isopen)
{
FileDataParamDto getDto = new FileDataParamDto();
while (position < m.Length)
{
bool isContinue = this.OnFilePositionCallback(call, m.Length, position);
getDto.Index = position;
getDto.Size = MAX_FILE_DATA_SIZE;
FileDataDto dataDto = this.Client.Request <FileDataDto, FileDataParamDto>(MsgCmd.GetFileData, getDto);
if (dataDto != null && isContinue)
{
fs.Seek(position, SeekOrigin.Begin);
if (dataDto.Length > 0 && dataDto.Data != null && dataDto.Length >= dataDto.Data.Length)
{
fs.Write(dataDto.Data, 0, dataDto.Length);
fs.Flush();
}
position = position + dataDto.Length;
}
else
{
break;
}
}
this.Client.Request(MsgCmd.CloseFile);
string saveFile = Utils.Combine(saveFullDirectory, m.Name);
string tempFile = saveFile + FILE_TEMP_SUFFIX;
string indexFile = saveFile + FILE_INDEX_SUFFIX;
File.WriteAllText(indexFile, position.ToString() + " " + JsonUtils.Serialize(m), Encoding.UTF8);
fs.Close();
if (position >= m.Length)
{
this.OnFilePositionCallback(call, m.Length, position);
if (File.Exists(saveFile))
{
File.Delete(saveFile);
}
File.Move(tempFile, Utils.Combine(saveFullDirectory, name));
File.Delete(indexFile);
result = true;
}
}
}
}
}
}
}
catch (Exception ex)
{
if (isopen)
{
this.Client.Request(MsgCmd.CloseFile);
}
LogUtils.Error("【FileInfoClient.GetFile】", ex);
}
return(result);
}
public virtual bool SendFile(string localFullFileName, string remoteDirectory, string remoteName, FilePositionCallback call = null)
{
bool result = false;
try
{
if (!string.IsNullOrEmpty(localFullFileName) && !string.IsNullOrEmpty(remoteName) &&
File.Exists(localFullFileName) && this.Client.IsLogin)
{
var localinfo = new FileInfo(localFullFileName);
this.OnFilePositionCallback(call, localinfo.Length, 0);
if (this.Client.Host == "127.0.0.1" || this.Client.Host == "localhost")
{
result = this.AddFileInfo(localinfo, remoteDirectory, remoteName);
this.OnFilePositionCallback(call, localinfo.Length, localinfo.Length);
}
else
{
using (var fs = File.OpenRead(localFullFileName))
{
long fileLength = fs.Length;
CreateFileParamDto createDto = new CreateFileParamDto()
{
Directory = remoteDirectory,
Name = remoteName,
Length = localinfo.Length,
CreationTime = localinfo.CreationTime,
LastWriteTime = localinfo.LastAccessTime
};
var getDto = this.Client.Request <FileDataParamDto, CreateFileParamDto>(MsgCmd.CreateFile, createDto);
FileDataDto dataDto = new FileDataDto();
if (getDto != null)
{
while (getDto.Index < fileLength)
{
dataDto.Index = getDto.Index;
int size = getDto.Size;
long temp = fileLength - dataDto.Index;
if (temp < size)
{
size = Convert.ToInt32(temp);
}
byte[] buffer = new byte[size];
fs.Seek(dataDto.Index, SeekOrigin.Begin);
dataDto.Length = fs.Read(buffer, 0, buffer.Length);
dataDto.Data = buffer;
getDto = this.Client.Request <FileDataParamDto, FileDataDto>(MsgCmd.UploadFileData, dataDto);
bool isContinue = this.OnFilePositionCallback(call, fileLength, dataDto.Index);
if (getDto == null || !isContinue)
{
break;
}
}
this.Client.Request(MsgCmd.CreateFileCompleted);
if (getDto != null && getDto.Index >= fileLength)
{
this.OnFilePositionCallback(call, fileLength, dataDto.Index);
result = true;
}
}
}
}
}
}
catch (Exception ex)
{
LogUtils.Error("【FileInfoClient.SendFile】", ex);
}
return(result);
}
public async Task UpdateFileData([FromBody] FileDataDto fileData)
{
await _fileService.UpdateData(fileData);
}
