public void ElementListCanRenderAsXml()
{
var list = new ElementList(new Element("input", "type=text"), new Element("img", "src=stoopid.gif"));
var expected = "<input type=\"text\" /><img src=\"stoopid.gif\" />";
var actual = list.Render(RendersTo.XmlTextWriter);
Assert.AreEqual(expected, actual);
}
public bool Create(ElementList sParams)
{
db.SetConnection();
string sSQL1 = "Insert into acquire_parms_rec ";
string sSQL = sSQL1 + sParams.ColumnsValues;
return db.Execute(sSQL);
}
public bool Delete(string DetectorName, string CounterType, ElementList sParams)
{
DataRow dr = null;
string table = "CountingParams";
if (CounterType.Equals("Multiplicity") || CounterType.Equals("Coincidence"))
table = "LMMultiplicity";
Detectors dets = new Detectors(db);
long l = dets.PrimaryKey(DetectorName);
if (l == -1)
{
DBMain.AltLog(LogLevels.Warning, 70137, "Missing Det key ({0}) selecting CountingParams", l);
return false;
}
if (table.Equals("LMMultiplicity"))
dr = HasRow(l, CounterType, table, sParams, sParams[faidx].Value); // the FA parameter
else
dr = HasRow(l, CounterType, table, sParams);
if (dr != null)
{
string sSQL = "DELETE FROM " + table + " where counter_type=" + SQLSpecific.QVal(CounterType) + " AND detector_id=" + l.ToString();
if (table.Equals("LMMultiplicity"))
sSQL += " AND " + sParams[faidx].Name + "=" + sParams[faidx].Value;
return db.Execute(sSQL);
}
else
return true;
}
public bool DefinitionExists(ElementList els)
{
db.SetConnection();
string sSQL = "Select * FROM detectors where ";
sSQL = sSQL + els.ColumnEqValueAndList;
DataTable dt = db.DT(sSQL);
return dt.Rows.Count > 0;
}
public void NullElementsAreNotAddedToList()
{
Element nullel = null;
Element el = new Element("b").Update("Anja");
ElementList list = new ElementList(nullel, el);
Assert.AreEqual(1, list.Count);
Assert.AreEqual("<b>Anja</b>", list.ToString());
}
public bool Create(string measDetId, ElementList sParams)
{
db.SetConnection();
Detectors dets = new Detectors(db);
long l = dets.PrimaryKey(measDetId);
sParams.Add(new Element("detector_id", l));
string sSQL1 = "Insert into " + table + " ";
string sSQL = sSQL1 + sParams.ColumnsValues;
return db.Execute(sSQL);
}
public long Create(long measid, ElementList sParams)
{
db.SetConnection();
ArrayList sqlList = new ArrayList();
string sSQL1 = "Insert into results_rec ";
sParams.Add(new Element("mid", measid));
string sSQL = sSQL1 + sParams.ColumnsValues; sqlList.Add(sSQL);
sqlList.Add(SQLSpecific.getLastID("results_rec"));
return db.ExecuteTransactionID(sqlList);
}
public bool Update(string measDetId, ElementList sParams)
{
db.SetConnection();
Detectors dets = new Detectors(db);
long l = dets.PrimaryKey(measDetId);
string sSQL1 = "UPDATE " + table + " SET ";
string sSQL1i = String.Empty;
string wh = " where " + "detector_id = " + l.ToString();
string sSQL = sSQL1 + sParams.ColumnEqValueList + wh;
return db.Execute(sSQL);
}
public long Create(long mid, ElementList resParams)
{
db.SetConnection();
resParams.Add(new Element("mid", mid));
ArrayList sqlList = new ArrayList();
string sSQL1 = "Insert into " + table + "_m" + " ";
string sSQL = sSQL1 + resParams.ColumnsValues;
sqlList.Add(sSQL);
sqlList.Add(SQLSpecific.getLastID(table + "_m" ));
return db.ExecuteTransactionID(sqlList);
}
public void GetAvailableElementListNotAvailable()
{
ElementList <AvailableElementData> elementList = new ElementList <AvailableElementData>();
T2GManagerErrorEnum returns = T2GManagerErrorEnum.eElementNotFound;
Guid sessionId = Guid.NewGuid();
_sessionManagerMock.Setup(x => x.IsSessionValid(sessionId)).Returns(true);
_train2groundClientMock.Setup(y => y.GetAvailableElementDataList(out elementList)).Returns(returns);
MissionServiceElementListResult result = _missionService.GetAvailableElementList(sessionId);
_train2groundClientMock.Verify(w => w.GetAvailableElementDataList(out elementList), Times.Once());
Assert.AreEqual(MissionErrorCode.ElementListNotAvailable, result.ResultCode);
}
public void GetAvailableElementListInvalidSessionId()
{
Guid sessionId = Guid.NewGuid();
_sessionManagerMock.Setup(x => x.IsSessionValid(sessionId)).Returns(false);
MissionServiceElementListResult result = _missionService.GetAvailableElementList(sessionId);
ElementList <AvailableElementData> elementList = new ElementList <AvailableElementData>();
this._train2groundClientMock.Verify(w => w.GetAvailableElementDataList(out elementList), Times.Never());
Assert.AreEqual(MissionErrorCode.InvalidSessionId, result.ResultCode);
}
/// <summary>
/// Get the list of streamhosts
/// </summary>
/// <returns></returns>
public StreamHost[] GetStreamHosts()
{
ElementList nl = SelectElements(typeof(StreamHost));
StreamHost[] hosts = new StreamHost[nl.Count];
int i = 0;
foreach (Element e in nl)
{
hosts[i] = (StreamHost)e;
i++;
}
return(hosts);
}
/// <summary>
/// Appends the specified element to the end of this queue.
/// </summary>
/// <remarks>
/// Queues may place limitations on what elements may be added
/// to this Queue. In particular, some Queues will impose restrictions
/// on the type of elements that may be added. Queue implementations
/// should clearly specify in their documentation any restrictions on
/// what elements may be added.
/// </remarks>
/// <param name="obj">
/// Element to be appended to this Queue.
/// </param>
/// <returns>
/// <b>true</b> (as per the general contract of the IList.Add method)
/// </returns>
/// <exception cref="InvalidCastException">
/// If the class of the specified element prevents it from being added
/// to this Queue.
/// </exception>
public virtual bool Add(object obj)
{
lock (this)
{
ElementList.Add(obj);
// this Queue reference is waited on by the blocking remove
// method; use notify to wake up a thread waiting
// to remove
Monitor.Pulse(this);
return(true);
}
}
/// <summary>
/// Gets a list of all form fields
/// </summary>
/// <returns></returns>
public Rule[] GetRules()
{
ElementList nl = SelectElements(typeof(Rule));
Rule[] items = new Rule[nl.Count];
int i = 0;
foreach (Element e in nl)
{
items[i] = (Rule)e;
i++;
}
return(items);
}
/// <summary>
/// Get all url bookmarks
/// </summary>
/// <returns></returns>
public Url[] GetUrls()
{
ElementList nl = SelectElements(typeof(Url));
Url[] items = new Url[nl.Count];
int i = 0;
foreach (Element e in nl)
{
items[i] = (Url)e;
i++;
}
return(items);
}
public Mechanism[] GetMechanisms()
{
ElementList elements = SelectElements("mechanism");
Mechanism[] items = new Mechanism[elements.Count];
int i = 0;
foreach (Element e in elements)
{
items[i] = (Mechanism)e;
i++;
}
return(items);
}
/// <summary>
/// Gets the roster.
/// </summary>
/// <returns> </returns>
public RosterItem[] GetRoster()
{
ElementList nl = SelectElements(typeof(RosterItem));
int i = 0;
var result = new RosterItem[nl.Count];
foreach (RosterItem ri in nl)
{
result[i] = ri;
i++;
}
return(result);
}
/// <summary>
/// Gets all values for multi fields as Array
/// </summary>
/// <returns> string Array that contains all the values </returns>
public string[] GetValues()
{
ElementList nl = SelectElements(typeof(Value));
var values = new string[nl.Count];
int i = 0;
foreach (Element val in nl)
{
values[i] = val.Value;
i++;
}
return(values);
}
/// <summary>
/// Retrieve the result items of a search
/// </summary>
//public ElementList GetItems
//{
// get
// {
// return this.SelectElements("item");
// }
//}
public SearchItem[] GetItems()
{
ElementList nl = SelectElements(typeof(SearchItem));
SearchItem[] items = new SearchItem[nl.Count];
int i = 0;
foreach (Element e in nl)
{
items[i] = (SearchItem)e;
i++;
}
return(items);
}
public Header[] GetHeaders()
{
ElementList nl = SelectElements("header");
var headers = new Header[nl.Count];
int i = 0;
foreach (Element e in nl)
{
headers[i] = (Header)e;
i++;
}
return(headers);
}
/// <summary>
/// Retrieve a field with the given "var"
/// </summary>
/// <param name="var"></param>
/// <returns></returns>
public Field GetField(string var)
{
ElementList nl = SelectElements(typeof(Field));
foreach (Element e in nl)
{
Field f = e as Field;
if (f.Var == var)
{
return(f);
}
}
return(null);
}
public Jid[] GetAddressList()
{
ElementList nl = SelectElements("address");
var addresses = new Jid[nl.Count];
int i = 0;
foreach (Element e in nl)
{
addresses[i] = ((Address)e).Jid;
i++;
}
return(addresses);
}
public DiscoItem[] GetDiscoItems()
{
ElementList nl = SelectElements(typeof(DiscoItem));
DiscoItem[] items = new DiscoItem[nl.Count];
int i = 0;
foreach (Element e in nl)
{
items[i] = (DiscoItem)e;
i++;
}
return(items);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public Subscriber[] GetSubscribers()
{
ElementList nl = SelectElements(typeof(Subscriber));
Subscriber[] subscribers = new Subscriber[nl.Count];
int i = 0;
foreach (Element e in nl)
{
subscribers[i] = (Subscriber)e;
i++;
}
return(subscribers);
}
public Address[] GetAddresses()
{
ElementList nl = SelectElements("address");
var addresses = new Address[nl.Count];
int i = 0;
foreach (Element e in nl)
{
addresses[i] = (Address)e;
i++;
}
return(addresses);
}
/// <summary>
/// Gets all "ChilsServices" od this service
/// </summary>
/// <returns></returns>
public Service[] GetServices()
{
ElementList nl = SelectElements(typeof(Service));
Service[] Services = new Service[nl.Count];
int i = 0;
foreach (Element service in nl)
{
Services[i] = service as Service;
i++;
}
return(Services);
}
public BrowseItem[] GetItems()
{
ElementList nl = SelectElements(typeof(BrowseItem));
BrowseItem[] items = new BrowseItem[nl.Count];
int i = 0;
foreach (Element item in nl)
{
items[i] = item as BrowseItem;
i++;
}
return(items);
}
/// <summary>
/// </summary>
/// <param name="groupname"> </param>
/// <returns> </returns>
public bool HasGroup(string groupname)
{
ElementList groups = GetGroups();
foreach (Group g in groups)
{
if (g.Name == groupname)
{
return(true);
}
}
return(false);
}
/// <summary>
/// get all conference booksmarks
/// </summary>
/// <returns></returns>
public Conference[] GetConferences()
{
ElementList nl = SelectElements(typeof(Conference));
Conference[] items = new Conference[nl.Count];
int i = 0;
foreach (Element e in nl)
{
items[i] = (Conference)e;
i++;
}
return(items);
}
public Method[] GetMethods()
{
ElementList methods = SelectElements(typeof(Method));
Method[] items = new Method[methods.Count];
int i = 0;
foreach (Method m in methods)
{
items[i] = m;
i++;
}
return(items);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public Affiliate[] GetAffiliates()
{
ElementList nl = SelectElements(typeof(Affiliate));
Affiliate[] affiliates = new Affiliate[nl.Count];
int i = 0;
foreach (Element e in nl)
{
affiliates[i] = (Affiliate)e;
i++;
}
return(affiliates);
}
/// <summary>
/// </summary>
/// <returns> </returns>
public Item[] GetItems()
{
ElementList nl = SelectElements(typeof(Item));
var items = new Item[nl.Count];
int i = 0;
foreach (Item itm in nl)
{
items[i] = itm;
i++;
}
return(items);
}
public Subscription[] GetSubscriptions()
{
ElementList nl = SelectElements(typeof(Subscription));
Subscription[] items = new Subscription[nl.Count];
int i = 0;
foreach (Element e in nl)
{
items[i] = (Subscription)e;
i++;
}
return(items);
}
public Affiliation[] GetAffiliations()
{
ElementList nl = SelectElements(typeof(Affiliation));
Affiliation[] items = new Affiliation[nl.Count];
int i = 0;
foreach (Element e in nl)
{
items[i] = (Affiliation)e;
i++;
}
return(items);
}
/// <summary>
/// Gets a list of all form fields
/// </summary>
/// <returns> </returns>
public Field[] GetFields()
{
ElementList nl = SelectElements(typeof(Field));
var fields = new Field[nl.Count];
int i = 0;
foreach (Element e in nl)
{
fields[i] = (Field)e;
i++;
}
return(fields);
}
/// <summary>
/// </summary>
/// <returns> </returns>
public Option[] GetOptions()
{
ElementList nl = SelectElements(typeof(Option));
int i = 0;
var result = new Option[nl.Count];
foreach (Option o in nl)
{
result[i] = o;
i++;
}
return(result);
}
/// <summary>Sends a video streaming status request.</summary>
/// <param name="requestId">Request ID for the corresponding request.</param>
private static void SendVideoStreamingStatusRequest(Guid requestId)
{
ElementList <AvailableElementData> availableElementData = new ElementList <AvailableElementData>();
T2GManagerErrorEnum result = _t2gManager.GetAvailableElementDataList(out availableElementData);
switch (result)
{
case T2GManagerErrorEnum.eSuccess:
foreach (AvailableElementData element in availableElementData)
{
ServiceInfo serviceInfo;
result = _t2gManager.GetAvailableServiceData(element.ElementNumber, (int)eServiceID.eSrvSIF_LiveVideoControlServer, out serviceInfo);
switch (result)
{
case T2GManagerErrorEnum.eSuccess:
ProcessSendVideoStreamingStatusRequestContext request = new ProcessSendVideoStreamingStatusRequestContext(
element.ElementNumber,
requestId,
serviceInfo);
_requestProcessor.AddRequest(request);
break;
case T2GManagerErrorEnum.eT2GServerOffline:
LiveVideoControlService.SendNotificationToGroundApp(requestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.LiveVideoControlT2GServerOffline, string.Empty);
break;
case T2GManagerErrorEnum.eElementNotFound:
LiveVideoControlService.SendNotificationToGroundApp(requestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.LiveVideoControlElementNotFound, element.ElementNumber);
break;
case T2GManagerErrorEnum.eServiceInfoNotFound:
LiveVideoControlService.SendNotificationToGroundApp(requestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.LiveVideoControlServiceNotFound, element.ElementNumber);
break;
default:
break;
}
}
break;
case T2GManagerErrorEnum.eT2GServerOffline:
LiveVideoControlService.SendNotificationToGroundApp(requestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.LiveVideoControlT2GServerOffline, string.Empty);
break;
default:
break;
}
}
public void CanRenderToXmlWriter()
{
ElementList list = new ElementList(
new Element("b").Update("Chris"),
new Element("i").Update("Emmitt"));
string expected = "<b>Chris</b><i>Emmitt</i>";
string actual;
using (StringWriter text = new StringWriter())
{
XmlTextWriter xml = new XmlTextWriter(text);
list.Render(xml);
actual = text.ToString();
}
Assert.AreEqual(expected, actual);
}
public void CanRenderToStream()
{
ElementList list = new ElementList(
new Element("b").Update("Chris"),
new Element("i").Update("Emmitt"));
string expected = "<b>Chris</b><i>Emmitt</i>";
string actual;
byte[] buffer = new byte[expected.Length];
using (MemoryStream stream = new MemoryStream(buffer))
{
list.Render(stream);
actual = System.Text.ASCIIEncoding.ASCII.GetString(buffer);
}
Assert.AreEqual(expected, actual);
}
public static void TapOnFlowElement(int position)
{
try
{
ElementList.GetInternalElement().FindElementsById("document_icon")[position].Click();
ConsoleMessage.Pass(String.Format("{0}. Tap flow element by position: {1}",
ActivityName, position));
}
catch (Exception ex)
{
ConsoleMessage.Fail(String.Format("{0}. Tap flow element by position: {1}",
ActivityName, position), ex);
throw;
}
}
/// <summary>
/// Gets all advertised namespaces of this item
/// </summary>
/// <returns> string array that contains the advertised namespaces </returns>
public string[] GetNamespaces()
{
ElementList elements = SelectElements("ns");
var nss = new string[elements.Count];
int i = 0;
foreach (Element ns in elements)
{
nss[i] = ns.Value;
i++;
}
return(nss);
}
public bool Update(ElementList sParams)
{
DataRow dr = null;
string table = "LMINCCAppContext";
dr = Get();
if (dr == null)
{
string sSQL = "Insert into " + table;
sSQL += sParams.ColumnsValues;
return db.Execute(sSQL);
}
else
{
string sSQL1 = "UPDATE " + table + " SET ";
string sSQL = sSQL1 + sParams.ColumnEqValueList;
return db.Execute(sSQL);
}
}
public bool Update(string DetectorName, string CounterType, ElementList sParams)
{
DataRow dr = null;
string table = "CountingParams";
if (CounterType.Equals("Multiplicity") || CounterType.Equals("Coincidence"))
table = "LMMultiplicity";
Detectors dets = new Detectors(db);
long l = dets.PrimaryKey(DetectorName);
if (l == -1)
{
DBMain.AltLog(LogLevels.Warning, 70137, "Missing Det key ({0}) selecting CountingParams", l);
return false;
}
if (table.Equals("LMMultiplicity"))
dr = HasRow(DetectorName, CounterType, table, sParams[faidx].Value); // the FA parameter
else
dr = HasRow(DetectorName, CounterType, table);
if (dr == null)
{
sParams.Add(new Element("detector_id", l));
string sSQL = "Insert into " + table;
sSQL += sParams.ColumnsValues;
return db.Execute(sSQL);
}
else
{
//NEXT: not tested(?)
string sSQL = "UPDATE " + table + " SET ";
sSQL += (sParams.ColumnEqValueList + " where counter_type=" + SQLSpecific.QVal(CounterType) + " AND detector_id=" + l.ToString());
if (table.Equals("LMMultiplicity"))
sSQL += " AND " + sParams[faidx].Name + "=" + sParams[faidx].Value;
return db.Execute(sSQL);
}
}
public bool Update(string DetectorName, string ItemType, ElementList sParams)
{
bool res = false;
db.SetConnection();
//NEXT: this duo-lookup part takes too long, so get the values once in a wrapper call, then cache them, then reuse them
DataRow dr = HasRow(DetectorName, ItemType); // sets the connection
Detectors dets = new Detectors(db);
long l = dets.PrimaryKey(DetectorName);
Descriptors mats = new Descriptors("material_types", db);
long m = mats.PrimaryKey(ItemType);
if (l == -1 || m == -1)
{
DBMain.AltLog(LogLevels.Warning, 70130, "Missing Det/Mat keys ({0},{1}) selecting AnalysisMethods", l, m);
return false;
}
if (dr == null) // a new entry!
{
string sSQL = "insert into analysis_method_rec ";
sParams.Add(new Element("item_type_id", m));
sParams.Add(new Element("analysis_method_detector_id", l));
sSQL = sSQL + sParams.ColumnsValues;
res = db.Execute(sSQL);
}
else
{
string wh = " where item_type_id= " + m.ToString() + " AND analysis_method_detector_id=" + l.ToString();
string sSQL1 = "UPDATE analysis_method_rec SET ";
string sSQL = sSQL1 + sParams.ColumnEqValueList + wh;
res = db.Execute(sSQL);
}
return res;
}
public bool Update(string name, ElementList sParams)
{
db.SetConnection();
long m = PrimaryKey(name);
string sSQL1 = "UPDATE stratum_ids SET ";
string wh = " where stratum_id = " + m.ToString();
string sSQL = sSQL1 + sParams.ColumnEqValueList + wh;
return db.Execute(sSQL);
}
// TODO: update results and method results in same step
public bool unraeadyUpdate(string detname, DateTime date, ElementList resParams, ElementList methodParams)
{
db.SetConnection();
Measurements ms = new Measurements(db);
ArrayList sqlList = new ArrayList(); //.......
long l = ms.PrimaryKey(detname, date);
string sSQL1 = "UPDATE " + table + " SET ";
string wh = " where mid=" + l.ToString();
string sSQL = sSQL1 + resParams.ColumnEqValueList + wh;
return db.Execute(sSQL);
}
public long Create(string detname, DateTime date, ElementList resParams)
{
db.SetConnection();
Measurements ms = new Measurements(db);
long mid = ms.PrimaryKey(detname, date);
return Create(mid, resParams);
}
public bool Update(long rid, ElementList sParams)
{
db.SetConnection();
ArrayList sqlList = new ArrayList();
string sSQL1 = "UPDATE results_rec SET ";
string wh = " where id=" + rid.ToString();
string sSQL = sSQL1 + sParams.ColumnEqValueList + wh;
return db.Execute(sSQL);
}
public void xtor()
{
Console.WriteLine("ElementCollection:xtor");
_singles = new ElementList();
_multiples = new System.LinkedList<ElementRef>();
}
public long CreateNetComm(long id, ElementList sParams, IDB db)
{
return CreateTbl(id, "LMNetComm", sParams, db);
}
public bool Update(string measDetId, string table, ElementList sParams)
{
db.SetConnection();
Detectors dets = new Detectors(db);
long l = dets.PrimaryKey(measDetId);
if (table == "net")
return UpdateNetComm(l, sParams, db);
else
return UpdateCfg(l, sParams, db);
}
public bool UpdateCfg(long id, ElementList sParams, IDB db)
{
return UpdateTbl(id, "LMHWParams", sParams, db);
}
// create a stratum
public long Create(ElementList sParams)
{
db.SetConnection();
ArrayList sqlList = new ArrayList();
string sSQL = InsertStratum(sParams);
sqlList.Add(sSQL);
sqlList.Add(SQLSpecific.getLastID("stratum_ids"));
return db.ExecuteTransactionID(sqlList);
}
public bool UpdateTbl(long id, string table, ElementList sParams, IDB db)
{
db.SetConnection();
string sSQL1 = "UPDATE " + table + " SET ";
string sSQL1i = String.Empty;
string wh = " where detector_id = " + id.ToString();
string sSQL = sSQL1 + sParams.ColumnEqValueList + wh;
return db.Execute(sSQL);
}
/**
* Parses an HTML string and a string containing CSS into a list of Element objects.
* The FontProvider will be obtained from iText's FontFactory object.
*
* @param html a String containing an XHTML snippet
* @param css a String containing CSS
* @return an ElementList instance
*/
public static ElementList ParseToElementList(String html, String css) {
// CSS
ICSSResolver cssResolver = new StyleAttrCSSResolver();
if (css != null) {
ICssFile cssFile = XMLWorkerHelper.GetCSS(new MemoryStream(Encoding.Default.GetBytes(css)));
cssResolver.AddCss(cssFile);
}
// HTML
CssAppliers cssAppliers = new CssAppliersImpl(FontFactory.FontImp);
HtmlPipelineContext htmlContext = new HtmlPipelineContext(cssAppliers);
htmlContext.SetTagFactory(Tags.GetHtmlTagProcessorFactory());
htmlContext.AutoBookmark(false);
// Pipelines
ElementList elements = new ElementList();
ElementHandlerPipeline end = new ElementHandlerPipeline(elements, null);
HtmlPipeline htmlPipeline = new HtmlPipeline(htmlContext, end);
CssResolverPipeline cssPipeline = new CssResolverPipeline(cssResolver, htmlPipeline);
// XML Worker
XMLWorker worker = new XMLWorker(cssPipeline, true);
XMLParser p = new XMLParser(worker);
p.Parse(new MemoryStream(Encoding.Default.GetBytes(html)));
return elements;
}
///////////////////////
public bool UpdateCalib(string DetectorName, string ItemType, string calib_table, ElementList sParams)
{
//NEXT: this duo-lookup part takes too long, so get the values once in a wrapper call, then cache them, then reuse them
long l, m;
GetKeys(DetectorName, ItemType, out l, out m);
DataRow dr = HasRow(l, m); // sets the connection
if (l == -1 || m == -1)
{
DBMain.AltLog(LogLevels.Warning, 70137, "Missing Det/Mat keys ({0},{1}) selecting method calibration params", l, m);
return false;
}
string wh = " where item_type_id= " + m.ToString() + " AND detector_id=" + l.ToString();
string exsql = "select item_type_id from " + calib_table + wh; // 1 column is sufficient to show existence
DataTable dt = db.DT(exsql);
if (dt.Rows.Count < 1)
{
string sSQL = "insert into " + calib_table + " ";
sParams.Add(new Element("item_type_id", m));
sParams.Add(new Element("detector_id", l));
sSQL += sParams.ColumnsValues;
return db.Execute(sSQL);
}
else
{
string sSQL1 = "UPDATE " + calib_table + " SET ";
string sSQL = sSQL1 + sParams.ColumnEqValueList + wh;
return db.Execute(sSQL);
}
}
// create a stratum and detector stratum association
public bool Create(string measDetId, ElementList sParams)
{
db.SetConnection();
Detectors dets = new Detectors(db);
long l = dets.PrimaryKey(measDetId);
string sSQL = InsertStratum(sParams);
ArrayList sqlList = new ArrayList();
sqlList.Add(sSQL);
sqlList.Add(SQLSpecific.getLastID("stratum_ids"));
long newID = db.ExecuteTransactionID(sqlList);
string saSQL = "insert into stratum_id_detector VALUES(" + l.ToString() + "," + newID.ToString() + ")";
return db.Execute(saSQL);
}
public long CreateTbl(long id, string table, ElementList sParams, IDB db)
{
sParams.Add(new Element("detector_id", id));
string sSQL1 = "Insert into " + table + " ";
string sSQL = sSQL1 + sParams.ColumnsValues;
ArrayList sqlList = new ArrayList();
sqlList.Add(sSQL);
sqlList.Add(SQLSpecific.getLastID(table));
return db.ExecuteTransactionID(sqlList);
}
public bool UpdateNetComm(long id, ElementList sParams, IDB db)
{
return UpdateTbl(id, "LMNetComm", sParams, db);
}
private string InsertStratum(ElementList sParams)
{
string sSQL1 = "Insert into stratum_ids " + sParams.ColumnsValues;
return sSQL1;
}
