/// <summary>
/// Returns a Signal based on ID
/// </summary>
/// <param name="signalID"></param>
/// <returns></returns>
public SignalModel Get(string signalID)
{
string query = "EXEC rGetSignals @SignalID = '" + signalID + "'";
SignalModel returnObjs = new SignalModel();
using (DataTable tblData = sqlObject.QuerySQL(query, ref sqlStatus))
{
if (tblData != null && tblData.Rows.Count > 0)
{
returnObjs.DataTypeID = tblData.Rows[0]["DataTypeID"].ToString();
returnObjs.DeviceID = tblData.Rows[0]["DeviceID"].ToString();
returnObjs.DataTypeText = tblData.Rows[0]["DataTypeText"].ToString();
returnObjs.DataTypeValue = tblData.Rows[0]["DataTypeValue"].ToString();
returnObjs.DisplayName = tblData.Rows[0]["DisplayName"].ToString();
returnObjs.Enabled = tblData.Rows[0]["Enabled"].ToString();
returnObjs.RawValue = tblData.Rows[0]["RawValue"].ToString();
returnObjs.SignalID = tblData.Rows[0]["SignalID"].ToString();
returnObjs.SourceID = tblData.Rows[0]["SourceID"].ToString();
returnObjs.SourceText = tblData.Rows[0]["SourceText"].ToString();
returnObjs.SourceValue = tblData.Rows[0]["SourceValue"].ToString();
returnObjs.TagName = tblData.Rows[0]["TagName"].ToString();
returnObjs.TimeStamp = tblData.Rows[0]["TimeStamp"].ToString();
}
}
return(returnObjs);
}
public static SignalModel GetSignalModel(string nameSpace, string signalName)
{
SignalModel model = null;
SignalModelLibrary library = null;
SignalManager sm = Instance;
if (sm._signalModelLibraryCache.ContainsKey(nameSpace))
{
library = sm._signalModelLibraryCache[nameSpace];
}
else
{
SignalDAO dao = new SignalDAO();
dbTSFLibrary tsfLib = dao.getTSFLibraryByNameSpace(nameSpace);
if (tsfLib != null)
{
string content = tsfLib.content;
MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(content));
library = new SignalModelLibrary(ms);
sm._signalModelLibraryCache.Add(nameSpace, library);
}
}
if (library != null)
{
model = library.GetSignalModel(signalName);
}
return(model);
}
/// <summary>
/// Returns a list of available Signals
/// </summary>
/// <returns></returns>
public SignalModels Get()
{
string query = "EXEC rGetSignals";
SignalModels returnObjs = new SignalModels();
using (DataTable tblData = sqlObject.QuerySQL(query, ref sqlStatus))
{
if (tblData != null)
{
foreach (DataRow item in tblData.Rows)
{
SignalModel newObj = new SignalModel();
newObj.DataTypeID = item["DataTypeID"].ToString();
newObj.DeviceID = item["DeviceID"].ToString();
newObj.DataTypeText = item["DataTypeText"].ToString();
newObj.DataTypeValue = item["DataTypeValue"].ToString();
newObj.DisplayName = item["DisplayName"].ToString();
newObj.Enabled = item["Enabled"].ToString();
newObj.RawValue = item["RawValue"].ToString();
newObj.SignalID = item["SignalID"].ToString();
newObj.SourceID = item["SourceID"].ToString();
newObj.SourceText = item["SourceText"].ToString();
newObj.SourceValue = item["SourceValue"].ToString();
newObj.TagName = item["TagName"].ToString();
newObj.TimeStamp = item["TimeStamp"].ToString();
returnObjs.Signals.Add(newObj);
}
}
}
return(returnObjs);
}
private void awbDropListTree_SignalSelected(object sender, XmlDocument tsfDocument)
{
var signal = sender as dbSignal;
_currentSignalModel = sender as SignalModel;
try
{
HourGlass.Start();
Clear();
if (!LoadSignalModel(signal))
{
if (!LoadSignalModel(_currentSignalModel))
{
XmlNode node = SignalManager.Instance.SignalTree.SelectSingleNode("");
//--- ============================================================ ---//
//--- TODO: Determine what to do if the Signal Model does not load ---//
//--- ============================================================ ---//
}
}
}
finally
{
HourGlass.Stop();
}
}
private bool LoadSignalModel(SignalModel sm)
{
bool loaded = false;
if (sm != null)
{
var modelSignal = sm.TSF.model.Item as Signal;
var modelStandard = sm.TSF.model.Item as TSFTypeModelStandard;
if (modelSignal != null)
{
Signal signal = modelSignal;
var items = new List <object>();
items.AddRange(modelSignal.Items);
//signalPartsListControl.SignalItems = items;
signalAttributes.Rows.Clear();
string uuid = sm.TSF.uuid;
edtName.Text = modelSignal.name;
foreach (SignalAttribute attribute in sm.Attributes)
{
signalAttributes.Rows.Add(new object[] { attribute.Name, "" });
}
}
else if (modelStandard != null)
{
//--- =========================================================================================== ---//
//--- TODO: TSFTypeModelStandard is not currently handled - we need to add this is an enhancement ---//
//--- =========================================================================================== ---//
}
loaded = true;
}
return(loaded);
}
public bool Validate(SignalModel signal, List <Rule> matchingRules)
{
bool isValid = true;
foreach (var rule in matchingRules)
{
switch (rule.Operation)
{
case Operation.Equal:
isValid = rule.Value.Equals(signal.Value);
break;
case Operation.NotEqual:
isValid = !rule.Value.Equals(signal.Value);
break;
}
if (!isValid)
{
break;
}
}
return(isValid);
}
protected override async Task ReadDbAsync(IDatablockModel db)
{
VerifyConnected();
if (_collectedPlcTasksToExecute.Count > 0)
{
Console.WriteLine($"BEG ReadDbAsync sec {System.DateTime.Now.Second} ms {System.DateTime.Now.Millisecond}");
}
//await _semaphoreSlim.WaitAsync(5);
byte[] dbBytes = await _plcReader.ReadBytesAsync(S7.Net.DataType.DataBlock, db.Number, db.FirstByte, db.ByteCount);
// TODO change Debug.Assert to if and create scheduler to check if it fails several times,
// and throw exception + handling remove this db from read list
//Debug.Assert(dbBytes.Length == db.ByteCount - db.FirstByte);
List <PlcComIndexValueModel> indexValueModels = new List <PlcComIndexValueModel>();
for (int i = 0; i < db.Signals.Count; i++)
{
SignalModel s = db.Signals[i];
int signalByteCount = s.ByteCount;
int skipBytesValue = s.DbByteIndex() - db.FirstByte;
byte[] signalValueArray = dbBytes.Skip(skipBytesValue).Take(s.ByteCount).ToArray();
indexValueModels.Add(new PlcComIndexValueModel(Index, db.Index, s.Index, s.BytesToValue(signalValueArray)));
}
PlcReadResultEventArgs args = new PlcReadResultEventArgs(indexValueModels);
RaiseHasNewData(args);
}
public static string GenerateSignalToken(this ActivityExecutionContext context, string signal)
{
var workflowInstanceId = context.WorkflowExecutionContext.WorkflowInstance.Id;
var payload = new SignalModel(signal, workflowInstanceId);
var tokenService = context.GetService <ITokenService>();
return(tokenService.CreateToken(payload));
}
public static void ProcessSetup(OperationSetupSensor item)
{
XmlElement any = item.Any;
Signal signal = SignalModel.ExtractSignalFromElement(any);
if (signal != null)
{
int i = 0;
}
}
protected virtual void OnSignalSelected(SignalModel model, XmlDocument tsfDocument)
{
SelectedSignalModel = model;
SignalSelectHandler handler = SignalSelected;
if (handler != null)
{
handler(model, tsfDocument);
}
}
public bool SignalExist(SignalModel signal, DataPathModel data)
{
bool result = false;
if (signal != null && data.Signals != null)
{
foreach (SignalModel sig in data.Signals)
{
bool name = false;
bool SComp = false;
bool SCompPort = false;
bool TComp = false;
bool TCompPort = false;
if (signal.Name == sig.Name)
{
name = true;
}
if (signal.Source_Comp == sig.Source_Comp)
{
SComp = true;
}
if (signal.Source_port == sig.Source_port)
{
SCompPort = true;
}
if (signal.Target_Comp == sig.Target_Comp)
{
TComp = true;
}
if (signal.Target_port == sig.Target_port)
{
TCompPort = true;
}
if (signal.Name == null && sig.Name == null)
{
if (SComp && SCompPort && TComp && TCompPort)
{
result = true;
}
else
{
result = false;
}
}
else if (name || (SComp && SCompPort && TComp && TCompPort))
{
result = true;
}
}
}
return(result);
}
public void Load(SignalModel model)
{
if (model != null)
{
foreach (SignalAttribute signalAttribute in model.Attributes)
{
DataGridViewRow row = (DataGridViewRow)dgInterfaces.RowTemplate.Clone();
row.CreateCells(dgInterfaces, signalAttribute.Name, "");
dgInterfaces.Rows.Add(row);
}
}
}
/// <summary>
/// Adds a new Signal
/// </summary>
/// <param name="objSignal"></param>
/// <param name="recipeName"></param>
/// <param name="deviceID"></param>
/// <returns></returns>
public HttpResponseMessage Put([FromUri] SignalModel objSignal = null, [FromUri] string recipeName = null, [FromUri] string deviceID = null)
{
HttpResponseMessage response;
string query = string.Empty;
if (objSignal == null && recipeName == null)
{
response = Request.CreateResponse(HttpStatusCode.BadRequest, "No values");
}
else if (recipeName != null)
{
response = Request.CreateResponse(HttpStatusCode.OK, CreateSignalFromRecipe(recipeName, deviceID));
}
else
{
query = "INSERT INTO dataTblSignals (" +
"TagName" +
",DeviceID" +
",DisplayName" +
",TimeStamp" +
",RawValue" +
",Source" +
",Enabled" +
",ItemDataType" +
") VALUES (" +
"'" + objSignal.TagName + "'" +
",'" + objSignal.DeviceID + "'" +
",'" + objSignal.DisplayName + "'" +
",'" + objSignal.TimeStamp + "'" +
",'" + objSignal.RawValue + "'" +
",'" + objSignal.SourceID + "'" +
",'" + objSignal.Enabled + "'" +
",'" + objSignal.DataTypeID + "'" +
")";
sqlObject.QuerySQL(query, ref sqlStatus);
if (sqlStatus == "Success")
{
response = Request.CreateResponse(HttpStatusCode.OK, sqlStatus);
}
else
{
response = Request.CreateResponse(HttpStatusCode.BadRequest, sqlStatus);
}
}
response.Content = new StringContent(sqlStatus, Encoding.Unicode);
response.Headers.CacheControl = new CacheControlHeaderValue()
{
MaxAge = TimeSpan.FromMinutes(20)
};
return(response);
}
private bool LoadSignalModel(dbSignal dbsignal)
{
bool loaded = false;
if (dbsignal != null)
{
var dao = new SignalDAO();
dbsignal = dao.getSignal(dbsignal.signalId);
_currentSignalModel = SignalManager.GetSignalModel(dbsignal.xmlns, dbsignal.signalName);
LoadSignalModel(_currentSignalModel);
loaded = true;
}
return(loaded);
}
public Signal(string signalID, DateTime startDate, DateTime endDate,
List <int> eventCodes, int startOfCycle)
{
SignalID = signalID;
StartDate = startDate;
EndDate = endDate;
EventCodes = eventCodes;
var repository =
SignalsRepositoryFactory.Create();
SignalModel = repository.GetLatestVersionOfSignalBySignalID(signalID);
Detectors = SignalModel.GetDetectorsForSignal();
Plans = new PlansBase(signalID, startDate, endDate);
GetPhases(startOfCycle);
}
public IActionResult createSignal([FromBody] SignalModel model)
{
var signal = _mapper.Map <Signal>(model);
try
{
// create signal
_signalService.create(signal);
return(Ok());
}
catch (Exception ex)
{
// return error message if there was an exception
return(BadRequest(new { message = ex.Message }));
}
}
public static List <Signal> ExtractSignalsFromExtension(Extension ext)
{
List <Signal> _signals = null;
//------------------------------------------------------------//
//--- Process the SignalDescription as a Extension element ---//
//------------------------------------------------------------//
if (ext != null)
{
List <XmlElement> any = ext.Any;
if (any != null)
{
_signals = new List <Signal>(any.Count);
foreach (XmlElement element in any)
{
_signals.Add(SignalModel.ExtractSignalFromElement(element));
}
}
}
return(_signals);
}
private void _treeForm_SignalSelect(object sender, XmlDocument tsfDocument)
{
var element = sender as XmlElement;
if (element != null)
{
edtSelectedValue.Text = element.Name;
edtSelectedValue.Tag = element;
string xmlns = element.GetAttribute("xmlns");
SignalModel model = SignalManager.GetSignalModel(xmlns, element.Name);
if (xmlns.Contains("STDBSC"))
{
OnSignalSelected(element.Name, element.OwnerDocument);
}
else
{
OnSignalSelected(model, element.OwnerDocument);
}
}
CloseTree();
}
protected override async Task ReadDbAsync(IDatablockModel db)
{
VerifyConnected();
List <PlcComIndexValueModel> indexValueModels = new List <PlcComIndexValueModel>();
for (int i = 0; i < db.Signals.Count; i++)
{
SignalModel s = db.Signals[i];
double simValue = 0;
if (s is BoolSignalModel)
{
bool boolVal = _simulatedSignals[s.Index].RandomBool();
simValue = boolVal == true ? 1.0 : 0.0;
}
else
{
if (i % 3 == 0)
{
simValue = _simulatedSignals[s.Index].Sine();
}
else
{
simValue = _simulatedSignals[s.Index].RandomFloat();
}
}
if (i % 3 == 0)
{
indexValueModels.Add(new PlcComIndexValueModel(Index, db.Index, s.Index, simValue));
}
}
PlcReadResultEventArgs args = new PlcReadResultEventArgs(indexValueModels);
RaiseHasNewData(args);
await DelayAsync(100);
}
private void CreateXmlElementItem(SignalModel model)
{
if (model != null)
{
var document = new XmlDocument();
TSFType tsf = model.TSF;
string xmlns = model.SignalNameSpace;
string xml = XmlUtils.SerializeObject(model.Signal);
document.LoadXml(xml);
XmlElement root = document.DocumentElement;
if (root != null)
{
XmlElement el = root.FirstChild as XmlElement;
if (el != null && !string.IsNullOrEmpty(edtIn.Text))
{
XmlAttribute attIn = document.CreateAttribute("In");
attIn.Value = edtIn.Text;
el.Attributes.Append(attIn);
}
_signalFunctionType = el;
}
}
}
public bool Validate(SignalModel signal, List <Rule> matchingRules)
{
bool isValid = true;
decimal signalValue = decimal.Parse(signal.Value);
foreach (var rule in matchingRules)
{
decimal ruleValue = decimal.Parse(rule.Value);
switch (rule.Operation)
{
case Operation.Equal:
isValid = signalValue == ruleValue;
break;
case Operation.NotEqual:
isValid = signalValue != ruleValue;
break;
case Operation.GreaterThan:
isValid = signalValue > ruleValue;
break;
case Operation.LessThan:
isValid = signalValue < ruleValue;
break;
}
if (!isValid)
{
break;
}
}
return(isValid);
}
private void awbDropListTree_SignalSelected(object sender, XmlDocument tsfDocument)
{
var signal = sender as dbSignal;
_currentSignalModel = sender as SignalModel;
var bscName = sender as string;
try
{
HourGlass.Start();
Clear();
if (!string.IsNullOrWhiteSpace(bscName))
{
}
else if (!LoadSignalModel(signal, tsfDocument))
{
LoadSignalModel(_currentSignalModel, tsfDocument);
}
}
finally
{
HourGlass.Stop();
}
}
/// <summary>
/// Gets the value of the byte index in the belonging datablock
/// </summary>
/// <param name="model"></param>
/// <returns>The byte index if parse found valid, else -1</returns>
public static int DbByteIndex(this SignalModel model)
{
// numeric example DB100.DBD124 Target: 124
// bool example DB100.DBX240.1 Target: 240
string[] subStrings = model.Address.Split('.');
if (subStrings.Length < 2)
{
return(-1);
}
string indexStr = subStrings[1].Remove(0, 3);
int output;
bool parseOk = Int32.TryParse(indexStr, out output);
if (parseOk)
{
return(output);
}
return(-1);
}
public ActionResult Index()
{
var model = new SignalModel();
return(View(model));
}
/// <summary>
/// Update Signal. Along with the required variables you must also supply the SignalID.
/// The History gets updated on every data change.
/// </summary>
/// <param name="objSignal"></param>
public HttpResponseMessage Post([FromUri] SignalModel objSignal)
{
HttpResponseMessage response;
if (string.IsNullOrWhiteSpace(objSignal.SignalID))
{
response = Request.CreateResponse(HttpStatusCode.BadRequest, sqlStatus);
return(response);
}
string query = "UPDATE dataTblSignals SET ";
if (!string.IsNullOrWhiteSpace(objSignal.TagName))
{
query += "TagName = '" + objSignal.TagName + "'";
}
if (!string.IsNullOrWhiteSpace(objSignal.DisplayName))
{
if (query[query.Length - 1] != ' ')
{
query += ",";
}
query += "DisplayName = '" + objSignal.DisplayName + "'";
}
if (!string.IsNullOrWhiteSpace(objSignal.RawValue))
{
if (query[query.Length - 1] != ' ')
{
query += ",";
}
if (string.IsNullOrWhiteSpace(objSignal.TimeStamp))
{
objSignal.TimeStamp = DateTime.Now.ToString();
}
query += "RawValue = '" + objSignal.RawValue + "',TimeStamp = '" + objSignal.TimeStamp + "'";
}
if (!string.IsNullOrWhiteSpace(objSignal.SourceID))
{
if (query[query.Length - 1] != ' ')
{
query += ",";
}
query += "Source = '" + objSignal.SourceID + "'";
}
if (!string.IsNullOrWhiteSpace(objSignal.Enabled))
{
if (query[query.Length - 1] != ' ')
{
query += ",";
}
query += "Enabled = '" + objSignal.Enabled + "'";
}
if (!string.IsNullOrWhiteSpace(objSignal.DataTypeID))
{
if (query[query.Length - 1] != ' ')
{
query += ",";
}
query += "ItemDataType = '" + objSignal.DataTypeID + "'";
}
if (!string.IsNullOrWhiteSpace(objSignal.DeviceID))
{
if (query[query.Length - 1] != ' ')
{
query += ",";
}
query += "DeviceID = '" + objSignal.DataTypeID + "'";
}
query += " WHERE ID = '" + objSignal.SignalID + "'";
sqlObject.QuerySQL(query, ref sqlStatus);
if (sqlStatus == "Success")
{
response = Request.CreateResponse(HttpStatusCode.OK, sqlStatus);
}
else
{
response = Request.CreateResponse(HttpStatusCode.BadRequest, sqlStatus);
}
response.Content = new StringContent(sqlStatus, Encoding.Unicode);
response.Headers.CacheControl = new CacheControlHeaderValue()
{
MaxAge = TimeSpan.FromMinutes(20)
};
return(response);
}
private bool LoadSignalModel(SignalModel sm, XmlDocument tsfDocument)
{
bool loaded = false;
if (sm != null)
{
string tsfNameSpace = sm.SignalNameSpace;
string tsfName = sm.TSF.name;
string tsfUuid = sm.TSF.uuid;
_currentSignalModel = sm;
Signal modelSignal = new Signal();
modelSignal.name = tsfName;
XmlElement el = tsfDocument.CreateElement("tsf", tsfName, tsfNameSpace);
foreach (SignalAttribute attr in sm.Attributes)
{
el.Attributes.Append(tsfDocument.CreateAttribute(attr.Name));
}
modelSignal.Items = new[] { el };
Signal = modelSignal;
var items = new List <object>();
items.AddRange(modelSignal.Items);
signalPartsListControl.SignalItems = items;
/*
* var modelSignal = sm.TSF.model.Item as Signal;
* var modelStandard = sm.TSF.model.Item as TSFTypeModelStandard;
* if (modelSignal != null)
* {
* modelSignal.type = tsfName;
* var la = new List<XmlAttribute>( modelSignal.AnyAttr );
* if (tsfDocument != null)
* {
* XmlAttribute xAttribute1 = tsfDocument.CreateAttribute("tsf-xmlns");
* XmlAttribute xAttribute2 = tsfDocument.CreateAttribute("tsf-uuid");
* XmlAttribute xAttribute3 = tsfDocument.CreateAttribute("tsf-name");
* xAttribute1.Value = tsfNameSpace;
* xAttribute2.Value = tsfUuid;
* xAttribute3.Value = tsfName;
* la.Add(xAttribute1);
* la.Add(xAttribute2);
* la.Add(xAttribute3);
* }
* modelSignal.AnyAttr = la.ToArray();
* Signal = modelSignal;
* var items = new List<object>();
* items.AddRange(modelSignal.Items);
* signalPartsListControl.SignalItems = items;
* signalInterfaceListControl.Load( sm );
* //dg.Rows.Clear();
* //string uuid = sm.TSF.uuid;
* //foreach (SignalAttribute attribute in sm.Attributes)
* // dgInterfaceAttributes.Rows.Add(new object[] { attribute.Name, "" });
* }
* else if (modelStandard != null) //TODO: Figure out TSFTypeModelStandard
* {
* }
* */
loaded = true;
}
return(loaded);
}
private void signalComboBox_SelectedIndexChanged(object sender, EventArgs e)
{
try
{
HourGlass.Enabled = true;
SignalModel signalModel = awbDropListTree.SelectedSignalModel;
if (signalModel != null)
{
var signal = signalModel.Signal; //signalComboBox.SelectedItem as dbSignal;
if (signal != null)
{
//---------------------------------------------------//
//--- Find "name" in data grid and set it's value ---//
//---------------------------------------------------//
foreach (DataGridViewRow row in signalAttributes.Rows)
{
if (row.IsNewRow)
{
continue;
}
var name = row.Cells[0].Value as string;
var type = row.Cells[1].Value as string;
var value = row.Cells[2].Value as string;
if ("type".Equals(name))
{
row.Cells[1].Value = edtName.Text;
break;
}
}
signalAttributes.Rows.Clear();
if (string.IsNullOrEmpty(edtName.Text))
{
edtName.Text = signal.name;
}
var dao = new SignalDAO();
dbSignal dataSignal = dao.getSignal(signal.name, signalModel.SignalNameSpace);
string xmlns = signalModel.SignalNameSpace;
XmlSchemaComplexType complexType;
XmlSchemaElement element = null;
SchemaManager.GetComplexType(xmlns, signal.name, out complexType);
if (complexType == null)
{
SchemaManager.GetElement(xmlns, signal.name, out element);
}
if (complexType != null || element != null)
{
signalAttributes.Rows.Clear();
List <XmlSchemaAttribute> schemaAttributes = complexType != null
? SchemaManager.GetAttributes(complexType)
: SchemaManager.GetAttributes(element);
List <dbSignalAttribute> dbAttributes = dao.getAllSignalAttributes(signal.name, signalModel.SignalNameSpace);
var foundAttributes = new Dictionary <string, dbSignalAttribute>();
foreach (dbSignalAttribute attribute in dbAttributes)
{
foundAttributes.Add(attribute.attributeName, attribute);
object value = null;
try
{
if (_signalFunctionType != null)
{
PropertyInfo pi =
_signalFunctionType.GetType().GetProperty(attribute.attributeName);
if (pi != null)
{
value = pi.GetValue(_signalFunctionType, null);
}
}
}
catch (Exception err)
{
LogManager.Error(err);
}
int idx =
signalAttributes.Rows.Add(new[] { attribute.attributeName, attribute.type, value });
signalAttributes.Rows[idx].Tag = attribute;
}
//-----------------------------------------------------------------------------//
//--- Check the database for each of the attributes found in the schema. If ---//
//--- the attribute does not exist in the database the add it. ---//
//-----------------------------------------------------------------------------//
signalAttributes.Rows.Clear();
foreach (XmlSchemaAttribute attribute in schemaAttributes)
{
string name = attribute.Name;
if (!foundAttributes.ContainsKey(name))
{
var dbSignalAttribute = new dbSignalAttribute();
dbSignalAttribute.signalId = dataSignal.signalId;
dbSignalAttribute.attributeName = name;
dbSignalAttribute.defaultValue = attribute.DefaultValue;
dbSignalAttribute.fixedValue = attribute.FixedValue;
if (attribute.AttributeSchemaType != null)
{
dbSignalAttribute.type = attribute.AttributeSchemaType.Name;
}
dbSignalAttribute.DataState = BASEBean.eDataState.DS_ADD;
dbSignalAttribute.save();
int idx = signalAttributes.Rows.Add(new[] { name, dbSignalAttribute.type, null });
signalAttributes.Rows[idx].Tag = attribute;
}
}
}
}
}
}
finally
{
HourGlass.Enabled = false;
}
}
/// <summary>
/// Returns the result of required fields validation
/// </summary>
/// <param name="model"></param>
/// <returns>true if required field are found valid, otherwise false.</returns>
public static bool IsValid(this SignalModel model)
{
// Length: Least possible length example: DB1.DBD0
return(model.Db > 0 && model.Name.Length > 0 && model.Address.Length >= 8);
}
public void Load(string nameSpace, string signalName)
{
SignalModel model = SignalManager.GetSignalModel(nameSpace, signalName);
Load(model);
}
private void ControlsToData()
{
if (_signalFunctionType == null)
{
SignalModel model = awbDropListTree.SelectedSignalModel;
if (model != null)
{
var name = edtName.Text;
var ins = edtIn.Text;
var signal = model.Signal;
if (signal != null)
{
bool hasClass = false;
string signalName = signal.name;
string xmlns = model.SignalNameSpace;
var bean = CacheManager.GetNamespaceCache().getItem(xmlns) as LuNamespaceBean;
if (bean != null)
{
string className = bean.appNamespace + "." + signalName;
object obj = Assembly.GetExecutingAssembly().CreateInstance(className);
if (obj is SignalFunctionType)
{
_signalFunctionType = obj as SignalFunctionType;
hasClass = true;
}
}
if (!hasClass)
{
CreateXmlElementItem(model);
}
}
}
else if (!string.IsNullOrEmpty(edtName.Text))
{
//CreateXmlElementItem( edtName.Text );
}
}
XmlElement element = _signalFunctionType as XmlElement;
if (element != null)
{
element.SetAttribute("name", edtName.Text);
if (string.IsNullOrWhiteSpace(edtIn.Text))
{
element.RemoveAttribute("in");
}
else
{
element.SetAttribute("in", edtIn.Text);
}
}
foreach (DataGridViewRow row in signalAttributes.Rows)
{
if (row.IsNewRow)
{
continue;
}
var name = row.Cells[0].Value as string;
var type = row.Cells[1].Value as string;
var value = row.Cells[2].Value as string;
var attr = row.Tag as dbSignalAttribute;
//---------------------------------------------------//
//--- Set the default value if the value is empty ---//
//---------------------------------------------------//
if (string.IsNullOrWhiteSpace(value) && attr != null &&
!string.IsNullOrWhiteSpace(attr.defaultValue))
{
value = attr.defaultValue;
}
if (_signalFunctionType is SignalFunctionType)
{
if (attr == null)
{
attr = new dbSignalAttribute();
}
attr.Value = value;
attr.attributeName = name;
((SignalFunctionType)_signalFunctionType).Value = value;
if (name != null)
{
PropertyInfo pi = _signalFunctionType.GetType().GetProperty(name);
if (pi != null)
{
if (!string.IsNullOrWhiteSpace(value))
{
pi.SetValue(_signalFunctionType, value, null);
}
}
}
}
else if (_signalFunctionType is XmlElement)
{
var signal = (XmlElement)_signalFunctionType;
if (string.IsNullOrWhiteSpace(value))
{
signal.RemoveAttribute(name);
}
else if (name != null)
{
signal.SetAttribute(name, value);
}
}
}
}
