Sic-Software
/
Sic.Framework-Nanjing-Baishi
4
0
Fork 0
Code Issues Pull Requests Projects Releases Activity
Sic.Framework-Nanjing-Baishi/MECF.Framework.Common/Aitex/Core/RT/RecipeCenter/RecipeFileManager.cs

1277 lines
37 KiB
C#
Raw Normal View History

Add project files.
2023-04-13 11:51:03 +08:00
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using System.Xml;
using System.Xml.Schema;
using Aitex.Common.Util;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.Log;
using Aitex.Core.Util;
using Aitex.Core.Utilities;
using Aitex.Core.WCF;
using MECF.Framework.Common.DBCore;
using MECF.Framework.Common.Properties;
using MECF.Framework.Common.RecipeCenter;
namespace Aitex.Core.RT.RecipeCenter
{
public class RecipeFileManager : Singleton<RecipeFileManager>
{
public const string SequenceFolder = "Sequence";
public const string SourceModule = "Recipe";
private bool _recipeIsValid;
private bool _recipeSaveInDB = false;
private List<string> _validationErrors = new List<string>();
private List<string> _validationWarnings = new List<string>();
private Dictionary<int, Dictionary<string, string>> _recipeItems;
private IRecipeFileContext _rcpContext;
private ISequenceFileContext _seqContext;
public void Initialize(IRecipeFileContext context)
{
Initialize(context, null, enableService: true);
}
public void Initialize(IRecipeFileContext context, bool enableService, bool recipeSaveInDB)
{
_recipeSaveInDB = recipeSaveInDB;
Initialize(context, null, enableService);
}
public void Initialize(IRecipeFileContext rcpContext, ISequenceFileContext seqContext, bool enableService)
{
IRecipeFileContext rcpContext2;
if (rcpContext != null)
{
rcpContext2 = rcpContext;
}
else
{
IRecipeFileContext recipeFileContext = new DefaultRecipeFileContext();
rcpContext2 = recipeFileContext;
}
_rcpContext = rcpContext2;
ISequenceFileContext seqContext2;
if (seqContext != null)
{
seqContext2 = seqContext;
}
else
{
ISequenceFileContext sequenceFileContext = new DefaultSequenceFileContext();
seqContext2 = sequenceFileContext;
}
_seqContext = seqContext2;
//CultureSupported.UpdateCoreCultureResource("en-US");
if (enableService)
{
Singleton<WcfServiceManager>.Instance.Initialize(new Type[1] { typeof(RecipeService) });
}
string path = string.Format("{0}{1}\\", PathManager.GetRecipeDir(), "Sequence");
DirectoryInfo directoryInfo = new DirectoryInfo(path);
if (!directoryInfo.Exists)
{
directoryInfo.Create();
}
MoveRecipe();
MoveSequence();
}
private void MoveSequence()
{
DataTable allData = SequenceInfoRecorder.GetAllData();
if (!_recipeSaveInDB)
{
if (allData == null || allData.Rows.Count <= 0)
{
return;
}
for (int i = 0; i < allData.Rows.Count; i++)
{
try
{
string @string = Encoding.UTF8.GetString((byte[])allData.Rows[i]["fileDetail"]);
SaveSequence(allData.Rows[i]["seqName"].ToString().Replace(".seq", ""), @string, notifyUI: false);
}
catch
{
}
}
SequenceInfoRecorder.DeleteAllData();
}
else if (allData == null || allData.Rows.Count <= 0)
{
MoveSequeceToDB();
}
}
private void MoveRecipe()
{
DataTable allData = RecipeInfoRecorer.GetAllData();
if (!_recipeSaveInDB)
{
List<string> list = new List<string>();
if (allData == null || allData.Rows.Count <= 0)
{
return;
}
for (int i = 0; i < allData.Rows.Count; i++)
{
string text = allData.Rows[i]["rootName"].ToString() + "\\" + allData.Rows[i]["recipeName"].ToString();
string arg = text;
if (text.IndexOf(".rcp") > 0)
{
arg = text.Substring(0, text.LastIndexOf("\\"));
}
string path = $"{PathManager.GetRecipeDir()}{arg}\\";
DirectoryInfo directoryInfo = new DirectoryInfo(path);
if (!directoryInfo.Exists)
{
directoryInfo.Create();
}
if (text.IndexOf(".rcp") > 0)
{
try
{
string @string = Encoding.UTF8.GetString((byte[])allData.Rows[i]["fileDetail"]);
SaveRecipe(allData.Rows[i]["rootName"].ToString(), allData.Rows[i]["recipeName"].ToString().Replace(".rcp", ""), @string, clearBarcode: false, notifyUI: false);
}
catch
{
}
}
}
RecipeInfoRecorer.DeleteAllData();
}
else if (allData == null || allData.Rows.Count <= 0)
{
MoveReipeToDB();
}
}
private void MoveReipeToDB()
{
string recipeDir = PathManager.GetRecipeDir();
DirectoryInfo directoryInfo = new DirectoryInfo(recipeDir + "\\Sic");
if (directoryInfo.Exists)
{
DirectoryInfo[] directories = directoryInfo.GetDirectories();
DirectoryInfo[] array = directories;
foreach (DirectoryInfo directoryInfo2 in array)
{
WriteDBFromLocal(directoryInfo2, "Sic\\" + directoryInfo2.Name, directoryInfo2.FullName + "\\");
}
}
}
private void WriteDBFromLocal(DirectoryInfo dir, string rootName, string rootPath)
{
DirectoryInfo[] directories = dir.GetDirectories();
DirectoryInfo[] array = directories;
foreach (DirectoryInfo dir2 in array)
{
WriteDBFromLocal(dir2, rootName, rootPath);
}
FileInfo[] files = dir.GetFiles("*.rcp");
FileInfo[] array2 = files;
foreach (FileInfo fileInfo in array2)
{
string recipeName = fileInfo.FullName.Replace(rootPath, "").Replace(".rcp", "");
string recipeContent = LoadRecipe(rootName, recipeName, needValidation: false, isWriteToAnother: true);
SaveRecipe(rootName, recipeName, recipeContent, clearBarcode: false, notifyUI: false);
}
}
private void MoveSequeceToDB()
{
string path = string.Format("{0}{1}\\", PathManager.GetRecipeDir(), "Sequence");
DirectoryInfo directoryInfo = new DirectoryInfo(path);
if (directoryInfo.Exists)
{
FileInfo[] files = directoryInfo.GetFiles("*.seq");
FileInfo[] array = files;
foreach (FileInfo fileInfo in array)
{
string sequenceName = fileInfo.Name.Replace(".seq", "");
string sequence = GetSequence(sequenceName, needValidation: false, isLoadAnother: true);
SaveSequence(sequenceName, sequence, notifyUI: false);
}
}
}
private void ValidationEventHandler(object sender, ValidationEventArgs e)
{
switch (e.Severity)
{
case XmlSeverityType.Error:
_validationErrors.Add(e.Message);
_recipeIsValid = false;
break;
case XmlSeverityType.Warning:
_validationWarnings.Add(e.Message);
break;
}
}
public bool ValidateRecipe(string chamberId, string recipeName, string recipeContent, out List<string> reason)
{
try
{
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml(recipeContent);
MemoryStream input = new MemoryStream(Encoding.ASCII.GetBytes(GetRecipeSchema(chamberId)));
XmlReader reader = XmlReader.Create(input);
XmlSchema schema = XmlSchema.Read(reader, ValidationEventHandler);
xmlDocument.Schemas.Add(schema);
xmlDocument.LoadXml(recipeContent);
ValidationEventHandler validationEventHandler = ValidationEventHandler;
_recipeIsValid = true;
_validationErrors = new List<string>();
_validationWarnings = new List<string>();
xmlDocument.Validate(validationEventHandler);
}
catch (Exception ex)
{
LOG.Write(ex.Message);
_recipeIsValid = false;
}
if (!_recipeIsValid && _validationErrors.Count == 0)
{
_validationErrors.Add(Resource.RecipeFileManager_ValidateRecipe_XMLSchemaValidateFailed);
}
reason = _validationErrors;
return _recipeIsValid;
}
public bool CheckRampRate(int stepNo, string rampEnable, string varName, string rampTime, double maxRampUpRate, double maxRampDownRate)
{
try
{
if (stepNo <= 0)
{
return false;
}
switch (varName)
{
default:
if (!(varName == "DZone.Setpoint"))
{
break;
}
goto case "AZone.Setpoint";
case "AZone.Setpoint":
case "BZone.Setpoint":
case "CZone.Setpoint":
{
string text = _recipeItems[stepNo]["Heater.Mode"];
string text2 = _recipeItems[stepNo - 1]["Heater.Mode"];
if (text != text2)
{
return false;
}
break;
}
}
bool flag = bool.Parse(rampEnable);
string[] array = rampTime.Split(new char[1] { ':' }, StringSplitOptions.RemoveEmptyEntries);
double num = 0.0;
double num2 = 0.0;
double num3 = 0.0;
if (array.Length == 3)
{
num = double.Parse(array[0]);
num2 = double.Parse(array[1]);
num3 = double.Parse(array[2]);
}
else if (array.Length == 2)
{
num2 = double.Parse(array[0]);
num3 = double.Parse(array[1]);
}
else if (array.Length == 1)
{
num3 = double.Parse(array[0]);
}
double num4 = num * 3600.0 + num2 * 60.0 + num3;
double num5 = double.Parse(_recipeItems[stepNo][varName]) - double.Parse(_recipeItems[stepNo - 1][varName]);
if (!flag || num4 <= 0.0)
{
if (num5 != 0.0)
{
return true;
}
return false;
}
double num6 = num5 / num4;
if ((num6 > 0.0 && num6 >= maxRampUpRate) || (num6 < 0.0 && num6 <= 0.0 - maxRampDownRate))
{
return true;
}
return false;
}
catch (Exception ex)
{
LOG.Write(ex.Message);
return true;
}
}
public bool CheckRecipe(string chamberId, string recipeContent, out List<string> reasons)
{
reasons = new List<string>();
try
{
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml(GetRecipeFormatXml(chamberId));
Dictionary<string, double> dictionary = new Dictionary<string, double>();
Dictionary<string, double> dictionary2 = new Dictionary<string, double>();
foreach (XmlElement item in xmlDocument.SelectNodes("/TableRecipeFormat/Catalog/Group/Step[@DeviceType='MFC']"))
{
dictionary.Add(item.Attributes["ControlName"].Value, Convert.ToDouble(item.Attributes["Max"].Value));
}
foreach (XmlElement item2 in xmlDocument.SelectNodes("/TableRecipeFormat/Catalog/Group/Step[@DeviceType='PC']"))
{
dictionary2.Add(item2.Attributes["ControlName"].Value, Convert.ToDouble(item2.Attributes["Max"].Value));
}
XmlDocument xmlDocument2 = new XmlDocument();
xmlDocument2.LoadXml(recipeContent);
_recipeItems = new Dictionary<int, Dictionary<string, string>>();
XmlNodeList xmlNodeList = xmlDocument2.SelectNodes("/TableRecipeData/Step");
for (int i = 0; i < xmlNodeList.Count; i++)
{
XmlElement xmlElement3 = xmlNodeList[i] as XmlElement;
Dictionary<string, string> dictionary3 = new Dictionary<string, string>();
_recipeItems.Add(i, dictionary3);
foreach (XmlAttribute attribute in xmlElement3.Attributes)
{
dictionary3.Add(attribute.Name, attribute.Value);
}
foreach (XmlElement childNode in xmlElement3.ChildNodes)
{
foreach (XmlAttribute attribute2 in childNode.Attributes)
{
dictionary3.Add(attribute2.Name, attribute2.Value);
}
foreach (XmlElement childNode2 in childNode.ChildNodes)
{
foreach (XmlAttribute attribute3 in childNode2.Attributes)
{
dictionary3.Add(attribute3.Name, attribute3.Value);
}
foreach (XmlElement childNode3 in childNode2.ChildNodes)
{
foreach (XmlAttribute attribute4 in childNode3.Attributes)
{
dictionary3.Add(attribute4.Name, attribute4.Value);
}
}
}
}
}
for (int j = 0; j < _recipeItems.Count; j++)
{
string text = _recipeItems[j]["Loop"];
bool flag = Regex.IsMatch(text, "^Loop\\x20\\d+$");
bool flag2 = Regex.IsMatch(text, "^Loop End$");
bool flag3 = string.IsNullOrWhiteSpace(text);
if (!flag2 && !flag && !flag3)
{
string arg = $"Value '{text}' not valid";
reasons.Add($"第{j + 1}步，{arg}.");
}
if (flag2)
{
string arg2 = "Loop Start 缺失";
reasons.Add($"第{j + 1}步，{arg2}.");
}
else
{
if (!flag)
{
continue;
}
for (int k = j + 1; k < _recipeItems.Count; k++)
{
string text2 = _recipeItems[k]["Loop"];
bool flag4 = Regex.IsMatch(text2, "^Loop\\x20\\d+$");
bool flag5 = Regex.IsMatch(text2, "^Loop End$");
flag3 = string.IsNullOrWhiteSpace(text2);
if (!flag5 && !flag4 && !flag3)
{
string arg3 = $"Value '{text2}' not valid";
reasons.Add($"第{k + 1}步，{arg3}.");
}
else if (flag4)
{
string arg4 = "前面循环没有结束，不能设置新的Loop Start标志";
reasons.Add($"第{k + 1}步，{arg4}.");
}
else if (flag5)
{
j = k;
break;
}
if (k == _recipeItems.Count - 1)
{
j = k;
string arg5 = "Loop End 缺失";
reasons.Add($"第{k + 1}步，{arg5}.");
}
}
}
}
for (int l = 0; l < _recipeItems.Count; l++)
{
foreach (string key in dictionary.Keys)
{
if (_recipeItems[l].ContainsKey(key))
{
double num = Convert.ToDouble(_recipeItems[l][key]);
if (num < 0.0 || num > dictionary[key])
{
reasons.Add($"第{l + 1}步，{key}设定{num}，超出 0~{dictionary[key]}sccm范围.");
}
}
}
foreach (string key2 in dictionary2.Keys)
{
if (_recipeItems[l].ContainsKey(key2))
{
double num2 = Convert.ToDouble(_recipeItems[l][key2]);
if (num2 < 0.0 || num2 > dictionary2[key2])
{
reasons.Add($"第{l + 1}步，{key2}设定{num2}，超出 0~{dictionary2[key2]}mbar范围.");
}
}
}
}
Dictionary<string, string> dictionary4 = new Dictionary<string, string>();
foreach (XmlElement item3 in xmlDocument.SelectNodes("/TableRecipeFormat/Validation/Predefine/Item"))
{
dictionary4.Add(item3.Attributes["VarName"].Value, item3.Attributes["Value"].Value);
}
}
catch (Exception ex)
{
reasons.Add(Resource.RecipeFileManager_CheckRecipe_RecipeValidationFailed + ex.Message);
LOG.Write(ex);
return false;
}
return reasons.Count == 0;
}
public string LoadRecipe(string chamberId, string recipeName, bool needValidation, bool isWriteToAnother = false)
{
string result = string.Empty;
try
{
bool flag = _recipeSaveInDB;
if (isWriteToAnother)
{
flag = !_recipeSaveInDB;
}
if (flag)
{
return RecipeInfoRecorer.GetRecipeInfoByFileName(chamberId, recipeName);
}
using StreamReader streamReader = new StreamReader(GenerateRecipeFilePath(chamberId, recipeName));
result = streamReader.ReadToEnd();
streamReader.Close();
}
catch (Exception ex)
{
LOG.Write(ex, "load recipe file failed, " + recipeName);
result = string.Empty;
}
return result;
}
public IEnumerable<string> GetRecipes(string chamberId, bool includingUsedRecipe)
{
if (_recipeSaveInDB)
{
DataTable rootAllDirectoryAndFiles = RecipeInfoRecorer.GetRootAllDirectoryAndFiles(chamberId);
List<string> list = new List<string>();
if (rootAllDirectoryAndFiles != null && rootAllDirectoryAndFiles.Rows.Count > 0)
{
for (int i = 0; i < rootAllDirectoryAndFiles.Rows.Count; i++)
{
list.Add(rootAllDirectoryAndFiles.Rows[i][0].ToString().Replace(".rcp", ""));
}
}
return list;
}
return _rcpContext.GetRecipes(chamberId, includingUsedRecipe);
}
public string GetXmlRecipeList(string chamberId, bool includingUsedRecipe)
{
XmlDocument xmlDocument = new XmlDocument();
string recipeDirPath = getRecipeDirPath(chamberId);
DirectoryInfo currentDir = new DirectoryInfo(recipeDirPath);
xmlDocument.AppendChild(GenerateRecipeList(chamberId, currentDir, xmlDocument, includingUsedRecipe));
return xmlDocument.OuterXml;
}
public void SaveRecipeHistory(string chamberId, string recipeName, string recipeContent, bool needSaveAs = true)
{
try
{
if (!string.IsNullOrEmpty(recipeName) && needSaveAs)
{
string recipeName2 = string.Format("HistoryRecipe\\{0}\\{1}", DateTime.Now.ToString("yyyyMM"), recipeName);
SaveRecipe(chamberId, recipeName2, recipeContent, clearBarcode: true, notifyUI: false);
LOG.Write($"{chamberId}通知TM保存工艺程序{recipeName}");
}
}
catch (Exception ex)
{
LOG.Write(ex, $"保存{chamberId}工艺程序{recipeName}发生错误");
}
}
private XmlElement GenerateRecipeList(string currentDir, List<string> lstDir, XmlDocument doc)
{
XmlElement xmlElement = doc.CreateElement("Folder");
string value = currentDir;
if (currentDir.IndexOf("\\") > 0)
{
value = currentDir.Substring(currentDir.LastIndexOf("\\") + 1);
}
xmlElement.SetAttribute("Name", value);
List<string> nextForderList = GetNextForderList(lstDir, currentDir);
if (nextForderList.Count > 0)
{
foreach (string item in nextForderList)
{
xmlElement.AppendChild(GenerateRecipeList(item, GetCurrentFileListAll(lstDir, item), doc));
}
}
List<string> currentRcpList = GetCurrentRcpList(lstDir, currentDir);
if (currentRcpList.Count > 0)
{
foreach (string item2 in currentRcpList)
{
XmlElement xmlElement2 = doc.CreateElement("File");
string value2 = item2.Substring(0, item2.LastIndexOf("."));
xmlElement2.SetAttribute("Name", value2);
xmlElement.AppendChild(xmlElement2);
}
}
return xmlElement;
}
private List<string> GetCurrentFileListAll(List<string> lstDir, string curForder)
{
List<string> list = new List<string>();
for (int i = 0; i < lstDir.Count; i++)
{
if (string.IsNullOrEmpty(curForder))
{
return lstDir;
}
if ((lstDir[i].IndexOf(curForder + "\\") == 0 || lstDir[i] == curForder) && !list.Contains(lstDir[i]))
{
list.Add(lstDir[i]);
}
}
return list;
}
private List<string> GetCurrentRcpList(List<string> lstDir, string curForder)
{
List<string> list = new List<string>();
for (int i = 0; i < lstDir.Count; i++)
{
if (string.IsNullOrEmpty(curForder))
{
if (lstDir[i].IndexOf("\\") <= 0 && lstDir[i].IndexOf(".rcp") > 0 && !list.Contains(lstDir[i]))
{
list.Add(lstDir[i]);
}
}
else if (lstDir[i].IndexOf(curForder + "\\") == 0)
{
string text = lstDir[i].Substring(curForder.Length + 1);
if (text.IndexOf("\\") <= 0 && text.IndexOf(".rcp") > 0 && !list.Contains(lstDir[i]))
{
list.Add(lstDir[i]);
}
}
}
return list;
}
private List<string> GetNextForderList(List<string> lstDir, string curForder)
{
List<string> list = new List<string>();
for (int i = 0; i < lstDir.Count; i++)
{
if (string.IsNullOrEmpty(curForder))
{
string text = lstDir[i];
if (text.IndexOf("\\") > 0)
{
string item = text.Substring(0, text.IndexOf("\\"));
if (!list.Contains(item))
{
list.Add(item);
}
}
else if (text.IndexOf(".rcp") < 0 && !list.Contains(text))
{
list.Add(text);
}
}
else
{
if (lstDir[i].IndexOf(curForder + "\\") != 0)
{
continue;
}
string text2 = lstDir[i].Substring(curForder.Length + 1);
if (text2.IndexOf("\\") > 0)
{
string text3 = text2.Substring(0, text2.IndexOf("\\"));
if (!list.Contains(curForder + "\\" + text3))
{
list.Add(curForder + "\\" + text3);
}
}
else if (text2.IndexOf(".rcp") < 0 && !list.Contains(curForder + "\\" + text2))
{
list.Add(curForder + "\\" + text2);
}
}
}
return list;
}
private XmlElement GenerateRecipeList(string chamberId, DirectoryInfo currentDir, XmlDocument doc, bool includingUsedRecipe)
{
if (_recipeSaveInDB)
{
DataTable rootAllDirectoryAndFiles = RecipeInfoRecorer.GetRootAllDirectoryAndFiles(chamberId);
List<string> list = new List<string>();
if (rootAllDirectoryAndFiles != null && rootAllDirectoryAndFiles.Rows.Count > 0)
{
for (int i = 0; i < rootAllDirectoryAndFiles.Rows.Count; i++)
{
list.Add(rootAllDirectoryAndFiles.Rows[i][0].ToString());
}
}
return GenerateRecipeList("", list, doc);
}
int length = getRecipeDirPath(chamberId).Length;
XmlElement xmlElement = doc.CreateElement("Folder");
xmlElement.SetAttribute("Name", currentDir.FullName.Substring(length));
DirectoryInfo[] directories = currentDir.GetDirectories();
DirectoryInfo[] array = directories;
foreach (DirectoryInfo directoryInfo in array)
{
if (includingUsedRecipe || !(directoryInfo.Name == "HistoryRecipe"))
{
xmlElement.AppendChild(GenerateRecipeList(chamberId, directoryInfo, doc, includingUsedRecipe));
}
}
FileInfo[] files = currentDir.GetFiles("*.rcp");
FileInfo[] array2 = files;
foreach (FileInfo fileInfo in array2)
{
XmlElement xmlElement2 = doc.CreateElement("File");
string text = fileInfo.FullName.Substring(length).TrimStart('\\');
text = text.Substring(0, text.LastIndexOf("."));
xmlElement2.SetAttribute("Name", text);
xmlElement.AppendChild(xmlElement2);
}
return xmlElement;
}
public bool DeleteRecipe(string chamberId, string recipeName)
{
try
{
if (_recipeSaveInDB)
{
RecipeInfoRecorer.DeleteRecipeInfoByFileName(chamberId, recipeName);
}
else
{
File.Delete(GenerateRecipeFilePath(chamberId, recipeName));
InfoDialog(string.Format(Resource.RecipeFileManager_DeleteRecipe_RecipeFile0DeleteSucceeded, recipeName));
}
}
catch (Exception ex)
{
LOG.Write(ex, "删除recipe file 出错");
WarningDialog(string.Format(Resource.RecipeFileManager_DeleteRecipe_RecipeFile0DeleteFailed, recipeName));
return false;
}
return true;
}
public bool RenameRecipe(string chamId, string oldName, string newName)
{
try
{
if (_recipeSaveInDB)
{
RecipeInfoRecorer.RenameRecipeFileName(chamId, oldName, newName);
}
else
{
if (File.Exists(GenerateRecipeFilePath(chamId, newName)))
{
WarningDialog(string.Format(Resource.RecipeFileManager_RenameRecipe_RecipeFile0FileExisted, oldName));
return false;
}
File.Move(GenerateRecipeFilePath(chamId, oldName), GenerateRecipeFilePath(chamId, newName));
InfoDialog(string.Format(Resource.RecipeFileManager_RenameRecipe_RecipeFile0Renamed, oldName, newName));
}
}
catch (Exception ex)
{
LOG.Write(ex, "重命名recipe file 出错");
WarningDialog(string.Format(Resource.RecipeFileManager_RenameRecipe_RecipeFile0RenameFailed, oldName, newName));
return false;
}
return true;
}
private void InfoDialog(string message)
{
_rcpContext.PostInfoDialogMessage(message);
}
private void WarningDialog(string message)
{
_rcpContext.PostWarningDialogMessage(message);
}
private void EventDialog(string message, List<string> reason)
{
string text = message;
foreach (string item in reason)
{
text = text + "\r\n" + item;
}
_rcpContext.PostDialogEvent(text);
}
private string GenerateRecipeFilePath(string chamId, string recipeName)
{
return getRecipeDirPath(chamId) + recipeName + ".rcp";
}
private string GenerateSequenceFilePath(string chamId, string recipeName)
{
return getRecipeDirPath(chamId) + recipeName + ".seq";
}
private string getRecipeDirPath(string chamId)
{
string text = $"{PathManager.GetRecipeDir()}{chamId}\\";
DirectoryInfo directoryInfo = new DirectoryInfo(text);
if (!directoryInfo.Exists)
{
directoryInfo.Create();
}
return text;
}
public bool DeleteFolder(string chamId, string folderName)
{
try
{
if (_recipeSaveInDB)
{
RecipeInfoRecorer.DeleteFolder(chamId, folderName);
}
else
{
Directory.Delete(getRecipeDirPath(chamId) + folderName, recursive: true);
InfoDialog(string.Format(Resource.RecipeFileManager_DeleteFolder_RecipeFolder0DeleteSucceeded, folderName));
}
}
catch (Exception ex)
{
LOG.Write(ex, "删除recipe folder 出错");
WarningDialog($"recipe folder {folderName} delete failed");
return false;
}
return true;
}
public bool SaveAsRecipe(string chamId, string recipeName, string recipeContent)
{
string path = GenerateRecipeFilePath(chamId, recipeName);
if (File.Exists(path))
{
WarningDialog(string.Format(Resource.RecipeFileManager_SaveAsRecipe_RecipeFile0savefailed, recipeName));
return false;
}
return SaveRecipe(chamId, recipeName, recipeContent, clearBarcode: true, notifyUI: true);
}
public bool SaveRecipe(string chamId, string recipeName, string recipeContent, bool clearBarcode, bool notifyUI)
{
if (_recipeSaveInDB)
{
if (!RecipeInfoRecorer.WriteRecipeInfo(chamId, recipeName, recipeContent))
{
LOG.Write("保存recipe file 到数据库出错");
return false;
}
return true;
}
bool result = true;
try
{
string text = GenerateRecipeFilePath(chamId, recipeName);
FileInfo fileInfo = new FileInfo(text);
if (!fileInfo.Directory.Exists)
{
fileInfo.Directory.Create();
}
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml(recipeContent);
XmlTextWriter xmlTextWriter = new XmlTextWriter(text, Encoding.UTF8);
xmlTextWriter.Formatting = Formatting.Indented;
xmlDocument.Save(xmlTextWriter);
xmlTextWriter.Close();
if (notifyUI)
{
InfoDialog(string.Format(Resource.RecipeFileManager_SaveRecipe_RecipeFile0SaveCompleted, recipeName));
}
else
{
EV.PostMessage("System", EventEnum.GeneralInfo, string.Format(Resource.RecipeFileManager_SaveRecipe_RecipeFile0SaveCompleted, recipeName));
}
}
catch (Exception ex)
{
LOG.Write(ex, "保存recipe file 出错");
if (notifyUI)
{
WarningDialog(string.Format(Resource.RecipeFileManager_SaveRecipe_RecipeFile0SaveFailed, recipeName));
}
result = false;
}
return result;
}
public bool CreateFolder(string chamId, string folderName)
{
try
{
if (_recipeSaveInDB)
{
if (!RecipeInfoRecorer.CreateFolder(chamId, folderName))
{
LOG.Write("保存recipe file 到数据库出错");
return false;
}
}
else
{
Directory.CreateDirectory(getRecipeDirPath(chamId) + folderName);
InfoDialog(string.Format(Resource.RecipeFileManager_CreateFolder_RecipeFolder0Created, folderName));
}
}
catch (Exception ex)
{
LOG.Write(ex, "create recipe folder failed");
WarningDialog(string.Format(Resource.RecipeFileManager_CreateFolder_RecipeFolder0CreateFailed, folderName));
return false;
}
return true;
}
public bool RenameFolder(string chamId, string oldName, string newName)
{
try
{
string sourceDirName = getRecipeDirPath(chamId) + oldName;
string destDirName = getRecipeDirPath(chamId) + newName;
Directory.Move(sourceDirName, destDirName);
InfoDialog(string.Format(Resource.RecipeFileManager_RenameFolder_RecipeFolder0renamed, oldName, newName));
}
catch (Exception ex)
{
LOG.Write(ex, "Rename recipe folder failed");
WarningDialog(string.Format(Resource.RecipeFileManager_RenameFolder_RecipeFolder0RenameFailed, oldName, newName));
return false;
}
return true;
}
private string GetRecipeBody(string chamberId, string nodePath)
{
if (_rcpContext == null)
{
return string.Empty;
}
string recipeDefiniton = _rcpContext.GetRecipeDefiniton(chamberId);
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml(recipeDefiniton);
XmlNode xmlNode = xmlDocument.SelectSingleNode(nodePath);
return xmlNode.OuterXml;
}
public string GetRecipeFormatXml(string chamberId)
{
return GetRecipeBody(chamberId, "/Aitex/TableRecipeFormat");
}
public string GetRecipeTemplate(string chamberId)
{
if (_rcpContext != null)
{
return _rcpContext.GetRecipeTemplate(chamberId);
}
return GetRecipeBody(chamberId, "/Aitex/TableRecipeData");
}
public string GetRecipeSchema(string chamberId)
{
if (_rcpContext == null)
{
return string.Empty;
}
string recipeDefiniton = _rcpContext.GetRecipeDefiniton(chamberId);
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml(recipeDefiniton);
XmlNode xmlNode = xmlDocument.SelectSingleNode("/Aitex/TableRecipeSchema");
return xmlNode.InnerXml;
}
public string GetRecipeByBarcode(string chamberId, string barcode)
{
try
{
string text = PathManager.GetRecipeDir() + chamberId + "\\";
DirectoryInfo directoryInfo = new DirectoryInfo(text);
FileInfo[] files = directoryInfo.GetFiles("*.rcp", SearchOption.AllDirectories);
XmlDocument xmlDocument = new XmlDocument();
FileInfo[] array = files;
foreach (FileInfo fileInfo in array)
{
string text2 = fileInfo.FullName.Substring(text.Length);
if (!text2.Contains("HistoryRecipe\\"))
{
xmlDocument.Load(fileInfo.FullName);
if (xmlDocument.SelectSingleNode($"/TableRecipeData[@Barcode='{barcode}']") != null)
{
return text2.Substring(0, text2.LastIndexOf('.'));
}
}
}
return string.Empty;
}
catch (Exception ex)
{
LOG.Write(ex);
return string.Empty;
}
}
private string GetSequenceConfig(string nodePath)
{
if (_seqContext == null)
{
return string.Empty;
}
string configXml = _seqContext.GetConfigXml();
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml(configXml);
XmlNode xmlNode = xmlDocument.SelectSingleNode(nodePath);
return xmlNode.OuterXml;
}
public string GetSequence(string sequenceName, bool needValidation, bool isLoadAnother = false)
{
string text = string.Empty;
try
{
bool flag = _recipeSaveInDB;
if (isLoadAnother)
{
flag = !_recipeSaveInDB;
}
if (flag)
{
return SequenceInfoRecorder.GetSequenceInfoByFileName(sequenceName);
}
using (StreamReader streamReader = new StreamReader(GenerateSequenceFilePath("Sequence", sequenceName)))
{
text = streamReader.ReadToEnd();
streamReader.Close();
}
if (needValidation && !_seqContext.Validation(text))
{
EV.PostWarningLog("Recipe", "Read " + sequenceName + " failed, validation failed");
text = string.Empty;
}
}
catch (Exception ex)
{
LOG.Write(ex);
EV.PostWarningLog("Recipe", "Read " + sequenceName + " failed, " + ex.Message);
text = string.Empty;
}
return text;
}
public List<string> GetSequenceNameList()
{
List<string> list = new List<string>();
try
{
if (_recipeSaveInDB)
{
DataTable allData = SequenceInfoRecorder.GetAllData();
if (allData != null && allData.Rows.Count > 0)
{
for (int i = 0; i < allData.Rows.Count; i++)
{
string text = allData.Rows[i]["seqName"].ToString();
int num = text.IndexOf(".seq");
if (num > 0)
{
text = text.Substring(0, num);
if (!list.Contains(text))
{
list.Add(text);
}
}
}
}
}
else
{
string text2 = PathManager.GetRecipeDir() + "Sequence\\";
DirectoryInfo directoryInfo = new DirectoryInfo(text2);
FileInfo[] files = directoryInfo.GetFiles("*.seq", SearchOption.AllDirectories);
FileInfo[] array = files;
foreach (FileInfo fileInfo in array)
{
string text3 = fileInfo.FullName.Substring(text2.Length);
text3 = text3.Substring(0, text3.LastIndexOf('.'));
list.Add(text3);
}
}
}
catch (Exception ex)
{
LOG.Write(ex);
EV.PostWarningLog("Recipe", "Get sequence list failed, " + ex.Message);
}
return list;
}
public bool DeleteSequence(string sequenceName)
{
try
{
if (_recipeSaveInDB)
{
SequenceInfoRecorder.DeleteByFileName(sequenceName);
}
else
{
File.Delete(GenerateSequenceFilePath("Sequence", sequenceName));
EV.PostInfoLog("Recipe", "sequence " + sequenceName + " deleted");
}
}
catch (Exception ex)
{
LOG.Write(ex);
EV.PostWarningLog("Recipe", "delete " + sequenceName + " failed, " + ex.Message);
return false;
}
return true;
}
public bool SaveSequence(string sequenceName, string sequenceContent, bool notifyUI)
{
bool result = true;
try
{
if (_recipeSaveInDB)
{
result = SequenceInfoRecorder.WriteSequenceInfo(sequenceName, sequenceContent);
}
else
{
string text = GenerateSequenceFilePath("Sequence", sequenceName);
FileInfo fileInfo = new FileInfo(text);
if (!fileInfo.Directory.Exists)
{
fileInfo.Directory.Create();
}
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml(sequenceContent);
XmlTextWriter xmlTextWriter = new XmlTextWriter(text, null);
xmlTextWriter.Formatting = Formatting.Indented;
xmlDocument.Save(xmlTextWriter);
xmlTextWriter.Close();
}
if (notifyUI)
{
EV.PostPopDialogMessage(EventLevel.Information, "Save Complete", "Sequence " + sequenceName + " saved ");
}
else
{
EV.PostInfoLog("Recipe", "Sequence " + sequenceName + " saved ");
}
}
catch (Exception ex)
{
LOG.Write(ex);
EV.PostWarningLog("Recipe", "save sequence " + sequenceName + " failed, " + ex.Message);
if (notifyUI)
{
EV.PostPopDialogMessage(EventLevel.Alarm, "Save Error", "save sequence " + sequenceName + " failed, " + ex.Message);
}
result = false;
}
return result;
}
public bool SaveAsSequence(string sequenceName, string sequenceContent)
{
string path = GenerateSequenceFilePath("Sequence", sequenceName);
if (File.Exists(path))
{
EV.PostWarningLog("Recipe", "save sequence " + sequenceName + " failed, already exist");
return false;
}
return SaveSequence(sequenceName, sequenceContent, notifyUI: false);
}
public bool RenameSequence(string oldName, string newName)
{
try
{
if (_recipeSaveInDB)
{
SequenceInfoRecorder.RenameFileName(oldName, newName);
return true;
}
if (File.Exists(GenerateSequenceFilePath("Sequence", newName)))
{
EV.PostWarningLog("Recipe", newName + " already exist, rename failed");
return false;
}
File.Move(GenerateSequenceFilePath("Sequence", oldName), GenerateSequenceFilePath("Sequence", newName));
EV.PostInfoLog("Recipe", "sequence " + oldName + " renamed to " + newName);
}
catch (Exception ex)
{
LOG.Write(ex);
EV.PostWarningLog("Recipe", "rename " + oldName + " failed, " + ex.Message);
return false;
}
return true;
}
public string GetSequenceFormatXml()
{
return GetSequenceConfig("/Aitex/TableSequenceFormat");
}
internal bool DeleteSequenceFolder(string folderName)
{
try
{
Directory.Delete(PathManager.GetRecipeDir() + "Sequence\\" + folderName, recursive: true);
EV.PostInfoLog("Recipe", "Folder " + folderName + "deleted");
}
catch (Exception ex)
{
LOG.Write(ex, "delete sequence folder exception");
EV.PostWarningLog("Recipe", "can not delete folder " + folderName + ", " + ex.Message);
return false;
}
return true;
}
internal bool CreateSequenceFolder(string folderName)
{
try
{
Directory.CreateDirectory(PathManager.GetRecipeDir() + "Sequence\\" + folderName);
EV.PostInfoLog("Recipe", "Folder " + folderName + "created");
}
catch (Exception ex)
{
LOG.Write(ex, "sequence folder create exception");
EV.PostWarningLog("Recipe", "can not create folder " + folderName + ", " + ex.Message);
return false;
}
return true;
}
internal bool RenameSequenceFolder(string oldName, string newName)
{
try
{
string sourceDirName = PathManager.GetRecipeDir() + "Sequence\\" + oldName;
string destDirName = PathManager.GetRecipeDir() + "Sequence\\" + newName;
Directory.Move(sourceDirName, destDirName);
EV.PostInfoLog("Recipe", "rename folder from " + oldName + " to " + newName);
}
catch (Exception ex)
{
LOG.Write(ex, "rename sequence folder failed");
EV.PostWarningLog("Recipe", "can not rename folder " + oldName + ", " + ex.Message);
return false;
}
return true;
}
public string GetXmlSequenceList(string chamberId)
{
XmlDocument xmlDocument = new XmlDocument();
DirectoryInfo currentDir = new DirectoryInfo(PathManager.GetRecipeDir() + "Sequence\\");
xmlDocument.AppendChild(GenerateSequenceList(chamberId, currentDir, xmlDocument));
return xmlDocument.OuterXml;
}
private XmlElement GenerateSequenceList(string chamberId, DirectoryInfo currentDir, XmlDocument doc)
{
int length = (PathManager.GetRecipeDir() + "Sequence\\").Length;
XmlElement xmlElement = doc.CreateElement("Folder");
xmlElement.SetAttribute("Name", currentDir.FullName.Substring(length));
DirectoryInfo[] directories = currentDir.GetDirectories();
DirectoryInfo[] array = directories;
foreach (DirectoryInfo currentDir2 in array)
{
xmlElement.AppendChild(GenerateSequenceList(chamberId, currentDir2, doc));
}
FileInfo[] files = currentDir.GetFiles("*.seq");
FileInfo[] array2 = files;
foreach (FileInfo fileInfo in array2)
{
XmlElement xmlElement2 = doc.CreateElement("File");
string text = fileInfo.FullName.Substring(length).TrimStart('\\');
text = text.Substring(0, text.LastIndexOf("."));
xmlElement2.SetAttribute("Name", text);
xmlElement.AppendChild(xmlElement2);
}
return xmlElement;
}
}
}