private void SaveSelectedSignalModel()
{
HourGlass.Start();
try
{
SignalDAO dao = DataManager.getSignalDAO();
if (_signalModelLibrary != null)
{
dao.DeleteTSFLibrary( _signalModelLibrary.TSFLibrary.uuid,
_signalModelLibrary.TSFLibrary.targetNamespace );
var library = new dbTSFLibrary();
library.IncludeKeyOnInsert = true;
library.lastUpdate = DateTime.UtcNow;
library.id = Guid.Parse( _signalModelLibrary.TSFLibrary.uuid );
library.content = _signalModelLibrary.XmlContent;
library.targetNamespace = _signalModelLibrary.TSFLibrary.targetNamespace;
library.libraryName = _signalModelLibrary.TSFLibrary.name;
library.DataState = ( !dao.hasTSFLibrary( _signalModelLibrary.TSFLibrary.uuid ) )
? BASEBean.eDataState.DS_ADD
: BASEBean.eDataState.DS_EDIT;
library.save();
foreach (SignalModel sm in _signalModelLibrary.SignalModels.Values)
{
TSFType tsf = sm.TSF;
dbSignal dataSignal = dao.getSignal( sm.Name, library.targetNamespace );
if (dataSignal == null)
{
//Add Signal to the database
string baseSignalName = sm.BaseSignalName;
dbSignal baseSignal = dao.getSignal( baseSignalName, sm.BaseSignalNameSpace );
dataSignal = new dbSignal();
dataSignal.ParentSignal = baseSignal;
dataSignal.signalName = sm.Name;
dataSignal.uuid = Guid.Parse(tsf.uuid);
dataSignal.xmlns = library.targetNamespace;
foreach (SignalAttribute attribute in sm.Attributes)
{
var a = new dbSignalAttribute();
a.attributeName = attribute.Name;
a.defaultValue = attribute.DefaultValue;
a.DataState = BASEBean.eDataState.DS_ADD;
a.type = attribute.SchemaType;
a.fixedValue = attribute.FixedValue;
if (dataSignal.Attributes == null )
dataSignal.Attributes = new List<dbSignalAttribute>();
dataSignal.Attributes.Add( a );
}
dataSignal.DataState = BASEBean.eDataState.DS_ADD;
}
else
{
dataSignal.xmlns = library.targetNamespace;
dataSignal.uuid = Guid.Parse(tsf.uuid);
List<dbSignalAttribute> attributes = dataSignal.Attributes;
var attrMap = new Dictionary<string, SignalAttribute>();
var dbAttrMap = new Dictionary<string, dbSignalAttribute>();
foreach (SignalAttribute sa in sm.Attributes)
attrMap.Add( sa.Name, sa );
foreach (dbSignalAttribute dbAttribute in attributes)
{
string an = dbAttribute.attributeName;
dbAttrMap.Add( an, dbAttribute );
if (attrMap.ContainsKey( an ))
{
SignalAttribute sa = attrMap[an];
dbAttribute.type = sa.SchemaType;
dbAttribute.defaultValue = sa.DefaultValue;
dbAttribute.fixedValue = sa.FixedValue;
dbAttribute.DataState = BASEBean.eDataState.DS_EDIT;
}
else
{
dbAttribute.DataState = BASEBean.eDataState.DS_DELETE;
}
}
foreach (SignalAttribute sa in sm.Attributes)
{
if (!dbAttrMap.ContainsKey( sa.Name ))
{
var dbAttribute = new dbSignalAttribute();
dbAttribute.type = sa.SchemaType;
dbAttribute.defaultValue = sa.DefaultValue;
dbAttribute.fixedValue = sa.FixedValue;
dbAttribute.DataState = BASEBean.eDataState.DS_ADD;
dataSignal.Attributes.Add( dbAttribute );
}
}
dataSignal.DataState = BASEBean.eDataState.DS_EDIT;
}
dataSignal.xmlns = _signalModelLibrary.TSFLibrary.targetNamespace;
dataSignal.save();
}
foreach (ListViewItem item in lvSignals.Items)
{
var model = item.Tag as SignalModel;
if (model != null)
{
var signal = new dbTSFSignal();
signal.signalName = model.Name;
signal.id = Guid.Parse( model.TSF.uuid );
signal.signalContent = model.TSF.Serialize();
signal.libraryUuid = _signalModelLibrary.TSFLibrary.uuid;
signal.DataState = ( !dao.hasTSFSignal( model.TSF.uuid )
? BASEBean.eDataState.DS_ADD
: BASEBean.eDataState.DS_EDIT );
signal.lastUpdate = DateTime.UtcNow;
try
{
signal.save();
}
catch (Exception e)
{
if (e.Message.ToLower().Contains( "duplicate" ))
{
TestSignalBean otherSignal = dao.getTSFSignal( model.Name,
_signalModelLibrary.TSFLibrary.uuid );
LogManager.Error( "UUID Conflict between document data and the database for Signal {0} in Signal Library {1} ",
model.Name, library.libraryName );
if (otherSignal != null)
{
LogManager.Error( "\tDocument signal uuid {0}, Database signal uuid {{{1}}} ",
model.TSF.uuid, otherSignal.id.ToString().ToUpper() );
if (dao.changeTSFSignalId( otherSignal.id, Guid.Parse(model.TSF.uuid) ))
{
LogManager.Info(
"The Database signal uuid has been changed to reflect the Document signal uuid" );
signal.DataState = BASEBean.eDataState.DS_EDIT;
signal.save();
}
}
}
}
}
}
}
}
catch (Exception e)
{
LogManager.Error( e, "An error has occured saving the signal model library: {0}", e.Message );
}
finally
{
HourGlass.Stop();
if (_signalModelLibrary == null)
{
MessageBox.Show(Resources.A_Signal_Model_must_be_selected_to_save_);
}
else
{
LogManager.Trace(Resources.Completed_Saving_Selected_Signal_Model);
MessageBox.Show(Resources.Completed_Saving_Selected_Signal_Model);
}
}
}
public List<dbSignalAttribute> getSignalAttributes(int? signalId)
{
List<dbSignalAttribute> signalAttributes = new List<dbSignalAttribute>();
String sql = "SELECT * FROM signal_attribute_master WHERE signal_id = ?";
OleDbParameter[] dbParams = { CreateParameter("@signal_id", signalId) };
using (OleDbDataReader reader = ExecuteSqlQuery( sql, dbParams ))
{
if (reader != null)
{
while (reader.Read())
{
dbSignalAttribute signalAttribute = new dbSignalAttribute();
signalAttribute.load( reader );
signalAttributes.Add( signalAttribute );
}
reader.Close();
reader.Dispose();
}
}
return signalAttributes;
}
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 );
}
}
}
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;
}
}
public void SaveSignalModel()
{
//Check Database for _TSF.name
//If not found add it
//walk through attributes
//check for attribute names
//if not found add them
var dao = new SignalDAO();
dbSignal dataSignal = dao.getSignal( _name, _signalNameSpace );
dbSignal baseSignal = dao.getSignal( _baseSignalName, _baseSignalNameSpace );
if (dataSignal == null)
{
dataSignal = new dbSignal();
dataSignal.parentSignalId = baseSignal != null ? baseSignal.signalId : 0;
dataSignal.xmlns = _signalNameSpace;
dataSignal.signalName = _name;
dataSignal.uuid = Guid.Parse( _tsf.uuid );
dataSignal.save();
}
foreach (SignalAttribute attr in _attributes)
{
bool hasAttribute = dao.hasAttribute( dataSignal.signalId, attr.Name );
dbSignalAttribute dbAttribute;
if (!hasAttribute)
dbAttribute = new dbSignalAttribute();
else
dbAttribute = dao.GetAttribute( dataSignal.signalId, attr.Name );
dbAttribute.DataState = hasAttribute ? BASEBean.eDataState.DS_EDIT : BASEBean.eDataState.DS_ADD;
dbAttribute.attributeName = attr.Name;
dbAttribute.signalId = dataSignal.signalId;
dbAttribute.defaultValue = attr.DefaultValue;
dbAttribute.fixedValue = attr.FixedValue;
dbAttribute.type = attr.SchemaType;
dbAttribute.save();
}
}
