Thermo_SIM
642 lines
21 KiB
C#
642 lines
21 KiB
C#
using CefSharp;
|
|
using Client.Config;
|
|
using Client.Config.SubModels;
|
|
using Client2020.BrowserTools.Models;
|
|
using Client2020.BrowserTools.Models.Errors;
|
|
using Newtonsoft.Json;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Drawing;
|
|
using System.Drawing.Imaging;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using System.Windows.Forms;
|
|
|
|
namespace Client2020.BrowserTools
|
|
{
|
|
public class BrowserJSObject
|
|
{
|
|
private Form mainForm;
|
|
private static readonly string[] _validExtensions = { ".json", ".rcp", ".tpl" };
|
|
//private static readonly string[] _validExtensions = { "", ".txt", ".cnc", ".cn", ".cno", ".ini", ".mpf", ".spf", ".tap", ".anc", ".iso" };
|
|
private static readonly string[] _validImages = { ".svg" };
|
|
private static string jobPath = "";
|
|
private static Dictionary<string, IntPtr> _editorOpened = new Dictionary<string, IntPtr>();
|
|
public static string RECENT_FOLDER_KEY = "RECENT";
|
|
private const string THERMO_RECIPE_PATH = @"C:\CMS\Recipes";
|
|
private const string THERMO_RECIPE_FOLDER_NAME = @"Recipes";
|
|
private const string THERMO_SCREENSHOT_PATH = @"C:\CMS\Screenshots";
|
|
private const string CMS_PATH = @"C:\CMS";
|
|
|
|
#region CONSTRUCTOR_METHOD
|
|
public BrowserJSObject(Form f)
|
|
{
|
|
mainForm = f;
|
|
|
|
}
|
|
|
|
|
|
#endregion CONSTRUCTOR_METHOD
|
|
|
|
#region FORM_BEHAVIOUR_METHODS
|
|
public void minimizeForm()
|
|
{
|
|
//Invoke method if is needed or call the method in STD mode
|
|
if (mainForm.InvokeRequired)
|
|
mainForm.Invoke((MethodInvoker)delegate ()
|
|
{
|
|
mainForm.WindowState = FormWindowState.Minimized;
|
|
});
|
|
else
|
|
{
|
|
mainForm.WindowState = FormWindowState.Minimized;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Maximize Main Window
|
|
public void maximizeForm()
|
|
{
|
|
//Invoke method if is needed or call the method in STD mode
|
|
if (mainForm.InvokeRequired)
|
|
mainForm.Invoke((MethodInvoker)delegate ()
|
|
{
|
|
mainForm.WindowState = FormWindowState.Maximized;
|
|
});
|
|
else
|
|
{
|
|
mainForm.WindowState = FormWindowState.Maximized;
|
|
}
|
|
}
|
|
|
|
// Close Main Window
|
|
public void closeForm()
|
|
{
|
|
//If the mainform is disposed do nothing
|
|
if (mainForm.IsDisposed)
|
|
return;
|
|
|
|
//Invoke method if is needed or call the method in STD mode
|
|
Application.Exit();
|
|
}
|
|
|
|
public string takeScreenshot(string RecipeName)
|
|
{
|
|
|
|
string path = THERMO_SCREENSHOT_PATH + "\\" + RecipeName;
|
|
string pathFile = THERMO_SCREENSHOT_PATH + "\\" + RecipeName + "\\" + DateTime.Now.ToString("yyyy_MM_dd_HH_mm_ss") + ".jpg";
|
|
try
|
|
{
|
|
if (!Directory.Exists(path))
|
|
Directory.CreateDirectory(path);
|
|
|
|
Bitmap captureBitmap = new Bitmap(1920, 1080, PixelFormat.Format32bppArgb);
|
|
Rectangle captureRectangle = Screen.AllScreens[0].Bounds;
|
|
Graphics captureGraphics = Graphics.FromImage(captureBitmap);
|
|
captureGraphics.CopyFromScreen(captureRectangle.Left, captureRectangle.Top, 0, 0, captureRectangle.Size);
|
|
captureBitmap.Save(pathFile, ImageFormat.Jpeg);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return (JsonConvert.SerializeObject(new ErrorContainer("cannot_create_image")));
|
|
}
|
|
return (JsonConvert.SerializeObject(new ScreenshotController(pathFile))); ;
|
|
|
|
}
|
|
|
|
#endregion FORM_BEHAVIOUR_METHODS
|
|
|
|
#region NC_BEHAVIOUR_METHODS
|
|
public void setNcWindowState(int val)
|
|
{
|
|
|
|
}
|
|
|
|
public int getNcWindowState()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
public string getScreenBase64()
|
|
{
|
|
return "";
|
|
}
|
|
#endregion NC_BEHAVIOUR_METHODS
|
|
|
|
#region CHROMIUM_METHODS
|
|
|
|
// Get the Version of Chromium
|
|
public string getChromiumVersion()
|
|
{
|
|
return Cef.ChromiumVersion + " (" + Application.ProductVersion + ")";
|
|
}
|
|
|
|
#endregion CHROMIUM_METHODS
|
|
|
|
#region STEP_METHODS
|
|
|
|
// Get the ID of STEP Client
|
|
public int getClientID()
|
|
{
|
|
return Config.ConnectionConfig.Id;
|
|
}
|
|
|
|
public void forceStepFocus()
|
|
{
|
|
}
|
|
|
|
public void forceNcFocus()
|
|
{
|
|
}
|
|
|
|
public void forceProdFocus()
|
|
{
|
|
}
|
|
|
|
// Get the option of virtual Keyb configured
|
|
public bool isVirtualKeybConfigured()
|
|
{
|
|
return Config.ClientConfig.ShowVirtualKeyboard;
|
|
}
|
|
|
|
// Get the option of virtual Keyb configured
|
|
public bool isHMIenabled()
|
|
{
|
|
return Config.VendorHmiConfig.Enabled;
|
|
}
|
|
|
|
// Get the option of PROD Enabled
|
|
public bool isPRODenabled()
|
|
{
|
|
return Config.ProdSoftwareConfig.Enabled;
|
|
}
|
|
|
|
// Get the SCM option
|
|
public bool isSCMVisualStyle()
|
|
{
|
|
return Config.ClientConfig.IsSCM;
|
|
}
|
|
|
|
public string openExternalBrowser(string proc)
|
|
{
|
|
Process.Start(proc);
|
|
return "";
|
|
}
|
|
#endregion STEP_METHODS
|
|
|
|
#region PROCESSES_METHODS
|
|
|
|
// Read all configured processes
|
|
public string getConfiguredProcesses()
|
|
{
|
|
return JsonConvert.SerializeObject(Config.ExtSoftwaresConfig.Where(X => X.inMainMenuBar == false));
|
|
}
|
|
|
|
// Read all configured processes in main menu
|
|
public string getConfiguredProcessesInMainMenu()
|
|
{
|
|
return JsonConvert.SerializeObject(Config.ExtSoftwaresConfig.Where(X => X.inMainMenuBar == true));
|
|
}
|
|
|
|
// Start a new process
|
|
public void startNewProcess(string proc)
|
|
{
|
|
Thread t = new Thread(new ParameterizedThreadStart(OpenNew));
|
|
t.Start(proc);
|
|
}
|
|
|
|
// Open the last window or Start a new process
|
|
public void openOrStartProcess(string proc)
|
|
{
|
|
Thread t = new Thread(new ParameterizedThreadStart(OpenStartNew));
|
|
t.Start(proc);
|
|
}
|
|
|
|
// Function used in Thread
|
|
private void OpenStartNew(object id)
|
|
{
|
|
Software sft = Config.ExtSoftwaresConfig.FirstOrDefault(X => X.id == (string)id);
|
|
|
|
if (sft != null && File.Exists(sft.path))
|
|
{
|
|
Process[] p = Process.GetProcessesByName(Path.GetFileNameWithoutExtension(sft.path)).OrderByDescending(X => X.StartTime).ToArray();
|
|
|
|
if (p.Count() > 0 && p[0].MainWindowHandle != IntPtr.Zero)
|
|
NcWindow.ForceExtFocus(p[0].MainWindowHandle, 0, 0, 0, 0);
|
|
else
|
|
{
|
|
ProcessStartInfo PS = new ProcessStartInfo(sft.path, sft.arguments);
|
|
PS.WorkingDirectory = new FileInfo(sft.path).Directory.FullName;
|
|
Process.Start(PS);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Function used in Thread
|
|
private void OpenNew(object id)
|
|
{
|
|
Software sft = Config.ExtSoftwaresConfig.FirstOrDefault(X => X.id == (string)id);
|
|
if (sft != null)
|
|
{
|
|
ProcessStartInfo PS = new ProcessStartInfo(sft.path, sft.arguments);
|
|
PS.WorkingDirectory = new FileInfo(sft.path).Directory.FullName;
|
|
Process.Start(PS);
|
|
}
|
|
}
|
|
|
|
#endregion PROCESSES_METHODS
|
|
|
|
#region FILESYSTEM_METHODS
|
|
public string getOSdriveList()
|
|
{
|
|
List<Drive> drivelist = new List<Drive>();
|
|
|
|
if (Directory.Exists(THERMO_RECIPE_PATH))
|
|
{
|
|
drivelist.Add(new Drive()
|
|
{
|
|
Name = ElaborateName("Recipes", "", DriveType.Unknown),
|
|
Path = THERMO_RECIPE_PATH + "\\",
|
|
Type = "SPFO"
|
|
});
|
|
}
|
|
|
|
return JsonConvert.SerializeObject(drivelist);
|
|
}
|
|
|
|
public string getOSextDriveList()
|
|
{
|
|
List<Drive> drivelist = new List<Drive>();
|
|
|
|
// USB & HD Drives
|
|
foreach (var drive in DriveInfo.GetDrives())
|
|
{
|
|
if (drive.IsReady)
|
|
{
|
|
//Filter NC Address
|
|
if (drive.DriveType != DriveType.Network && drive.DriveType == DriveType.Removable)
|
|
{
|
|
drivelist.Add(new Drive()
|
|
{
|
|
Name = ElaborateName(drive.VolumeLabel, drive.Name.TrimEnd('\\'), drive.DriveType),
|
|
Path = drive.RootDirectory.ToString(),
|
|
Type = ElaborateType(drive.DriveType)
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
return JsonConvert.SerializeObject(drivelist);
|
|
}
|
|
public string backupRecipes(String p)
|
|
{
|
|
if (!Directory.Exists(p))
|
|
{
|
|
return (JsonConvert.SerializeObject(new ErrorContainer("path_not_exists")));
|
|
}
|
|
|
|
try
|
|
{
|
|
string finalPath = p + "Backup_Recipes_" + DateTime.Now.ToString("yyyy_MM_dd_HH_mm_ss");
|
|
Directory.CreateDirectory(finalPath);
|
|
this.CopyFilesRecursively(new DirectoryInfo(THERMO_RECIPE_PATH),new DirectoryInfo(finalPath));
|
|
Process.Start(finalPath);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return (JsonConvert.SerializeObject(new ErrorContainer("error_during_backup")));
|
|
}
|
|
|
|
return JsonConvert.SerializeObject("");
|
|
}
|
|
|
|
public string backupSubRecipes(String p, String folder)
|
|
{
|
|
if (!Directory.Exists(p))
|
|
{
|
|
return (JsonConvert.SerializeObject(new ErrorContainer("path_not_exists")));
|
|
}
|
|
|
|
folder = folder.Remove(0,THERMO_RECIPE_FOLDER_NAME.Length);
|
|
|
|
try
|
|
{
|
|
string finalPath = p + "Backup_Recipes_" + DateTime.Now.ToString("yyyy_MM_dd_HH_mm_ss");
|
|
Directory.CreateDirectory(finalPath);
|
|
this.CopyFilesRecursively(new DirectoryInfo(THERMO_RECIPE_PATH + folder), new DirectoryInfo(finalPath));
|
|
File.WriteAllText(finalPath + "\\data.json", JsonConvert.SerializeObject(new FolderBackup(folder)));
|
|
Process.Start(finalPath);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return (JsonConvert.SerializeObject(new ErrorContainer("error_during_backup")));
|
|
}
|
|
|
|
return JsonConvert.SerializeObject("");
|
|
}
|
|
|
|
|
|
// Read all files in directory
|
|
public string getFileList(string p)
|
|
{
|
|
List<FileModel> filelist = new List<FileModel>();
|
|
|
|
|
|
if (p != RECENT_FOLDER_KEY && !Directory.Exists(p))
|
|
{
|
|
return (JsonConvert.SerializeObject(new ErrorContainer("file_not_exists")));
|
|
}
|
|
|
|
try
|
|
{
|
|
if (p == RECENT_FOLDER_KEY)
|
|
{
|
|
filelist = new List<FileModel>();
|
|
}
|
|
else
|
|
{
|
|
// Add directories
|
|
foreach (string item in Directory.GetDirectories(p))
|
|
{
|
|
filelist.Add(new FileModel
|
|
{
|
|
Name = Path.GetFileName(item),
|
|
AbsolutePath = Path.GetFullPath(item),
|
|
Path = Path.GetFullPath(item),
|
|
IsDirectory = true,
|
|
FileExist = true,
|
|
IsMain = false
|
|
});
|
|
}
|
|
|
|
// Add files
|
|
foreach (string item in Directory.GetFiles(p))
|
|
{
|
|
if (_validExtensions.Contains(Path.GetExtension(item).ToLower()))
|
|
{
|
|
bool isJob = false;
|
|
filelist.Add(new FileModel
|
|
{
|
|
Name = Path.GetFileName(item),
|
|
AbsolutePath = Path.GetFullPath(item),
|
|
Path = Path.GetFullPath(item),
|
|
IsDirectory = false,
|
|
IsJob = isJob,
|
|
IsMain = false,
|
|
FileExist = true
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch { }
|
|
|
|
return (JsonConvert.SerializeObject(filelist));
|
|
}
|
|
|
|
// Read info of a file
|
|
public string getProgramInfo(string p)
|
|
{
|
|
string imagePath, imageDirectory;
|
|
|
|
if (!File.Exists(p))
|
|
{
|
|
return (JsonConvert.SerializeObject(new InfoFile()));
|
|
}
|
|
|
|
FileInfo f = new FileInfo(p);
|
|
InfoFile file = new InfoFile
|
|
{
|
|
Name = f.Name,
|
|
CreationDate = f.CreationTime,
|
|
LastModDate = f.LastAccessTime,
|
|
AbsolutePath = p,
|
|
CanEdit = !f.IsReadOnly
|
|
};
|
|
|
|
imagePath = Path.GetFileNameWithoutExtension(p);
|
|
imageDirectory = Path.GetDirectoryName(p);
|
|
|
|
file.SheetX = "";
|
|
file.SheetY = "";
|
|
file.SheetZ = "";
|
|
file.Annotation = "";
|
|
|
|
try
|
|
{
|
|
dynamic content = JsonConvert.DeserializeObject(File.ReadAllText(p));
|
|
|
|
if (content != null && content.RecipeParameters != null)
|
|
{
|
|
if (content.RecipeParameters.general_sizes_sheet_dim_x != null)
|
|
file.SheetX = content.RecipeParameters.general_sizes_sheet_dim_x;
|
|
if (content.RecipeParameters.general_sizes_sheet_dim_y != null)
|
|
file.SheetY = content.RecipeParameters.general_sizes_sheet_dim_y;
|
|
if (content.RecipeParameters.general_sizes_sheet_thickness != null)
|
|
file.SheetZ = content.RecipeParameters.general_sizes_sheet_thickness;
|
|
if (content.recipeNotes != null)
|
|
file.Annotation = content.recipeNotes;
|
|
}
|
|
|
|
foreach (string ext in _validImages)
|
|
{
|
|
if (File.Exists(imageDirectory + "/" + imagePath + ext))
|
|
{
|
|
if (ext.ToLower().Equals(".svg"))
|
|
file.PreviewBase64 = File.ReadAllText(imageDirectory + "/" + imagePath + ext);
|
|
else
|
|
file.PreviewBase64 = "data:image/" + ext + ";base64," + Convert.ToBase64String(File.ReadAllBytes(imageDirectory + "/" + imagePath + ext));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
}
|
|
|
|
return (JsonConvert.SerializeObject(file));
|
|
}
|
|
|
|
|
|
public string duplicateRecipe(string p1, string p2)
|
|
{
|
|
string oldFile = CMS_PATH + "\\" + p1 + ".rcp";
|
|
string newFile = CMS_PATH + "\\" + p2 + ".rcp";
|
|
string oldImage = CMS_PATH + "\\" + p1 + ".svg";
|
|
string newImage = CMS_PATH + "\\" + p2 + ".svg";
|
|
if (!File.Exists(oldFile))
|
|
{
|
|
return (JsonConvert.SerializeObject(new ErrorContainer("file_not_found")));
|
|
}
|
|
if (File.Exists(newFile))
|
|
{
|
|
return (JsonConvert.SerializeObject(new ErrorContainer("file_already_exists")));
|
|
}
|
|
try
|
|
{
|
|
File.Copy(oldFile, newFile, true);
|
|
if (File.Exists(oldImage))
|
|
{
|
|
File.Copy(oldImage, newImage, true);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return(JsonConvert.SerializeObject(new ErrorContainer("cannot_copy_file")));
|
|
}
|
|
return "";
|
|
}
|
|
|
|
public string getAllRecipeDirectories()
|
|
{
|
|
List<string> dirs = this.DirSearch(THERMO_RECIPE_PATH);
|
|
for (int i = 0; i < dirs.Count; i++)
|
|
{
|
|
dirs[i] = dirs[i].Remove(0, CMS_PATH.Length + 1);
|
|
}
|
|
|
|
return(JsonConvert.SerializeObject(dirs));
|
|
}
|
|
|
|
public string deleteFile(string p)
|
|
{
|
|
FileAttributes attr = File.GetAttributes(p);
|
|
if (!File.Exists(p) || attr.HasFlag(FileAttributes.Directory))
|
|
{
|
|
return (JsonConvert.SerializeObject(new ErrorContainer("file_not_found")));
|
|
}
|
|
if (attr.HasFlag(FileAttributes.ReadOnly))
|
|
{
|
|
return (JsonConvert.SerializeObject(new ErrorContainer("file_not_editable")));
|
|
}
|
|
try
|
|
{
|
|
File.Delete(p);
|
|
string images = Path.ChangeExtension(p, "svg");
|
|
if (File.Exists(images))
|
|
{
|
|
File.Delete(images);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return (JsonConvert.SerializeObject(new ErrorContainer("cannot_delete_file")));
|
|
}
|
|
return "";
|
|
}
|
|
|
|
public string deleteFolder(string p)
|
|
{
|
|
|
|
FileAttributes attr = File.GetAttributes(p);
|
|
if (!Directory.Exists(p) || !attr.HasFlag(FileAttributes.Directory))
|
|
{
|
|
return (JsonConvert.SerializeObject(new ErrorContainer("directory_not_found")));
|
|
}
|
|
if (attr.HasFlag(FileAttributes.ReadOnly))
|
|
{
|
|
return (JsonConvert.SerializeObject(new ErrorContainer("directory_not_editable")));
|
|
}
|
|
try
|
|
{
|
|
Directory.Delete(p, true);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return (JsonConvert.SerializeObject(new ErrorContainer("cannot_delete_directory")));
|
|
}
|
|
return "";
|
|
}
|
|
|
|
public string createFolder(string path)
|
|
{
|
|
if (Directory.Exists(path))
|
|
{
|
|
return (JsonConvert.SerializeObject(new ErrorContainer("directory_already_exists")));
|
|
}
|
|
try
|
|
{
|
|
Directory.CreateDirectory(path);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return (JsonConvert.SerializeObject(new ErrorContainer("cannot_delete_directory")));
|
|
}
|
|
return "";
|
|
}
|
|
|
|
// Private functions
|
|
private string ElaborateType(DriveType type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case DriveType.Fixed: return "HD";
|
|
case DriveType.Removable: return "USB";
|
|
case DriveType.Network: return "NTW";
|
|
}
|
|
return "SPFO";
|
|
}
|
|
private string ElaborateName(string name, string letter, DriveType type)
|
|
{
|
|
var retName = "";
|
|
|
|
if (!string.IsNullOrWhiteSpace(name))
|
|
retName = name;
|
|
else
|
|
{
|
|
switch (type)
|
|
{
|
|
case DriveType.Fixed: retName = "Hard_Disk"; break;
|
|
case DriveType.Removable: retName = "Usb_Disk"; break;
|
|
case DriveType.Network: retName = "Netword_Disk"; break;
|
|
default: retName = "Undefined"; break;
|
|
}
|
|
}
|
|
|
|
|
|
if (!string.IsNullOrWhiteSpace(letter))
|
|
retName = retName + " (" + letter + ")";
|
|
|
|
return retName;
|
|
}
|
|
|
|
public void CopyFilesRecursively(DirectoryInfo source, DirectoryInfo target)
|
|
{
|
|
foreach (DirectoryInfo dir in source.GetDirectories())
|
|
CopyFilesRecursively(dir, target.CreateSubdirectory(dir.Name));
|
|
foreach (FileInfo file in source.GetFiles())
|
|
file.CopyTo(Path.Combine(target.FullName, file.Name));
|
|
}
|
|
|
|
private List<String> DirSearch(string sDir)
|
|
{
|
|
List<String> files = new List<String>();
|
|
try
|
|
{
|
|
files.Add(sDir);
|
|
foreach (string d in Directory.GetDirectories(sDir))
|
|
{
|
|
files.AddRange(DirSearch(d));
|
|
}
|
|
}
|
|
catch (System.Exception excpt)
|
|
{
|
|
MessageBox.Show(excpt.Message);
|
|
}
|
|
|
|
return files;
|
|
}
|
|
|
|
public void cleanFileWatcher()
|
|
{
|
|
|
|
}
|
|
|
|
#endregion FILESYSTEM_METHODS
|
|
}
|
|
|
|
} |