private CacheManager()
{
EquipmentDAO equipmentDAO = DataManager.getEquipmentDAO();
HelpDAO helpDAO = DataManager.getHelpDAO();
StandardUnitMeasurementDAO sumDAO = DataManager.getStandardUnitMeasurementDAO();
SignalDAO signalDAO = DataManager.getSignalDAO();
LookupTablesDAO lookupTablesDAO = DataManager.getLookupTablesDAO();
loadCacheItem <dbConnector>(equipmentDAO, LuConnectorBean._TABLE_NAME,
"getConnectors", LuConnectorBean._CONNECTOR_TYPE);
loadCacheItem <LuNamespaceBean>(lookupTablesDAO, LuNamespaceBean._TABLE_NAME,
"getNamespaceLookup", LuNamespaceBean._XMLNS);
loadCacheItem <HelpMessageBean>(helpDAO, HelpMessageBean._TABLE_NAME,
"getHelpMessages", HelpMessageBean._MESSAGE_KEY);
loadCacheItem <StandardUnitMeasurementBean>(sumDAO, StandardUnitMeasurementBean._TABLE_NAME,
"getLimitsActiveStandardUnitMeasurementBeans", StandardUnitMeasurementBean._ID);
loadCacheItem <StandardUnitPrefixBean>(sumDAO, StandardUnitPrefixBean._TABLE_NAME,
"getAllStandardUnitPrefixBeans", StandardUnitPrefixBean._ID);
loadCacheItem <dbSignal>(signalDAO, SignalMasterBean._TABLE_NAME,
"getAllSignals", SignalMasterBean._SIGNAL_ID);
loadCacheItem <dbSignal>(signalDAO, TestSignalLibraryBean._TABLE_NAME,
"GetAllTsfSignals", SignalMasterBean._SIGNAL_ID);
loadCacheItem <dbCountry>(lookupTablesDAO, LuCountryBean._TABLE_NAME,
"getActiveCountries", LuCountryBean._COUNTRY_CODE);
loadCacheItem <DocumentType>(lookupTablesDAO, LuDocumentTypeBean._TABLE_NAME,
"getDocumentTypes", LuDocumentTypeBean._TYPE_ID);
}
private void ProcessSignalFunctionType()
{
edtName.Text = ((SignalFunctionType)_signalFunctionType).name;
edtIn.Text = ((SignalFunctionType)_signalFunctionType).In;
String name = _signalFunctionType.GetType().Name;
SignalDAO dao = DataManager.getSignalDAO();
//signalComboBox.SelectedIndex = signalComboBox.FindString( name );
List <dbSignalAttribute> dbAttributes = dao.getAllSignalAttributes(name, null);
//TODO:REPLACE NULL
signalAttributes.Rows.Clear();
foreach (dbSignalAttribute attr in dbAttributes)
{
object value = null;
try
{
PropertyInfo pi = _signalFunctionType.GetType().GetProperty(attr.attributeName);
if (pi != null)
{
value = pi.GetValue(_signalFunctionType, null);
}
}
catch (Exception e)
{
LogManager.Error(e);
}
int idx = signalAttributes.Rows.Add(new[] { attr.attributeName, attr.type, value });
signalAttributes.Rows[idx].Tag = attr;
}
}
private void ProcessXmlElement()
{
var signal = (XmlElement)_signalFunctionType;
if (signal.HasAttribute("name"))
{
edtName.Text = signal.GetAttribute("name");
}
if (signal.HasAttribute("In"))
{
edtName.Text = signal.GetAttribute("In");
}
String name = signal.LocalName;
string nameSpace = signal.NamespaceURI;
SignalDAO dao = DataManager.getSignalDAO();
List <dbSignalAttribute> dbAttributes = dao.getAllSignalAttributes(name, nameSpace);
//TODO:REPLACE NULL
signalAttributes.Rows.Clear();
foreach (dbSignalAttribute attr in dbAttributes)
{
//TODO: Lookup Attribute Type
String attrName = attr.attributeName;
String attrValue = signal.GetAttribute(attrName);
signalAttributes.Rows.Add(new object[] { attr.attributeName, attr.type, attrValue });
}
awbDropListTree.FindNode(name, nameSpace);
}
private void processTSF(HttpProcessor p)
{
string url = p.http_url;
//Strip off /tsf/
url = url.Substring(5);
string[] parts = url.Split('/');
if (parts.Length != 2)
{
throw new Exception("Invalid URL");
}
string name = parts[0];
string version = parts[1];
SignalDAO dao = DataManager.getSignalDAO();
dbTSFLibrary lb = dao.getTSFLibraryByName(name);
if (lb == null || lb.content == null)
{
throw new Exception(string.Format("Signal Model Library \"{0}\" was not found.", name));
}
p.httpHeaders.Add("Content-Type", "text/xml");
p.httpHeaders.Add("Content-Disposition", "inline; filename=" + name + ".xml");
var writer = new BinaryWriter(p.outputStream.BaseStream, Encoding.UTF8);
writer.Write(Encoding.UTF8.GetBytes(lb.content));
}
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);
}
private void SignalModelLibraryForm_Load(object sender, EventArgs e)
{
SignalDAO dao = DataManager.getSignalDAO();
List <dbTSFLibrary> list = dao.getTSFLibraries();
foreach (dbTSFLibrary library in list)
{
int idx = cmbLibraryName.Items.Add(new KeyValuePair <String, dbTSFLibrary>(library.libraryName, library));
}
}
private DataManager()
{
equpmentDAO = new EquipmentDAO();
signalDAO = new SignalDAO();
helpDAO = new HelpDAO();
standardUnitMeasurementDAO = new StandardUnitMeasurementDAO();
lookupTablesDAO = new LookupTablesDAO();
documentDAO = new DocumentDAO();
schemaDAO = new SchemaDAO();
}
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 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();
}
}
public static void Save(string uuid, Capabilities capabilities)
{
SignalDAO dao = new SignalDAO();
List <object> items = capabilities.Items;
if (items != null)
{
foreach (object item in items)
{
Capability capability = item as Capability;
DocumentReference documentReference = item as DocumentReference;
if (capability != null)
{
ProcessCapability(uuid, capability);
}
if (documentReference != null)
{
ProcessDocumentReference(uuid, documentReference);
}
}
}
}
public void LoadSignalModelLibraryCache()
{
SignalDAO dao = new SignalDAO();
List <dbTSFLibrary> list = dao.getTSFLibraries();
_signalModelLibraryCache.Clear();
foreach (dbTSFLibrary library in list)
{
string xmlns = library.targetNamespace;
string content = library.content;
if (string.IsNullOrEmpty(xmlns))
{
LogManager.Warn("A namespace does not exist for {0} and therefore not added to the schema cache.", library.libraryName);
}
else
{
MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(content));
SignalModelLibrary sml = new SignalModelLibrary(ms);
_signalModelLibraryCache.Add(xmlns, sml);
}
}
}
public SignalMapper()
{
_signalDao = new SignalDAO();
_signalMappingDao = new SignalMappingDAO();
}
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;
}
}
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);
}
}
}
