public void SerializeSettings()
{
Settings.Settings settings = new Settings.Settings
{
Languages = new List<Language> {Misc.GetLanguageSlovenian()},
};
XmlSerialization xmlSerialization = new XmlSerialization();
xmlSerialization.Serialize(settings, FileName);
}
} // LoadFromXmlFile
public static RecordTask LoadFromXmlString(string xmlText)
{
return(XmlSerialization.DeserializeXmlText <RecordTask>(xmlText));
} // LoadFromXmlFile
public void DeserializeSettings()
{
XmlSerialization xmlSerialization = new XmlSerialization();
Settings.Settings settings = xmlSerialization.Deserialize(new Settings.Settings(), FileName);
Assert.IsNotNull(settings);
}
internal static User XmlDeserialize(XElement payload)
{
var result = new User();
var deserializeId = XmlSerialization.ToDeserializer(e => (long?)e);
long?resultId;
if (deserializeId(payload, "id", out resultId))
{
result.Id = resultId;
}
var deserializeUsername = XmlSerialization.ToDeserializer(e => (string)e);
string resultUsername;
if (deserializeUsername(payload, "username", out resultUsername))
{
result.Username = resultUsername;
}
var deserializeFirstName = XmlSerialization.ToDeserializer(e => (string)e);
string resultFirstName;
if (deserializeFirstName(payload, "firstName", out resultFirstName))
{
result.FirstName = resultFirstName;
}
var deserializeLastName = XmlSerialization.ToDeserializer(e => (string)e);
string resultLastName;
if (deserializeLastName(payload, "lastName", out resultLastName))
{
result.LastName = resultLastName;
}
var deserializeEmail = XmlSerialization.ToDeserializer(e => (string)e);
string resultEmail;
if (deserializeEmail(payload, "email", out resultEmail))
{
result.Email = resultEmail;
}
var deserializePassword = XmlSerialization.ToDeserializer(e => (string)e);
string resultPassword;
if (deserializePassword(payload, "password", out resultPassword))
{
result.Password = resultPassword;
}
var deserializePhone = XmlSerialization.ToDeserializer(e => (string)e);
string resultPhone;
if (deserializePhone(payload, "phone", out resultPhone))
{
result.Phone = resultPhone;
}
var deserializeUserStatus = XmlSerialization.ToDeserializer(e => (int?)e);
int?resultUserStatus;
if (deserializeUserStatus(payload, "userStatus", out resultUserStatus))
{
result.UserStatus = resultUserStatus;
}
return(result);
}
public static bool RedConfigFile()
{
int i = 0;
for (i = 0; i < iCliCnt; i++)
{
cAct[i] = new cMotion(i);
cPrd[i] = new cRun(i);
}
try
{
#region initialize parameter file name
lstDIOFile.Add(Application.StartupPath + "\\Config\\DIO1.xml");
lstDIOFile.Add(Application.StartupPath + "\\Config\\DIO2.xml");
lstParaFile.Add(Application.StartupPath + "\\Config\\Para1.xml");
lstParaFile.Add(Application.StartupPath + "\\Config\\Para2.xml");
lstErrMsgFile.Add(Application.StartupPath + "\\Config\\ErrMsg1.xml");
lstErrMsgFile.Add(Application.StartupPath + "\\Config\\ErrMsg2.xml");
//lstPointFile.Add(Application.StartupPath + "\\Config\\Point1.xml");
//lstPointFile.Add(Application.StartupPath + "\\Config\\Point2.xml");
// lstProfileFile.Add(Application.StartupPath + "\\Config\\Profile1.xml");
//lstProfileFile.Add(Application.StartupPath + "\\Config\\Profile2.xml");
//lstPlcRegFile.Add(Application.StartupPath + "\\Config\\PlcConfig.xml");
#endregion
//CreateIniParaFile();
#region Read IO config
for (i = 0; i < iCliCnt; i++)
{
if (System.IO.File.Exists(lstDIOFile[i]))
{
cDIO[i] = XmlSerialization.DeserializeObjectFromFile <DIOItem>(lstDIOFile[i]);
if (cDIO[i] == null)
{
cBase.ShowNormalMessage((int)cBase.MsgType.EXCEPTION, "读取文件失败：\r\n" + lstDIOFile[i]);
return(false);
}
}
}
#endregion
#region Read Para config
for (i = 0; i < iCliCnt; i++)
{
if (System.IO.File.Exists(lstParaFile[i]))
{
cPara[i] = XmlSerialization.DeserializeObjectFromFile <ParaItem>(lstParaFile[i]);
if (cPara[i] == null)
{
cBase.ShowNormalMessage((int)cBase.MsgType.EXCEPTION, "读取文件失败：\r\n" + lstParaFile[i]);
return(false);
}
for (int k = 0; k < cBase.cPara[i].ParaSet.Count(); k++)
{
if (cBase.cPara[i].ParaSet[k].Name.Trim().ToUpper().Equals(cBase.LOCPARA.LINE_WAIT.ToString()))
{
cBase.iLineWaitTime = int.Parse(cBase.cPara[i].ParaSet[k].Value);
break;
}
}
}
}
#endregion
#region Read ErrMsg config
for (i = 0; i < iCliCnt; i++)
{
if (System.IO.File.Exists(lstErrMsgFile[i]))
{
cErrMsg[i] = XmlSerialization.DeserializeObjectFromFile <ErrMsgItem>(lstErrMsgFile[i]);
if (cErrMsg[i] == null)
{
cBase.ShowNormalMessage((int)cBase.MsgType.EXCEPTION, "读取文件失败：\r\n" + lstErrMsgFile[i]);
return(false);
}
}
}
#endregion
#region Read Point config
//for (i = 0; i < iCliCnt; i++)
//{
// if (System.IO.File.Exists(lstPointFile[i]))
// {
// cPoint[i] = XmlSerialization.DeserializeObjectFromFile<PointItem>(lstPointFile[i]);
// if (cPoint[i] == null)
// {
// cBase.ShowNormalMessage((int)cBase.MsgType.EXCEPTION, "读取文件失败：\r\n" + lstPointFile[i]);
// return false;
// }
// }
//}
//for (i = 0; i < iCliCnt; i++)
//{
// if (System.IO.File.Exists(lstProfileFile[i]))
// {
// cProfile[i] = XmlSerialization.DeserializeObjectFromFile<ProfileItem>(lstProfileFile[i]);
// if (cProfile[i] == null)
// {
// cBase.ShowNormalMessage((int)cBase.MsgType.EXCEPTION, "读取文件失败：\r\n" + lstProfileFile[i]);
// return false;
// }
// }
//}
#endregion
#region Red PLC file
//if (System.IO.File.Exists(lstPlcRegFile[0]))
//{
// cReg = XmlSerialization.DeserializeObjectFromFile<RegItem>(lstPlcRegFile[0]);
// if (cReg == null)
// {
// cBase.ShowNormalMessage((int)cBase.MsgType.EXCEPTION, "读取文件失败：\r\n" + lstPlcRegFile[0]);
// return false;
// }
//}
#endregion
}
catch (Exception ex)
{
cBase.ShowNormalMessage((int)cBase.MsgType.EXCEPTION, "RedConfigFile-:" + ex.Message.ToString());
}
return(true);
}
private static (List <string> fileList, QcDataCollection qcDataCollection) GetFileListAndQcFile(WorkflowParameters parameters, bool subdirectoriesIncluded)
{
QcDataCollection qcDataCollection;
string dataDirectory = parameters.RawFileDirectory;
string qcDirectory = parameters.QcParams.QcDirectory;
string qcSearchDataDirecotry = parameters.QcParams.QcSearchDataDirectory;
SearchParameters searchParameters = parameters.QcParams.SearchParameters;
// our qc file
string qcFile = Path.Combine(qcDirectory, "QC.xml");
// see if the file exists
if (File.Exists(qcFile))
{
// if so, open it
try
{
qcDataCollection = XmlSerialization.ReadFromXmlFile <QcDataCollection>(qcFile);
Log.Information("QC data file loaded successfully");
}
catch (Exception e)
{
Log.Error(e, "Failed while loading QC data");
throw e;
}
}
else
{
// if not, check if the directory exists
if (!Directory.Exists(qcDirectory))
{
Directory.CreateDirectory(qcDirectory);
}
qcDataCollection = new QcDataCollection(dataDirectory, qcDirectory, parameters.ExpType);
Log.Information("Appears to be a new QC directory. New QC data collection created.");
}
// get our list of new raw files. it is every raw file in the directory that is not listed in the qc data
List <string> fileList;
if (subdirectoriesIncluded)
{
fileList = Directory.GetFiles(dataDirectory, "*.*", SearchOption.AllDirectories)
.Where(s => s.EndsWith(".raw", StringComparison.OrdinalIgnoreCase)).ToList();
}
else
{
fileList = Directory.GetFiles(dataDirectory, "*.*", SearchOption.TopDirectoryOnly)
.Where(s => s.EndsWith(".raw", StringComparison.OrdinalIgnoreCase)).ToList();
}
// make sure we've got absolute paths to the files
fileList.EnsureAbsolutePaths();
if (fileList.Count() == 0)
{
Log.Error("No raw files found in {Directory}", dataDirectory);
Console.WriteLine("{0} contains no raw files!", dataDirectory);
Environment.Exit(1);
}
fileList.RemoveAll(s => qcDataCollection.ProcessedRawFiles.Contains(Path.GetFileName(s)));
Log.Information("Raw files in QC queue: {Files}", fileList);
if (fileList.Count() == 0)
{
Log.Information("No new files to QC");
Console.WriteLine("No new files in the directory to QC!");
Environment.Exit(0);
}
Console.WriteLine("{0} file(s) to process", fileList.Count());
return(fileList, qcDataCollection);
}
/// <summary>
/// Save app settings.
/// </summary>
public static void Save()
{
XmlSerialization.Serialize(AppSetting.Settings, Model.AppSetting.GetPath());
}
} // constructor
public void SaveXml <T>(string documentType, string name, int version, T xmlTree) where T : class
{
var path = Path.Combine(BaseDirectory, GetSafeDocumentName(documentType, name, ".xml"));
XmlSerialization.Serialize(path, Encoding.UTF8, xmlTree);
} // SaveXml
/// <summary>
/// retrieve _retyrnType and parameters
/// </summary>
private void getSignature()
{
if (string.IsNullOrEmpty(_methodName))
{
throw new MathException("Accessing getSignature with empty method name");
}
if (_methodOwnerObjectRef == null)
{
throw new MathException("Accessing getSignature with null owner");
}
if (_methodOwnerObjectRef.Type == ObjectRefType.Type)
{
Type t = _methodOwnerObjectRef.Value.LibType;
MethodInfo mi = t.GetMethod(_methodName);
if (mi == null)
{
throw new MathException("Accessing getSignature with invalid method name '{0}'", _methodName);
}
getSignature(mi);
}
else if (_methodOwnerObjectRef.Type == ObjectRefType.Field || _methodOwnerObjectRef.Type == ObjectRefType.Property)
{
if (_methodOwnerObjectRef.Owner.Type == ObjectRefType.XPath)
{
}
else if (_methodOwnerObjectRef.Owner.Type == ObjectRefType.Type)
{
MethodInfo mi = null;
Type t = _methodOwnerObjectRef.Owner.Value.LibType;
if (_methodOwnerObjectRef.Type == ObjectRefType.Field)
{
FieldInfo fi = t.GetField(_methodOwnerObjectRef.Name);
if (fi == null)
{
throw new MathException(XmlSerialization.FormatString("Accessing getSignature for Field with invalid field name {0} for type {1}", _methodOwnerObjectRef.Name, t));
}
mi = fi.FieldType.GetMethod(_methodName);
if (mi == null)
{
throw new MathException(XmlSerialization.FormatString("Accessing getSignature for Field with invalid method name {0} for field name {1} and type {2}", _methodName, _methodOwnerObjectRef.Name, t));
}
}
else if (_methodOwnerObjectRef.Type == ObjectRefType.Property)
{
PropertyInfo pi = t.GetProperty(_methodOwnerObjectRef.Name);
if (pi == null)
{
throw new MathException(XmlSerialization.FormatString("Accessing getSignature for Property with invalid property name {0} for type {1}", _methodOwnerObjectRef.Name, t));
}
mi = pi.PropertyType.GetMethod(_methodName);
if (mi == null)
{
throw new MathException(XmlSerialization.FormatString("Accessing getSignature for Property with invalid method name {0} for Property name {1} and type {2}", _methodName, _methodOwnerObjectRef.Name, t));
}
}
getSignature(mi);
}
throw new MathException(XmlSerialization.FormatString("Accessing getSignature for Field. Owner type {0} not implemented", _methodOwnerObjectRef.Owner.Type));
}
else if (_methodOwnerObjectRef.Type == ObjectRefType.XPath)
{
XmlDocument doc = _methodOwnerObjectRef.GetXmlDocument();
if (doc == null)
{
throw new MathException("Accessing getSignature with null document");
}
XmlNode prj = XmlSerialization.GetProjectNode(doc);
if (prj == null)
{
throw new MathException("Accessing getSignature with null project");
}
XmlNode ownNode = prj.SelectSingleNode(_methodOwnerObjectRef.XPath);
if (ownNode == null)
{
throw new MathException(XmlSerialization.FormatString("Accessing getSignature with invalid xpath {0}", _methodOwnerObjectRef.XPath));
}
if (_methodName == XmlSerialization.CONSTRUCTOR_METHOD)
{
throw new MathException("Accessing getSignature when the method is a constructor");
}
XmlNode methodNode = ownNode.SelectSingleNode(XmlSerialization.FormatString("{0}[@{1}='{2}']",
XmlSerialization.XML_METHOD, XmlSerialization.XMLATT_NAME, _methodName));
if (methodNode == null)
{
Type t = XmlSerialization.GetObjectLibType(ownNode);
if (t == null)
{
throw new MathException(XmlSerialization.FormatString("Accessing getSignature with valid xpath {0} but method name {1} not found and owner library type not found", _methodOwnerObjectRef.XPath, _methodName));
}
MethodInfo mif = t.GetMethod(_methodName);
if (mif == null)
{
throw new MathException(XmlSerialization.FormatString("Accessing getSignature with valid xpath {0} but method name {1} not found in owner library type {2}", _methodOwnerObjectRef.XPath, _methodName, t.Name));
}
getSignature(mif);
}
else
{
MethodType mt = new MethodType();
mt.OnReadFromXmlNode(null, methodNode);
_retType = mt.ReturnType;
Parameter[] ps = mt.Parameters;
if (ps != null && ps.Length > 0)
{
_parameters = new ParameterDef[ps.Length];
for (int i = 0; i < ps.Length; i++)
{
_parameters[i] = new ParameterDef(ps[i]);
}
}
}
}
throw new MathException(XmlSerialization.FormatString("Accessing getSignature: type not implemented: {0}", _methodOwnerObjectRef.Type));
}
public static void DoQc(QcParameters qcParameters)
{
QcDataCollection qcDataCollection;
string dataDirectory = qcParameters.RawFileDirectory;
string qcDirectory = qcParameters.QcDirectory;
string qcSearchDataDirecotry = qcParameters.QcSearchDataDirectory;
SearchParameters searchParameters = qcParameters.searchParameters;
// our qc file
string qcFile = Path.Combine(qcDirectory, "QC.xml");
// see if the file exists
if (File.Exists(qcFile))
{
// if so, open it
try
{
qcDataCollection = XmlSerialization.ReadFromXmlFile <QcDataCollection>(qcFile);
Log.Information("QC data file loaded successfully");
}
catch (Exception e)
{
Log.Error(e, "Failed while loading QC data");
throw e;
}
}
else
{
// if not, check if the directory exists
if (!Directory.Exists(qcDirectory))
{
Directory.CreateDirectory(qcDirectory);
}
qcDataCollection = new QcDataCollection(dataDirectory, qcDirectory);
Log.Information("Appears to be a new QC directory. New QC data collection created.");
}
// get our list of new raw files. it is every raw file in the directory that is not listed in the qc data
var fileList = Directory.GetFiles(dataDirectory, "*.*", SearchOption.TopDirectoryOnly)
.Where(s => s.EndsWith(".raw", StringComparison.OrdinalIgnoreCase)).ToList();
if (fileList.Count() == 0)
{
Log.Error("No raw files found in {Directory}", dataDirectory);
Console.WriteLine("{0} contains no raw files!", dataDirectory);
Environment.Exit(1);
}
fileList.RemoveAll(s => qcDataCollection.ProcessedRawFiles.Contains(Path.GetFileName(s)));
Log.Information("Raw files in QC queue: {Files}", fileList);
if (fileList.Count() == 0)
{
Log.Information("No new files to QC");
Console.WriteLine("No new files in the directory to QC!");
Environment.Exit(0);
}
Console.WriteLine("{0} file(s) to process", fileList.Count());
foreach (string fileName in fileList)
{
Console.WriteLine("Processing {0}", fileName);
IFileHeader rawHeader;
// try to open the raw file header
try
{
rawHeader = FileHeaderReaderFactory.ReadFile(fileName);;
}
catch (Exception)
{
Log.Information("{File} is not a valid raw file", fileName);
Console.WriteLine("{0} is not a valid raw file, continuing to next file.", fileName);
continue;
}
// is it a real raw file?
if (rawHeader.FileType == FileType.RawFile)
{
Log.Information("{File} is a valid raw file", fileName);
Log.Information("Creation date: {Date}", rawHeader.CreationDate);
Log.Information("File description: {Description}", rawHeader.FileDescription);
}
else
{
Log.Information("{File} is not a valid raw file", fileName);
Console.WriteLine("{0} is not a valid raw file, continuing to next file.", fileName);
continue;
}
// okay, it is probably a real raw file, let's do the QC
// check if the raw file already exists in the QC data with a different name
if (qcDataCollection.QcData.Keys.Contains(rawHeader.CreationDate))
{
Log.Information("A file with the same creation date and time as {File} already exists in the QC data", fileName);
Console.WriteLine("{0} appears to already exist in the QC data with the name {1}. Skipping to next file.",
fileName, qcDataCollection.QcData[rawHeader.CreationDate].RawFile);
continue;
}
using (IRawDataPlus rawFile = RawFileReaderFactory.ReadFile(fileName))
{
rawFile.SelectInstrument(Device.MS, 1);
RawDataCollection rawData = new RawDataCollection(rawFile);
rawData.ExtractAll(rawFile);
/*
* if (idpyPars?.QuantMods != null)
* {
* rawData.quantData.Quantify(rawData, rawFile, )
* }
*/
QcDataContainer newQcData = ProcessQcData(Data: qcDataCollection, rawData: rawData, rawFile: rawFile, qcDirectory: qcDirectory);
if (searchParameters != null)
{
Search.WriteSearchMGF(qcParameters, rawData, rawFile, searchParameters.FixedScans);
Search.RunSearch(qcParameters, rawData, rawFile);
newQcData.ParseSearchResults(rawData, rawFile, qcParameters);
/*
* if (searchParameters.SearchAlgorithm == SearchAlgorithm.XTandem)
* {
* SearchQC.ParseXTandem(newQcData, qcParameters);
* newQcData.IdentipyParameters = String.Format("\"Algorithm: X!Tandem; fmods: {0}; nmod: {1}; kmod: {2}; xmod: {3}; fastaDB: {4}; xtandemDirectory: {5}\"",
* searchParameters.FixedMods, searchParameters.NMod, searchParameters.KMod, searchParameters.XMod, searchParameters.FastaDatabase, searchParameters.XTandemDirectory);
* }
* else
* {
* SearchQC.ParseIdentipy(newQcData, rawData, rawFile, qcParameters);
* newQcData.IdentipyParameters = String.Format("\"Algorithm: IdentiPy; fmods: {0}; nmod: {1}; kmod: {2}; xmod: {3}; fastaDB: {4}; pythonExecutable: {5}; identipyScript: {6}\"",
* searchParameters.FixedMods, searchParameters.NMod, searchParameters.KMod, searchParameters.XMod, searchParameters.FastaDatabase, searchParameters.PythonExecutable, searchParameters.IdentipyScript);
* }
*/
}
qcDataCollection.QcData.Add(rawFile.CreationDate, newQcData);
qcDataCollection.ProcessedRawFiles.Add(Path.GetFileName(rawData.rawFileName));
qcDataCollection.WriteQcToTable();
}
Log.Information("QC finished: {File}", fileName);
}
Log.Information("QC of all files completed");
Console.WriteLine("QC of all files completed!");
try
{
XmlSerialization.WriteToXmlFile <QcDataCollection>(qcFile, qcDataCollection);
Log.Information("QC file saved successfully");
Console.WriteLine("QC file saved successfully");
}
catch (Exception e)
{
Log.Error(e, "Failed during serialization of QC data");
throw e;
}
}
public void TestLoadFromXmlBad()
{
string xml = @"<Person></Person>";
Person person = XmlSerialization.LoadFromXml <Person>(xml);
}
public void Save(string filename)
{
XmlSerialization.SaveToXml(this, filename, SettingsVersion);
}
} // SaveTo
public static void SaveTo(this RecordTask task, XmlWriter writer)
{
XmlSerialization.Serialize(writer, task);
} // SaveTo
} // SaveToXmlFile
public static void SaveTo(this RecordTask task, Stream stream)
{
XmlSerialization.Serialize(stream, task);
} // SaveTo
} // SaveTo
public static void SaveToXmlFile(this RecordTask task, string filename)
{
XmlSerialization.Serialize(filename, task);
} // SaveToXmlFile
private static Config DeserializeConfig()
{
return(XmlSerialization.Deserialize <Config>(ConfigFilename));
}
public void SaveToXml()
{
XmlSerialization xml = new XmlSerialization(this);
}
/// <summary>
///
/// </summary>
/// <param name="previousAction"></param>
/// <param name="nextAction"></param>
/// <param name="compiler"></param>
/// <param name="method"></param>
/// <param name="statements"></param>
/// <returns></returns>
public override bool OnExportCode(ActionBranch previousAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, CodeMemberMethod method, CodeStatementCollection statements)
{
if (IsCompiled)
{
return(false);
}
//preventing of compiling it twice
IsCompiled = true;
if (_ifActions != null && _elseActions != null && _ifActions.BranchId == _elseActions.BranchId)
{
throw new DesignerException("'Cast as' action [{0}, {1}] goes to the same action", this.BranchId, this.Name);
}
bool isGotoPoint = this.IsGotoPoint;
MethodSegment ms0 = null;
CodeStatementCollection sts = statements;
if (isGotoPoint)
{
//two or more branches in the same thread linked to this branch
//since goto-label must be in the method scope, not sub-scope, this branch code must be
//in the method scope
ms0 = CompilerUtil.GetGotoBranch(method, Method, this.FirstActionId);
if (ms0 == null)
{
sts = new CodeStatementCollection();
ms0 = new MethodSegment(sts);
CompilerUtil.AddGotoBranch(method, Method, this.FirstActionId, ms0, this.GroupBranchId);
}
else
{
throw new DesignerException("Action list as goto branch {0} compiled twice", this.FirstActionId);
}
//use goto statement to jump to this branch is the responsibility of the branches jumping to it.
}
if (this.IsWaitingPoint)
{
sts.Add(new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(WaitHandle)), "WaitAll",
new CodeVariableReferenceExpression(XmlSerialization.FormatString("wh_{0}_{1}",
IdToKey(this.StartingBranchId), this.BranchKey)))));
}
try
{
CodeExpression c;
if (_source == null || _target == null)
{
c = new CodePrimitiveExpression(false);
}
else
{
StringBuilder sb = new StringBuilder();
sb.Append(_source.CodeName);
sb.Append(" as ");
sb.Append(_target.BaseClassType.FullName);
CodeAssignStatement cas = new CodeAssignStatement();
cas.Left = new CodeVariableReferenceExpression(_target.CodeName);
cas.Right = new CodeSnippetExpression(sb.ToString());
sts.Add(cas);
CodeBinaryOperatorExpression cb = new CodeBinaryOperatorExpression();
cb.Left = new CodeVariableReferenceExpression(_target.CodeName);
cb.Operator = CodeBinaryOperatorType.IdentityInequality;
cb.Right = new CodePrimitiveExpression(null);
c = cb;
}
bool b1 = false;
bool b2 = false;
CodeConditionStatement ccs = new CodeConditionStatement();
ccs.Condition = c;
if (_ifActions != null)
{
if (_ifActions.IsGotoPoint)
{
CodeGotoStatement gotoCode = new CodeGotoStatement(ActionBranch.IdToLabel(_ifActions.FirstActionId));
ccs.TrueStatements.Add(gotoCode);
if (!_ifActions.IsCompiled)
{
_ifActions.ExportCode(null, null, compiler, method, null);
}
b1 = true;
}
else
{
b1 = _ifActions.ExportCode(previousAction, null, compiler, method, ccs.TrueStatements);
}
}
if (_elseActions != null)
{
if (_elseActions.IsGotoPoint)
{
CodeGotoStatement gotoCode = new CodeGotoStatement(ActionBranch.IdToLabel(_elseActions.FirstActionId));
ccs.FalseStatements.Add(gotoCode);
if (!_elseActions.IsCompiled)
{
_elseActions.ExportCode(null, null, compiler, method, null);
}
b2 = true;
}
else
{
b2 = _elseActions.ExportCode(previousAction, null, compiler, method, ccs.FalseStatements);
}
}
sts.Add(ccs);
if (b1 && b2)
{
if (ms0 != null)
{
ms0.Completed = true;
}
return(true);
}
}
catch (Exception err)
{
throw new DesignerException(err, "Error compiling Condition action {0}. See inner exception for details", TraceInfo);
}
return(false);
}
internal static Pet XmlDeserialize(XElement payload)
{
var result = new Pet();
var deserializeId = XmlSerialization.ToDeserializer(e => (long?)e);
long?resultId;
if (deserializeId(payload, "id", out resultId))
{
result.Id = resultId;
}
var deserializeCategory = XmlSerialization.ToDeserializer(e => Category.XmlDeserialize(e));
Category resultCategory;
if (deserializeCategory(payload, "category", out resultCategory))
{
result.Category = resultCategory;
}
var deserializeName = XmlSerialization.ToDeserializer(e => (string)e);
string resultName;
if (deserializeName(payload, "name", out resultName))
{
result.Name = resultName;
}
var deserializePhotoUrls = XmlSerialization.CreateListXmlDeserializer(XmlSerialization.ToDeserializer(e => (string)e), "photoUrl");
IList <string> resultPhotoUrls;
if (deserializePhotoUrls(payload, "photoUrl", out resultPhotoUrls))
{
result.PhotoUrls = resultPhotoUrls;
}
var deserializeTags = XmlSerialization.CreateListXmlDeserializer(XmlSerialization.ToDeserializer(e => Tag.XmlDeserialize(e)), "tag");
IList <Tag> resultTags;
if (deserializeTags(payload, "tag", out resultTags))
{
result.Tags = resultTags;
}
var deserializeSByteProperty = XmlSerialization.ToDeserializer(e => System.Convert.FromBase64String(e.Value));
byte[] resultSByteProperty;
if (deserializeSByteProperty(payload, "sByte", out resultSByteProperty))
{
result.SByteProperty = resultSByteProperty;
}
var deserializeBirthday = XmlSerialization.ToDeserializer(e => (System.DateTime?)e);
System.DateTime?resultBirthday;
if (deserializeBirthday(payload, "birthday", out resultBirthday))
{
result.Birthday = resultBirthday;
}
var deserializeDictionary = XmlSerialization.CreateDictionaryXmlDeserializer(XmlSerialization.ToDeserializer(e => Category.XmlDeserialize(e)));
IDictionary <string, Category> resultDictionary;
if (deserializeDictionary(payload, "dictionary", out resultDictionary))
{
result.Dictionary = resultDictionary;
}
var deserializeStatus = XmlSerialization.ToDeserializer(e => (string)e);
string resultStatus;
if (deserializeStatus(payload, "status", out resultStatus))
{
result.Status = resultStatus;
}
return(result);
}
public override void OnWriteToXmlNode(IXmlCodeWriter serializer, XmlNode node)
{
base.OnWriteToXmlNode(serializer, node);
XmlSerialization.SetAttribute(node, XmlSerialization.XMLATT_ID, PortID.ToString());
XmlSerialization.WriteToUniqueChildXmlNode(serializer, node, ProgramEntity.XML_PortProperty, _property);
}
public void HandleAddedConnection(string[] msg)
{
Connections newConnection = XmlSerialization.DeserializeObject <Connections>(XmlSerialization.GetStringToNormal(msg));
myWindow.myHost.connections.Add(newConnection);
NewLog($"New connection handled", myWindow, "AntiqueWhite");
}
/// <summary>Serializes the workflow to XML. </summary>
/// <returns>The XML. </returns>
public string ToXml()
{
var extraTypes = Activities.Select(a => a.GetType());
return(XmlSerialization.Serialize(this, extraTypes.Distinct().ToArray()));
}
public override void OnReadFromXmlNode(IXmlCodeReader serializer, XmlNode node)
{
_xmlNode = node;
base.OnReadFromXmlNode(serializer, node);
_entity = (IProgramEntity)XmlSerialization.ReadFromChildXmlNode(serializer, node, XML_ENTITY);
}
/// <summary>
/// generate reference code
/// </summary>
/// <param name="methodOwnerXPath"></param>
/// <returns></returns>
public CodeExpression ExportCode(string methodOwnerXPath)
{
MathNode.Trace("ObjectRef.ExportCode for {0}", this);
switch (Type)
{
case ObjectRefType.Argv:
case ObjectRefType.EventSender:
return(new CodeArgumentReferenceExpression(_name));
case ObjectRefType.This:
return(new CodeThisReferenceExpression());
case ObjectRefType.Type:
return(new CodeTypeReferenceExpression(DataType));
case ObjectRefType.Field:
case ObjectRefType.Property:
if (Owner == null)
{
throw new MathException("property reference does not have an owner");
}
return(new CodePropertyReferenceExpression(Owner.ExportCode(methodOwnerXPath), _name));
case ObjectRefType.Const:
if (_value == null)
{
return(new CodePrimitiveExpression(null));
}
else
{
return(ObjectCreationCodeGen.ObjectCreationCode(_value.DataValue));
}
case ObjectRefType.XPath:
if (_xpathNode == null)
{
throw new MathException("ObjectRef.ExportCode is called for XPath with null xpath Node");
}
if (string.IsNullOrEmpty(_name))
{
throw new MathException("ObjectRef.ExportCode is called for XPath with null xpath value");
}
CodeExpression codeExp = new CodeThisReferenceExpression();
if (methodOwnerXPath != _name)
{
//object for the reference
//_name is the xpath
XmlNode thisNode = _xpathNode.OwnerDocument.DocumentElement.SelectSingleNode(_name);
if (thisNode == null)
{
throw new MathException(XmlSerialization.FormatString("ObjectRef.ExportCode is called for XPath with invalid xpath value: {0}", _name));
}
//
if (thisNode.Name == XmlSerialization.RAIS_R)
{
if (XmlSerialization.IsStaticComponent(thisNode))
{
codeExp = new CodeTypeReferenceExpression(TypeString);
}
else
{
//find all names for each part R|A[@ID='?']R|A[@ID='?']...
string xpath0 = _name;
string name = XmlSerialization.GetName(thisNode);
while (xpath0.Length > 0 && xpath0 != methodOwnerXPath)
{
int pos = xpath0.LastIndexOf('/');
if (pos > 0)
{
xpath0 = xpath0.Substring(0, pos);
if (xpath0 != methodOwnerXPath)
{
XmlNode n0 = XmlSerialization.GetXmlNodeByPath(thisNode.OwnerDocument, xpath0);
if (n0 == null)
{
throw new MathException(XmlSerialization.FormatString("Invalid path {0}", xpath0));
}
name = XmlSerialization.GetName(n0) + "." + name;
}
}
else
{
break;
}
}
codeExp = new CodeFieldReferenceExpression(codeExp, name);
}
}
}
else
{
XmlNode thisNode = _xpathNode.OwnerDocument.DocumentElement.SelectSingleNode(_name);
if (thisNode == null)
{
throw new MathException(XmlSerialization.FormatString("ObjectRef.ExportCode is called for XPath with invalid xpath value: {0}", _name));
}
//use the parent node to generate code
if (thisNode.Name == XmlSerialization.RAIS_R)
{
if (XmlSerialization.IsStaticComponent(thisNode))
{
codeExp = new CodeTypeReferenceExpression(TypeString);
}
}
}
return(codeExp);
}
return(new CodeThisReferenceExpression());
}
private static void CreateIniParaFile()
{
#region create config file
//DIO
DIOItem a1 = new DIOItem();
a1.DI = new DINum[1];
a1.DI[0] = new DINum();
a1.DI[0].No = 10001;
a1.DI[0].Name = "1#吸嘴真空已开";
a1.DO = new DONum[1];
a1.DO[0] = new DONum();
a1.DO[0].No = 10002;
a1.DO[0].Name = "1#吸嘴开真空";
XmlSerialization.SerializeObjectToFile(a1, lstDIOFile[0]);
//Para
ParaItem a2 = new ParaItem();
a2.ParaSet = new Para[2];
a2.ParaSet[0] = new Para();
a2.ParaSet[0].Name = "PickOffset";
a2.ParaSet[0].Desc = "1#吸嘴取料偏差";
a2.ParaSet[0].Option = false;
a2.ParaSet[0].Select = "";
a2.ParaSet[0].Value = "0.5";
a2.ParaSet[0].MinValue = "-0.5";
a2.ParaSet[0].MaxValue = "0.5";
a2.ParaSet[1].Name = "VisionName";
a2.ParaSet[1].Desc = "顶部相机图像场景";
a2.ParaSet[1].Option = true;
a2.ParaSet[1].Select = "Prd1,Prd2,Prd3";
a2.ParaSet[1].Value = "Prd1";
a2.ParaSet[1].MinValue = "";
a2.ParaSet[1].MaxValue = "";
XmlSerialization.SerializeObjectToFile(a2, lstParaFile[0]);
//ErrMsg
ErrMsgItem a3 = new ErrMsgItem();
a3.ErrCode = new ErrMsg[1];
a3.ErrCode[0] = new ErrMsg();
a3.ErrCode[0].Code = 2000;
a3.ErrCode[0].Msg = "1#吸嘴真空检测超时";
XmlSerialization.SerializeObjectToFile(a3, lstErrMsgFile[0]);
//Point
PointItem a4 = new PointItem();
a4.Location = new Point[1];
a4.Location[0] = new Point();
a4.Location[0].Name = "SafePoint";
a4.Location[0].X = 1;
a4.Location[0].Y = 2;
a4.Location[0].Z = 2;
a4.Location[0].Yaw = 2;
a4.Location[0].Pitch = 2;
a4.Location[0].Roll = 2;
a4.Location[0].Config = 2;
XmlSerialization.SerializeObjectToFile(a4, lstPointFile[0]);
//Profile
ProfileItem a5 = new ProfileItem();
a5.MoveProfile = new Profile[1];
a5.MoveProfile[0] = new Profile();
a5.MoveProfile[0].Name = "QuickProfile";
a5.MoveProfile[0].Acc = 1;
a5.MoveProfile[0].AccR = 2;
a5.MoveProfile[0].Dec = 2;
a5.MoveProfile[0].DecR = 2;
a5.MoveProfile[0].Speed = 2;
a5.MoveProfile[0].Speed2 = 2;
a5.MoveProfile[0].InRange = 2;
a5.MoveProfile[0].Straight = false;
XmlSerialization.SerializeObjectToFile(a5, lstProfileFile[0]);
//PLC
RegItem a6 = new RegItem();
a6.PLCReg = new RegNum[1];
a6.PLCReg[0] = new RegNum();
a6.PLCReg[0].No = "M1";
a6.PLCReg[0].Name = "PLC 可以取料";
XmlSerialization.SerializeObjectToFile(a6, lstPlcRegFile[0]);
#endregion
}
public string CreatePhpScript(StringCollection method, string methodOwnerXPath)
{
MathNode.Trace("ObjectRef.CreatePhpScript for {0}", this);
switch (Type)
{
case ObjectRefType.Argv:
case ObjectRefType.EventSender:
return(string.Format(CultureInfo.InvariantCulture, "${0}", _name));
case ObjectRefType.This:
return("$this");
case ObjectRefType.Type:
return(DataType.FullName);
case ObjectRefType.Field:
case ObjectRefType.Property:
if (Owner == null)
{
throw new MathException("property reference does not have an owner");
}
return(MathNode.FormString("{0}->{1}", Owner.CreatePhpScript(method, methodOwnerXPath), _name));
case ObjectRefType.Const:
if (_value == null)
{
return("NULL");
}
else
{
return(_value.DataValue.ToString());
}
case ObjectRefType.XPath:
if (_xpathNode == null)
{
throw new MathException("ObjectRef.ExportCode is called for XPath with null xpath Node");
}
if (string.IsNullOrEmpty(_name))
{
throw new MathException("ObjectRef.ExportCode is called for XPath with null xpath value");
}
string codeExp = "$this";
if (string.CompareOrdinal(methodOwnerXPath, _name) != 0)
{
//object for the reference
//_name is the xpath
XmlNode thisNode = _xpathNode.OwnerDocument.DocumentElement.SelectSingleNode(_name);
if (thisNode == null)
{
throw new MathException(XmlSerialization.FormatString("ObjectRef.ExportCode is called for XPath with invalid xpath value: {0}", _name));
}
//
if (string.CompareOrdinal(thisNode.Name, XmlSerialization.RAIS_R) == 0)
{
if (XmlSerialization.IsStaticComponent(thisNode))
{
codeExp = TypeString;
}
else
{
//find all names for each part R|A[@ID='?']R|A[@ID='?']...
string xpath0 = _name;
string name = XmlSerialization.GetName(thisNode);
while (xpath0.Length > 0 && xpath0 != methodOwnerXPath)
{
int pos = xpath0.LastIndexOf('/');
if (pos > 0)
{
xpath0 = xpath0.Substring(0, pos);
if (xpath0 != methodOwnerXPath)
{
XmlNode n0 = XmlSerialization.GetXmlNodeByPath(thisNode.OwnerDocument, xpath0);
if (n0 == null)
{
throw new MathException(XmlSerialization.FormatString("Invalid path {0}", xpath0));
}
name = MathNode.FormString("{0}->{1}", XmlSerialization.GetName(n0), name);
}
}
else
{
break;
}
}
codeExp = MathNode.FormString("{0}->{1}", codeExp, name);
}
}
}
else
{
XmlNode thisNode = _xpathNode.OwnerDocument.DocumentElement.SelectSingleNode(_name);
if (thisNode == null)
{
throw new MathException(XmlSerialization.FormatString("ObjectRef.CreateJavaScript is called for XPath with invalid xpath value: {0}", _name));
}
//use the parent node to generate code
if (thisNode.Name == XmlSerialization.RAIS_R)
{
if (XmlSerialization.IsStaticComponent(thisNode))
{
codeExp = TypeString;
}
}
}
return(codeExp);
}
return("$this");
}
private void FillLanguage()
{
try
{
XmlSerialization xmlSerialization = new XmlSerialization();
Settings.Settings settings = xmlSerialization.Deserialize(new Settings.Settings(), "settings.xml");
string setting = ConfigurationManager.AppSettings["language"];
language = settings.Languages.Find(l => l.Culture.Equals(setting)) ?? Misc.GetLanguageSlovenian();
//Orders
TabOrders tabOrders = language.TabOrders;
tabPageOrders.Text = tabOrders.Name;
labelOrdersPersonInfo.Text = tabOrders.LabelOrdersPersonInfo;
labelOrdersItemType.Text = tabOrders.LabelOrdersItemType;
labelOrdersItem.Text = tabOrders.LabelOrdersItem;
labelOrdersItemStatus.Text = tabOrders.LabelOrdersItemStatus;
labelOrdersItemCount.Text = tabOrders.LabelOrdersItemCount;
labelOrdersPrice.Text = tabOrders.LabelOrdersPrice;
labelOrdersPostage.Text = tabOrders.LabelOrdersPostage;
labelOrdersTax.Text = tabOrders.LabelOrdersTax;
labelOrdersLegalEntity.Text = tabOrders.LabelOrdersLegalEntity;
labelOrdersPicture.Text = tabOrders.LabelOrdersPicture;
//groupBoxOrders.Text = tabOrders.
groupBoxOrdersList.Text = tabOrders.LabelOrdersList;
buttonOrdersSum.Text = tabOrders.ButtonOrdersSum;
buttonOrdersSave.Text = tabOrders.ButtonOrdersSave;
buttonOrdersUpdate.Text = tabOrders.ButtonOrdersUpdate;
buttonOrdersDelete.Text = tabOrders.ButtonOrdersDelete;
//Items
TabItems tabItems = language.TabItems;
tabPageItems.Text = tabItems.Name;
labelItemsName.Text = tabItems.LabelItemsName;
labelItemsDescription.Text = tabItems.LabelItemsDescription;
labelItemsType.Text = tabItems.LabelItemsType;
//labelItemsImage.Text = tabItems.LabelItemsImage;
groupBoxItemsList.Text = tabItems.LabelItemsList;
buttonItemsPictureBoxSelect.Text = tabItems.ButtonItemsPictureBoxSelect;
buttonItemsSave.Text = tabItems.ButtonItemsSave;
buttonItemsUpdate.Text = tabItems.ButtonItemsUpdate;
buttonItemsDelete.Text = tabItems.ButtonItemsDelete;
//Item Type
TabItemTypes tabItemTypes = language.TabItemTypes;
tabPageItemType.Text = tabItemTypes.Name;
labelItemTypeName.Text = tabItemTypes.LabelItemTypeName;
labelItemTypeDescription.Text = tabItemTypes.LabelItemTypeDescription;
groupBoxItemTypeList.Text = tabItemTypes.LabelItemTypeList;
buttonItemTypeSave.Text = tabItemTypes.ButtonItemTypeListSave;
buttonItemTypeUpdate.Text = tabItemTypes.ButtonItemTypeListUpdate;
buttonItemTypeDelete.Text = tabItemTypes.ButtonItemTypeListDelete;
//Item Status
TabItemStatus tabItemStatus = language.TabItemStatus;
tabPageItemStatus.Text = tabItemStatus.Name;
labelItemStatusName.Text = tabItemStatus.LabelItemsStatusName;
labelItemStatusDescription.Text = tabItemStatus.LabelItemStatusDescription;
labelItemStatusList.Text = tabItemStatus.LabelItemStatusList;
buttonItemStatusSave.Text = tabItemStatus.ButtonItemStatusSave;
buttonItemStatusUpdate.Text = tabItemStatus.ButtonItemStatusUpdate;
buttonItemStatusDelete.Text = tabItemStatus.ButtonItemStatusDelete;
//Person Info
TabPersonInfo tabPersonInfo = language.TabPersonInfo;
tabPagePersonInfo.Text = tabPersonInfo.Name;
labelPersonInfoName.Text = tabPersonInfo.LabelPersonInfoName;
labelPersonInfoSurName.Text = tabPersonInfo.LabelPersonInfoSurName;
labelPersonInfoNickName.Text = tabPersonInfo.LabelPersonInfoNickName;
labelPersonInfoDescription.Text = tabPersonInfo.LabelPersonInfoDescription;
labelPersonInfoAddress.Text = tabPersonInfo.LabelPersonInfoAddress;
labelPersonInfoCity.Text = tabPersonInfo.LabelPersonInfoCity;
labelPersonInfoPostNumber.Text = tabPersonInfo.LabelPersonInfoPostNumber;
labelPersonInfoEmail.Text = tabPersonInfo.LabelPersonInfoEmail;
labelPersonInfoTelephone.Text = tabPersonInfo.LabelPersonInfoTelephone;
labelPersonInfoTelephoneMobile.Text = tabPersonInfo.LabelPersonInfoTelephoneMobile;
labelPersonInfoFax.Text = tabPersonInfo.LabelPersonInfoFax;
groupBoxPersonInfoList.Text = tabPersonInfo.LabelPersonInfoList;
buttonPersonInfoSave.Text = tabPersonInfo.ButtonPersonInfoSave;
buttonPersonInfoUpdate.Text = tabPersonInfo.ButtonPersonInfoUpdate;
buttonPersonInfoDelete.Text = tabPersonInfo.ButtonPersonInfoDelete;
//Reports
tabPageReports.Text = language.TabReports.Name;
//Bank
TabBank tabBank = language.TabBank;
tabPageBank.Text = tabBank.Name;
labelBankName.Text = tabBank.LabelBankName;
labelBankOwner.Text = tabBank.LabelBankOwner;
labelBankAccountNumber.Text = tabBank.LabelBankAccountNumber;
labelBankList.Text = tabBank.LabelBankList;
buttonBankSave.Text = tabBank.ButtonBankSave;
buttonBankDelete.Text = tabBank.ButtonBankDelete;
buttonBankUpdate.Text = tabBank.ButtonBankUpdate;
}
catch (Exception exception)
{
Logger.Error(exception);
}
}
public override string ToString()
{
System.Text.StringBuilder sb = new StringBuilder("");
switch (_type)
{
case ObjectRefType.Argv:
sb.Append(_name);
break;
case ObjectRefType.Const:
if (_value == null)
{
sb.Append("null");
}
else
{
sb.Append(_value.ToString());
}
break;
case ObjectRefType.EventSender:
if (_value == null)
{
sb.Append("null");
}
else
{
sb.Append(_value.ToString());
}
sb.Append(" ");
sb.Append(_name);
break;
case ObjectRefType.Field:
case ObjectRefType.Property:
sb.Append(_type.ToString());
sb.Append(" ");
if (_owner == null)
{
sb.Append("null ");
}
else
{
sb.Append(_owner.ToString());
sb.Append(".");
}
sb.Append(_name);
break;
case ObjectRefType.This:
sb.Append(_type.ToString());
break;
case ObjectRefType.Type:
if (_value == null)
{
sb.Append("null");
}
else
{
sb.Append(_value.ToString());
}
break;
case ObjectRefType.XPath:
if (_xpathNode == null)
{
sb.Append(_name);
}
else
{
string s = XmlSerialization.GetAttribute(_xpathNode, XmlSerialization.XMLATT_NAME);
if (string.IsNullOrEmpty(s))
{
s = _xpathNode.Name;
}
sb.Append(s);
}
break;
}
return(sb.ToString());
}
private static void SerializeConfig()
{
XmlSerialization.Serialize(ConfigFilename, new Config());
}
} // Load
public static RecordTask LoadFromXmlFile(string filename)
{
return(XmlSerialization.Deserialize <RecordTask>(filename));
} // LoadFromXmlFile
