/// <summary>
/// Instantiates a task to run the patchmanager client functionality
/// </summary>
public static void InitiatePatchClient()
{
Task t = new Task(() => PatchmanagerClient.StartPatchCheck(@"Downloads"));
t.Start();
PatchData = PatchmanagerClient.MissingFiles;
}
private void HandleTcpRequest(PatchClient patchClient)
{
while (MessageFormatter.Connected(patchClient.client))
{
try {
List <string> filesToDownload;
if (patchClient.client.GetStream().DataAvailable)
{
if (patchClient.fileList == null)
{
patchClient.fileList = JsonConvert.DeserializeObject <Dictionary <string, string> >(MessageFormatter.ReadStreamOnce(patchClient.client.GetStream()));
Console.WriteLine("Filelist received!");
Console.WriteLine("Comparing files to master list");
filesToDownload = FileChecker.CompareFileDictionaries(masterFiles, patchClient.fileList);
Console.WriteLine("Missing files on client:");
foreach (var item in filesToDownload)
{
Console.WriteLine(item);
}
FileTransferModel fileTransferModel = GenerateFileTransferModel(filesToDownload, masterFilesPath);
Console.WriteLine("Sending missing files list to client");
byte [] modelData = MessageFormatter.MessageBytes(fileTransferModel);
patchClient.client.GetStream().Write(modelData, 0, modelData.Length);
Console.WriteLine("Files list sent");
}
else
{
string fileToSend = MessageFormatter.ReadStreamOnce(patchClient.client.GetStream());
FileInfo fi = new FileInfo(masterFilesPath + '/' + fileToSend);
Console.WriteLine("{0} size: {1}", fi.Name, fi.Length);
byte [] preBuffer = BitConverter.GetBytes((int)fi.Length);
patchClient.client.Client.SendFile(fi.FullName, preBuffer, null, TransmitFileOptions.UseDefaultWorkerThread);
Console.WriteLine("{0} sent", fi.Name);
}
}
}
catch (Exception e) {
Console.WriteLine("Error: " + e.Message);
}
}
lock (clients)
clients.Remove(patchClient);
Console.WriteLine("{0} disconnected!", patchClient.client.Client.RemoteEndPoint.ToString());
Console.WriteLine("Currently {0} other connected clients!", clients.Count);
}
private FileTransferModel GenerateFileTransferModel(List <string> filesToAdd, string directory = "")
{
FileTransferModel model = new FileTransferModel();
foreach (var item in filesToAdd)
{
FileInfo t = new FileInfo(directory + '/' + item);
model.Files.Add(new FileModel()
{
FilePath = item, Size = t.Length
});
model.TotalSize += t.Length;
}
model.RemainingSize += model.TotalSize;
return(model);
}
public async Task SaveFileDetails(FileTransferModel model)
{
var file = model.MapTo <File>();
if (model.Role == "patient")
{
var patient = await _dbContext.Patients.Where(item => item.Id == model.ParticipantId).FirstOrDefaultAsync();
file.SharedBy = patient.UserId;
}
else
{
var provider = await _dbContext.Providers.Where(item => item.Id == model.ParticipantId).FirstOrDefaultAsync();
file.SharedBy = provider.UserId;
}
_dbContext.Files.Add(file);
await _dbContext.SaveChangesAsync();
}
public static bool Pastefiles(FileTransferModel fLTransModel)
{
LastErrorMsg = string.Empty;
fileTransferModel = new FileTransferModel();
fileTransferModel = fLTransModel;
IsCopy = fileTransferModel.CurrentAction == FileTransferModel.EAction.copy ? true : false;
fileTransferModel.DestinationAdress.Path = GetDirectory(fileTransferModel.DestinationAdress.Path);
bool Result = false;
if (!string.IsNullOrEmpty(fileTransferModel.DestinationAdress.Path))
{
if (IsDirectory(fileTransferModel.SourceFile.Path))
{
SetModeofCopying();
Result = MoveDri(fileTransferModel.SourceFile.Path, fileTransferModel.DestinationAdress.Path);
if (!IsCopy && SetToCopyFiles)
{
try
{
//System.IO.Directory.Delete(fileTransferModel.SourceFile.Path,true);
DeleteDirectory(fileTransferModel.SourceFile.Path);
}
catch (Exception ex)
{
LastErrorMsg = "Files moved but Cannot source file";
}
}
}
else
{
Result = MoveFiles(fileTransferModel.SourceFile.Path, fileTransferModel.DestinationAdress.Path);
}
}
{
return(Result);
}
}
public async Task SaveFileDetails(FileTransferModel model)
{
await _repo.SaveFileDetails(model);
}
public FileTransferResponse FileTransfer(FileTransferModel file)
{
return(ControlFile.CheckFile(file));
}
public static FileTransferResponse CheckFile(FileTransferModel file)
{
if (file != null)
{
if (!string.IsNullOrEmpty(file.FileName))
{
if (file.Content != null)
{
var checker = new FileTypeChecker();
Stream stream = new MemoryStream(file.Content);
try
{
var fileExtension = checker.GetFileType(stream);
if (fileExtension.Extension == ".pdf")
{
var filePath = FileOperations.SaveBytesToFile(file.FileName + ".pdf", file.Content);
return(new FileTransferResponse
{
Status = "1",
FileName = file.FileName + ".pdf",
FilePath = filePath,
FileType = ".pdf",
});
}
else
{
return(new FileTransferResponse
{
ErrorMessage = "File must be Portable Document Format.",
Status = "-1"
});
}
}
catch (Exception)
{
throw;
}
}
else
{
return(new FileTransferResponse
{
ErrorMessage = "File content is null.",
Status = "-1"
});
}
}
else
{
return(new FileTransferResponse
{
ErrorMessage = "File name is null.",
Status = "-1"
});
}
}
else
{
return(new FileTransferResponse
{
ErrorMessage = "Request is null.",
Status = "-1"
});
}
}
//private static Task<bool> ConnectClient () {
//}
public static void StartPatchCheck(string dir)
{
Status = PatchStatus.Connecting;
StatusChanged.Invoke(null, new EventArgs());
downloadDirectory = dir;
Directory.CreateDirectory(downloadDirectory);
FileChecker.GetFilesDictionaryProgress += ProgressUpdateReceived;
Task.Run(() => FileChecker.GetFilesDictionary(out allFilesDictionary, downloadDirectory));
while (allFilesDictionary == null)
{
}
while (client == null)
{
Thread.Sleep(TimeSpan.FromMilliseconds(16.66667));
try {
client = new TcpClient(GlobalVariables.PATCHMANAGER_IP, GlobalVariables.PATCHMANAGER_PORT);
}
catch {
}
}
SendFileDictionaryToServer();
MissingFiles = null;
Completed = false;
bool waitingForFile = false;
Status = PatchStatus.Downloading;
StatusChanged.Invoke(null, new EventArgs());
while (!Completed)
{
if (MessageFormatter.Connected(client))
{
if (MissingFiles == null)
{
while (client.GetStream().DataAvailable)
{
string jsonList = MessageFormatter.ReadStreamOnce(client.GetStream());
MissingFiles = JsonConvert.DeserializeObject <FileTransferModel>(jsonList);
MissingFilesUpdated.Invoke(null, new EventArgs());
if (MissingFiles.Files.Count == 0)
{
DownloadComplete.Invoke(null, new EventArgs());
Status = PatchStatus.Done;
StatusChanged.Invoke(null, new EventArgs());
Completed = true;
}
}
}
//Start requesting missing files from server
else if (MissingFiles.Files.Count > 0)
{
if (!waitingForFile)
{
byte [] fileRequestData = MessageFormatter.MessageBytes(MissingFiles.Files [0].FilePath);
client.GetStream().Write(fileRequestData, 0, fileRequestData.Length);
waitingForFile = true;
}
else
{
while (client.GetStream().DataAvailable)
{
MessageFormatter.ReadFile(client, MissingFiles.Files [0].FilePath, downloadDirectory);
MissingFiles.RemainingSize -= MissingFiles.Files [0].Size;
MissingFilesUpdated.Invoke(null, new EventArgs());
MissingFiles.Files.RemoveAt(0);
waitingForFile = false;
}
}
if (MissingFiles.Files.Count == 0)
{
waitingForFile = false;
DownloadComplete.Invoke(null, new EventArgs());
Status = PatchStatus.Done;
StatusChanged.Invoke(null, new EventArgs());
Completed = true;
}
}
}
}
client.Dispose();
}
