public void writing_to_an_existing_file_overwrites_it()
{
// TODO: this currently gives us two files with the same name.
// it should result in the equivalent of a delete+store
using (var subject = Datastore.TryConnect(TestFilePath)) {
Assert.That(subject, Is.Not.Null, "Database connector failed");
var firstFile = MakeSourceStream("I am first file");
var secondFile = MakeSourceStream("file two");
var info_A = subject.Store("test_name", firstFile);
var info_B = subject.Store("test_name", secondFile);
Assert.That(info_A, Is.Not.Null, "Storage result was invalid");
Assert.That(info_B, Is.Not.Null, "Storage result was invalid");
var storedFiles = subject.ListFiles();
var list = string.Join(", ", storedFiles.Select(e => e.FileName + " = " + e.ID.ShortString()));
Assert.That(storedFiles.Length, Is.EqualTo(1), $"Expected one file, but got {storedFiles.Length} --> {list}");
Console.WriteLine($"{info_A.ID} then {info_B.ID}");
var ms2 = new MemoryStream();
var info2 = subject.Read(info_B.ID, ms2);
ms2.Seek(0, SeekOrigin.Begin);
Console.WriteLine($"{info_B.ID} -> {info2.ID}");
var result = Encoding.UTF8.GetString(ms2.ToArray());
Assert.That(result, Is.EqualTo("file two"), "unexpected message");
Assert.That(info_B.ID, Is.EqualTo(info2.ID), "Id changed");
}
}
} // BeginLoadEpgPrograms
private void LoadEpgPrograms(LoadEpgProgramsData data)
{
var programs = Datastore.GetPrograms(data.FullServiceName, LocalReferenceTime, 1, 2);
// try alternate service if no EPG data
if ((programs == null) && (data.FullAlternateServiceName != null))
{
programs = Datastore.GetPrograms(data.FullAlternateServiceName, LocalReferenceTime, 1, 2);
} // if
// populate data
if (programs != null)
{
var epgPrograms = new EpgProgram[4];
epgPrograms[0] = programs.Requested?.Previous?.Program;
epgPrograms[1] = programs.Requested?.Program;
var next = programs.Requested?.Next;
epgPrograms[2] = next?.Program;
next = next?.Next;
epgPrograms[3] = next?.Program;
data.EpgPrograms = epgPrograms;
} // if
if (InvokeRequired)
{
BeginInvoke(new Action <LoadEpgProgramsData>(LoadEpgProgramsEnded), data);
}
else
{
LoadEpgProgramsEnded(data);
} // if-else
} // LoadEpgPrograms
public void can_store_multiple_files()
{
using (var subject = Datastore.TryConnect(TestFilePath)) {
Assert.That(subject, Is.Not.Null, "Database connector failed");
var ms1 = MakeSourceStream();
var ms2 = MakeSourceStream();
var ms3 = MakeSourceStream();
var info1 = subject.Store("test1", ms1);
var info2 = subject.Store("test2", ms2);
var info3 = subject.Store("sub/test3", ms3);
var ms_result = new MemoryStream();
var info_result = subject.Read(info2.ID, ms_result);
ms_result.Seek(0, SeekOrigin.Begin);
var result = Encoding.UTF8.GetString(ms_result.ToArray());
Assert.That(result, Is.EqualTo(message), "message changed");
Assert.That(info_result.ID, Is.EqualTo(info2.ID), "Id changed");
Assert.That(info_result.ID, Is.Not.EqualTo(info1.ID), "Id mismatch");
Assert.That(info_result.ID, Is.Not.EqualTo(info3.ID), "Id mismatch");
var list = string.Join(", ", subject.ListFiles().Select(e => e.FileName));
Assert.That(list, Is.EqualTo("test1, test2, sub/test3"));
}
}
public void can_get_files_by_complete_path()
{
using (var subject = Datastore.TryConnect(TestFilePath)) {
Assert.That(subject, Is.Not.Null, "Database connector failed");
var ms1 = MakeSourceStream("This is my file content");
subject.Store("find/me/test1", ms1);
string recovered;
using (var ms2 = new MemoryStream())
{
var result = subject.Read("find/me/test1", ms2);
Assert.That(result, Is.Not.Null, "Null entry returned");
Assert.That(result.FileName, Is.EqualTo("find/me/test1"));
ms2.Seek(0, SeekOrigin.Begin);
recovered = Encoding.UTF8.GetString(ms2.ToArray());
}
Assert.That(recovered, Is.EqualTo("This is my file content"));
}
}
private void LoadDatastoreCache(NetVimClient.ObjectContent[] rawDatastores)
{
IEnumerable <string> cachedDatastoreNames = _datastoreCache.Keys;
List <string> activeDatastoreNames = new List <string>();
Dictionary <string, Datastore> datastores = new Dictionary <string, Datastore>();
foreach (var rawDatastore in rawDatastores)
{
try
{
Datastore datastore = new Datastore
{
Name = rawDatastore.GetProperty("name").ToString(),
Reference = rawDatastore.obj,
Browser = rawDatastore.GetProperty("browser") as ManagedObjectReference
};
_datastoreCache.TryAdd(rawDatastore.GetProperty("name").ToString(), datastore);
activeDatastoreNames.Add(datastore.Name);
}
catch (Exception ex)
{
_logger.LogError(ex, $"Error refreshing Datastore {rawDatastore.obj.Value}");
}
}
// clean cache of non-active datastores
foreach (var dsName in cachedDatastoreNames)
{
if (!activeDatastoreNames.Contains(dsName))
{
_logger.LogDebug($"removing stale datastore cache entry {dsName}");
_datastoreCache.Remove(dsName, out Datastore stale);
}
}
}
public int DeleteSampleGroup(Datastore dal, long?SampleGroup_CN)
{
// check tree table for data
if (dal.GetRowCount("Tree", "WHERE SampleGroup_CN = @p1", SampleGroup_CN) > 0)
{
return(-1);
}
// Check Count table for each sample group
if (dal.GetRowCount("CountTree", "WHERE SampleGroup_CN = @p1 AND TreeCount > 0", SampleGroup_CN) > 0)
{
return(-1);
}
//Delete Count Records for stratum
var allCountInSg = dal.From <CountTreeDO>()
.Where("SampleGroup_CN = @p1")
.Read(SampleGroup_CN).ToList();
foreach (CountTreeDO Cnt in allCountInSg)
{
Cnt.Delete();
}
Delete();
return(0);
}
public static async Task <Session> Start(string absolutePath)
{
try
{
using var write = File.OpenWrite(absolutePath);
write.Close();
}
catch
{
return(null);
}
var session = new Session()
{
AbsolutePath = absolutePath
};
session.Datastore = await Datastore.Initialize(session);
session.Logger = await Logger.Initialize(session);
session.Appearance = await Appearance.Initialize(session);
session.BinanceWrapper = await BinanceWrapper.Initialize(session);
session.Logger.AddLog(new Log(DateTime.Now, "General", "Initializing . . .", LogType.Info));
return(session);
}
public static List <Event> List(EventListener EventListener)
{
List <Event> result = new List <Event> ();
foreach (Datastore.Item item in Datastore.List(DatastoreAisle, Datastore.Filter.Where("ownerid", Datastore.Filter.ComparisonOperator.NotEqual, EventListener.Id), Datastore.Sort.AccendingBy("sort")))
{
try
{
Event e = FromData(item.Data);
if (e._updatetimestamp >= EventListener.UpdateTimestamp)
{
result.Add(e);
}
}
catch (Exception exception)
{
// LOG: LogDebug.ExceptionUnknown
Logging.LogDebug(string.Format(SorentoLib.Strings.LogDebug.ExceptionUnknown, typeof(Event), exception.Message));
// LOG: LogDebug.EventList
Logging.LogDebug(string.Format(Strings.LogDebug.EventList, item.Id));
}
}
// result.Sort (delegate (Event e1, Event e2) { return e1.Sort.CompareTo (e2.Sort); });
return(result);
}
public async Task <bool> GDBContainsMilitaryOverlay(GDBProjectItem gdbProjectItem)
{
if (gdbProjectItem == null)
{
return(false);
}
string militaryOverlayFeatureDatasetName = "militaryoverlay";
bool gdbContainsMilitaryOverlay = await
ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run <bool>(() =>
{
using (Datastore datastore = gdbProjectItem.GetDatastore())
{
// Unsupported datastores (non File GDB and non Enterprise GDB) will be of type UnknownDatastore
if (datastore is UnknownDatastore)
{
return(false);
}
Geodatabase geodatabase = datastore as Geodatabase;
if (geodatabase == null)
{
return(false);
}
var defs = geodatabase.GetDefinitions <FeatureDatasetDefinition>().Where(fd => fd.GetName().Contains(militaryOverlayFeatureDatasetName)).ToList();;
return(defs.Count > 0);
}
});
return(gdbContainsMilitaryOverlay);
}
private void Log(Message message)
{
#if DEBUG
Logger.Write($"{message.Ordinal} {message.SenderName}: {message.OriginalText}");
#endif
Datastore.InsertMessage(message);
}
public IEnumerable <TIEntity> Top(int quantity)
{
var select = new SelectTop <TIEntity>(this, quantity);
SelectStatement = select;
return(Datastore.ExecuteQuery(this, select));
}
/// <summary>
/// Test a modbus RTU slave
/// </summary>
static void Test_ModbusRTUSlave()
{
byte unit_id = 1;
// Created datastore for unit ID 1
Datastore ds = new Datastore(unit_id);
// Crete instance of modbus serial RTU (replace COMx with a free serial port - ex. COM5)
ModbusSlaveSerial ms = new ModbusSlaveSerial(new Datastore[] { ds }, ModbusSerialType.RTU, "COM1", 9600, 8, Parity.Even, StopBits.One, Handshake.None);
// Start listen
ms.StartListen();
// Print and write some registers...
Random rnd = new Random();
while (true)
{
Console.Write(
"---------------------- READING ----------------------" + Environment.NewLine +
"Holding register n.1 : " + ms.ModbusDB.Single(x => x.UnitID == unit_id).HoldingRegisters[0].ToString("D5") + Environment.NewLine +
"Holding register n.60 : " + ms.ModbusDB.Single(x => x.UnitID == unit_id).HoldingRegisters[59].ToString("D5") + Environment.NewLine +
"Coil register n.32 : " + ms.ModbusDB.Single(x => x.UnitID == unit_id).Coils[31].ToString() + Environment.NewLine +
"---------------------- WRITING ----------------------" + Environment.NewLine);
ms.ModbusDB.Single(x => x.UnitID == unit_id).HoldingRegisters[1] = (ushort)rnd.Next(ushort.MinValue, ushort.MaxValue);
Console.WriteLine(
"Holding register n.2 : " + ms.ModbusDB.Single(x => x.UnitID == unit_id).HoldingRegisters[1].ToString("D5"));
ms.ModbusDB.Single(x => x.UnitID == unit_id).Coils[15] = Convert.ToBoolean(rnd.Next(0, 1));
Console.WriteLine(
"Coil register n.16 : " + ms.ModbusDB.Single(x => x.UnitID == unit_id).Coils[15].ToString());
// Exec the cicle each 2 seconds
Thread.Sleep(2000);
}
}
public static List <Event> List()
{
List <Event> result = new List <Event> ();
foreach (Datastore.Item item in Datastore.List(DatastoreAisle, Datastore.Sort.AccendingBy("sort")))
{
try
{
result.Add(FromData(item.Data));
}
catch (Exception exception)
{
// LOG: LogDebug.ExceptionUnknown
Logging.LogDebug(string.Format(SorentoLib.Strings.LogDebug.ExceptionUnknown, typeof(Event), exception.Message));
// LOG: LogDebug.EventList
Logging.LogDebug(string.Format(Strings.LogDebug.EventList, item.Id));
}
}
// result.Sort (delegate (Event e1, Event e2) { return e1.UpdateTimestamp.CompareTo (e2.UpdateTimestamp); });
return(result);
}
public IEnumerable <TIEntity> GetValues()
{
var select = new Select <TIEntity>(this);
SelectStatement = select;
return(Datastore.ExecuteQuery(this, select));
}
//------------------------------------------------------------------------------------
/// <summary>
/// Will be called any time there's a set of DSItems to be deferred during a normal
/// planning query.
/// </summary>
//------------------------------------------------------------------------------------
public void ReceiveStoreItemsToDefer(Datastore store, DatastoreItems items)
{
foreach (DatastoreItem dsItem in items)
{
DeferStoreItem(store, dsItem, IsRefresh.No);
}
}
public LocalDatabase(Datastore ds)
{
this.Environment = DBEnvironment.Local;
this.DataStore = ds;
switch (this.DataStore)
{
case Datastore.Monitoring:
this.User = "******";
this.Password = "******";
this.Database = "Moniverse";
this.Server = "instinctserver";
break;
case Datastore.General:
this.User = "******";
this.Password = "******";
this.Database = "playverseDB";
this.Server = "pvdb-prod-general-s0.cegaxwwurgzs.us-east-1.rds.amazonaws.com";
break;
case Datastore.Validation:
this.User = "******";
this.Password = "******";
this.Database = "ValidationTests";
this.Server = "instinctserver";
break;
default:
this.User = "******";
this.Password = "******";
this.Database = "playverseDB";
this.Server = "instinctserver";
break;
}
SetConnectionString();
}
private void DeferStoreItem(Datastore store, DatastoreItem dsItem, IsRefresh isRefreshedItem)
{
DeferredStoreItem deferredItem = new DeferredStoreItem(store, dsItem, isRefreshedItem);
m_deferredStoreItems.Add(deferredItem);
DeferredItemCount++;
}
public Datastore GetDatastoreByName(string dsName)
{
Datastore datastore = null;
_datastoreCache.TryGetValue(dsName, out datastore);
return(datastore);
}
public void multiple_threads_reading_and_writing_is_supported()
{
ThreadPool.SetMinThreads(10, 10);
ThreadPool.SetMaxThreads(10, 10);
int count = 0;
const int target = 100;
long rawSize = 0;
using (var stream = new MemoryStream())
{
var subject = Datastore.TryConnect(stream);
for (int i = 0; i < target; i++)
{
var j = i;// unbind closure
ThreadPool.QueueUserWorkItem(x =>
{
try
{
var data = MakeSourceStream("Data for item " + j);
var info = subject.Store($"file_{j}", data);
rawSize += info.FileName.Length + data.Length;
ThreadPool.QueueUserWorkItem(y => {
using (var result = new MemoryStream())
{
var entry = subject.Read(info.ID, result);
result.Seek(0, SeekOrigin.Begin);
var str = Encoding.UTF8.GetString(result.ToArray());
Assert.That(entry.FileName, Is.EqualTo($"file_{j}"));
Assert.That(str, Is.EqualTo("Data for item " + j));
}
});
}
catch (Exception ex) {
Console.WriteLine($"Writing item {j} failed with: " + ex);
}
finally
{
Interlocked.Increment(ref count);
}
});
}
// wait for threads
while (count < target)
{
Thread.Sleep(100);
}
var everything = subject.ListFiles();
Assert.That(everything.Length, Is.EqualTo(target), $"Expected {target} files, but got {everything.Length}");
subject.Flush();
Console.WriteLine($"Total storage size = {stream.Length} for data = {rawSize}");
}
}
public Database(string dbPath)
{
database = new SQLiteConnection(dbPath);
database.CreateTable <EventsDB>();
database.CreateTable <AnnouncementDB>();
database.CreateTable <AssesmentDB>();
database.CreateTable <ClassDB>();
database.CreateTable <ResourcesDB>();
database.CreateTable <UnitDB>();
if (database.Table <UnitDB>().ToList().Count == 0)
{
ObservableCollection <Unit> units = Datastore.GenerateAllUnits();
foreach (Unit unit in units)
{
SaveUnit(unit);
}
}
database.CreateTable <SemesterDB>();
database.CreateTable <StudentDB>();
if (database.Table <StudentDB>().ToList().Count == 0)
{
List <Unit> units = GetUnits();
Student student = Datastore.GetStudent();
SaveStudent(student);
}
}
//------------------------------------------------------------------------------------
/// <summary>
/// Background worker for BeginOpenProductGroup - this routine attempts to read the
/// item from the backing store that represents the last-opened product group.
/// </summary>
//------------------------------------------------------------------------------------
void openProductGroupTask_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
{
BackgroundTask taskWorker = e.Argument as BackgroundTask;
taskWorker.ReportProgress(0, "", "Starting up...");
//try
{
m_currentProductGroupKey = Planner.Instance.UserPreferences.GetGlobalPreference <string>(GlobalPreference.LastOpenProductGroupKey);
CurrentProductGroup = Datastore.GetStoreItem(m_currentProductGroupKey) as ProductGroupItem;
if (CurrentProductGroup == null || !CurrentProductGroup.IsActive)
{
m_currentProductGroupKey = null;
}
e.Result = new BackgroundTaskResult {
ResultType = ResultType.Completed
};
}
//catch (Exception exception)
//{
// e.Result = new BackgroundTaskResult { ResultType = ResultType.Failed, ResultMessage = exception.Message };
//}
}
/// <summary>
/// Retrieves as many data points as are ready from the Datastore
/// property and puts them into the Data property.
/// </summary>
/// <returns>
/// The number of data points retrieved from the Datastore.
/// </returns>
protected long UpdateData()
{
// Get the points and figure out how many there are.
float[][] newPoints = Datastore.Dequeue();
if (newPoints == null)
{
return(0);
}
long length = newPoints.Length;
if (length < 1)
{
return(0);
}
// Update the points in Data.
Data.AddData(newPoints);
// If the field names haven't been set yet, do so now.
ColumnTitles = Datastore.Labels;
if (ColumnTitles != null && !ColumnTitlesAreReady)
{
ColumnTitlesAreReady = true;
}
return(length);
}
private void button1_Click(object sender, EventArgs e)
{
byte unit_id = 1;
// Created datastore for unit ID 1
Datastore ds = new Datastore(unit_id);
// Crete instance of modbus serial RTU (replace COMx with a free serial port - ex. COM5)
ModbusSlaveSerial ms = new ModbusSlaveSerial(new Datastore[] { ds }, ModbusSerialType.RTU, "COM1", 9600, 8, Parity.Even, StopBits.One, Handshake.None);
// Start listen
ms.StartListen();
// Print and write some registers...
Random rnd = new Random();
while (true)
{
textBox1.Text = "Holding register n.1 : " + ms.ModbusDB.Single(x => x.UnitID == unit_id).HoldingRegisters[0].ToString("D5") +
"Holding register n.60 : " + ms.ModbusDB.Single(x => x.UnitID == unit_id).HoldingRegisters[59].ToString("D5") +
"Coil register n.32 : " + ms.ModbusDB.Single(x => x.UnitID == unit_id).Coils[31].ToString();
ms.ModbusDB.Single(x => x.UnitID == unit_id).HoldingRegisters[1] = (ushort)rnd.Next(ushort.MinValue, ushort.MaxValue);
textBox2.Text = "Holding register n.2 : " + ms.ModbusDB.Single(x => x.UnitID == unit_id).HoldingRegisters[1].ToString("D5");
ms.ModbusDB.Single(x => x.UnitID == unit_id).Coils[15] = Convert.ToBoolean(rnd.Next(0, 1));
textBox3.Text = "Coil register n.16 : " + ms.ModbusDB.Single(x => x.UnitID == unit_id).Coils[15].ToString();
// Exec the cicle each 2 seconds
delayTime(2);
}
}
public long Count(params Object[] selectionArgs)
{
var builder = Builder;
var countBuilder = new SqlSelectBuilder
{
Source = builder.Source,
Dialect = builder.Dialect,
WhereClause = builder.WhereClause,
GroupByClause = builder.GroupByClause,
OrderByClause = builder.OrderByClause,
LimitClause = builder.LimitClause,
Clauses = builder.Clauses,
};
foreach (var jc in builder.JoinClauses)
{
countBuilder.JoinClauses.Add(jc);
}
countBuilder.ResultColumns.Add("count(1)");
var connection = Connection;
if (connection != null)
{
return(connection.ExecuteScalar <long>(countBuilder.ToString() + ";", parameters: selectionArgs));
}
else
{
return(Datastore.ExecuteScalar <long>(countBuilder.ToString() + ";", parameters: selectionArgs));
}
}
public static List <PlotDO> ReadyByUnitStratum(Datastore dal, String unit, String stratum)
{
if (dal == null)
{
return(null);
}
if (String.IsNullOrEmpty(unit))
{
return(dal.From <PlotDO>()
.Join("Stratum", "USING (Stratum_CN)")
.Where("Stratum.Code = @p1")
.Read(stratum).ToList());
//.Read<PlotDO>("JOIN Stratum WHERE Plot.Stratum_CN = Stratum.Stratum_CN AND Stratum.Code = ?;", (object)stratum);
}
else if (String.IsNullOrEmpty(stratum))
{
return(dal.From <PlotDO>()
.Join("CuttingUnit", "USING (CuttingUnit_CN)")
.Where("CuttingUnit.Code = @p1")
.Read(unit).ToList());
//.Read<PlotDO>("JOIN CuttingUnit WHERE Plot.CuttingUnit_CN = CuttingUnit.CuttingUnit_CN AND CuttingUnit.Code = ?;", (object)unit);
}
return(dal.From <PlotDO>()
.Join("CuttingUnit", "USING (CuttingUnit_CN)")
.Join("Stratum", "USING (Stratum_CN)")
.Where("CuttingUnit.Code = @p1 AND Stratum.Code = @p2")
.Read(unit, stratum).ToList());
//.Read<PlotDO>("JOIN CuttingUnit JOIN Stratum WHERE Plot.CuttingUnit_CN = CuttingUnit.CuttingUnit_CN AND CuttingUnit.Code = ? AND Plot.Stratum_CN = Stratum.Stratum_CN AND Stratum.Code = ?;", (object)unit, stratum);
}
public int Count()
{
var countedEntity = Query.Entity;
var columnValue = Datastore.ToColumnValue(countedEntity, countedEntity.PrimaryKey.FieldName);
SelectStatement = Queries.Count.CreateColumnCount(columnValue);
return(Datastore.ExecuteScalar(this));
}
private async Task LoadData()
{
AndroidHUD.AndHUD.Shared.Show(this, "Loading...", -1, AndroidHUD.MaskType.Black, null, null, true, null);
listesamplefull = await Datastore.GetSamplesFromWebAsync(this);
//listesamplefull = await Datastore.GetSamplesFromAssetsAsync(this, "sounds.json");
await LoadFilteredData("");
}
public bool TryLogMessage(string message, string level)
{
try
{
Datastore.LogMessage(message, level);
return(true);
}
catch { return(false); }
}
public void Init()
{
db = DatastoreDb.Create(projectId);
if (ds != null)
{
Debug.LogError("Trying to initialize a Datastore instance when one already exists");
}
ds = this;
}
public static int DeleteStratum(Datastore dal, StratumDO stratum)
{
// check tree table for data
if (dal.GetRowCount("Tree", "WHERE Stratum_CN = @p1", stratum.Stratum_CN) > 0)
{
return(-1);
}
// check plot table for data
if (dal.GetRowCount("Plot", "WHERE Stratum_CN = @p1", stratum.Stratum_CN) > 0)
{
return(-1);
}
// Check Count table for each sample group
if (dal.GetRowCount("CountTree", "JOIN SampleGroup ON CountTree.SampleGroup_CN = SampleGroup.SampleGroup_CN WHERE SampleGroup.Stratum_CN = @p1 AND CountTree.TreeCount > 0", stratum.Stratum_CN) > 0)
{
return(-1);
}
//Delete sample groups for stratum
List <SampleGroupDO> allSGInStratum = dal.From <SampleGroupDO>()
.Where("Stratum_CN = @p1")
.Read(stratum.Stratum_CN).ToList();
//.Read<SampleGroupDO>("WHERE Stratum_CN = ?", stratum.Stratum_CN);
foreach (SampleGroupDO Sg in allSGInStratum)
{
//Delete Count Records for stratum
List <CountTreeDO> allCountInSG = dal.From <CountTreeDO>()
.Where("SampleGroup_CN = @p1")
.Read(Sg.SampleGroup_CN).ToList();
//.Read<CountTreeDO>("WHERE SampleGroup_CN = ?", Sg.SampleGroup_CN);
foreach (CountTreeDO Cnt in allCountInSG)
{
Cnt.Delete();
}
Sg.Delete();
}
//Delete stratum stats for stratum
List <StratumStatsDO> allStratumStatsInStratum = dal.From <StratumStatsDO>()
.Where("Stratum_CN = @p1")
.Read(stratum.Stratum_CN)
.ToList();
//.Read<StratumStatsDO>(
//"WHERE Stratum_CN = ?", stratum.Stratum_CN);
foreach (StratumStatsDO StratumStats in allStratumStatsInStratum)
{
StratumStats.DeleteStratumStats(dal, StratumStats.StratumStats_CN);
}
stratum.Delete();
return(0);
}
//private void OnUniqueChanged()
//{
// if (this._viewLoading) { return; }
// if (this.TreeDefaultValue.IsPersisted == false)
// {
// if (this.HasUniqueConflict(this.TreeDefaultValue))
// {
// MessageBox.Show("Tree Default values entered conflict with existing Tree Default.\r\n" +
// "Please change Species, Primary Product, or Live Dead values");
// }
// }
//}
private bool HasUniqueConflict(TreeDefaultValueDO tdv)
{
if (Datastore == null)
{
return(false);
}
return(Datastore.GetRowCount(CruiseDAL.Schema.TREEDEFAULTVALUE._NAME,
"WHERE PrimaryProduct = ? AND Species = ? AND LiveDead = ?",
tdv.PrimaryProduct, tdv.Species, tdv.LiveDead) > 0);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="connectDomain"></param>
/// <param name="productName"></param>
/// <param name="onBehalfOf"></param>
public PSDataAccess(string connectDomain, string productName, string onBehalfOf = null)
{
this.connectDomain = connectDomain;
this.productName = productName;
try
{
this.psDirectory = new ProductStudio.Directory();
this.psDirectory.Connect(connectDomain, "", "");
this.psProduct = this.psDirectory.GetProductByName(productName);
this.psDataStore = this.psProduct.Connect("", "", onBehalfOf);
}
catch (Exception e)
{
throw new Exception(String.Format("Failed to initialize Product Studio connection for domain: {0} and product: {1}",
connectDomain, productName), e);
}
}
public StagingDatabase(Datastore ds)
{
this.DataStore = ds;
this.Environment = DBEnvironment.Staging;
switch (this.DataStore)
{
case Datastore.Monitoring:
this.User = "******";
this.Database = "Moniverse";
this.Password = "******";
this.Server = "staging-monitoring.cegaxwwurgzs.us-east-1.rds.amazonaws.com";
break;
case Datastore.General:
this.User = "******";
this.Database = "playverseDB";
this.Password = "******";
this.Server = "pvdb-prod-general-s0.cegaxwwurgzs.us-east-1.rds.amazonaws.com";
break;
}
SetConnectionString();
}
public ProductionDatabase(Datastore ds)
{
this.Environment = DBEnvironment.Production;
this.DataStore = ds;
switch (this.DataStore)
{
case Datastore.Monitoring:
this.User = "******";
this.Password = "******";
this.Database = "Moniverse";
this.Server = "prod-monitoring.cegaxwwurgzs.us-east-1.rds.amazonaws.com";
break;
case Datastore.General:
this.User = "******";
this.Password = "******";
this.Database = "playverseDB";
this.Server = "pvdb-prod-general-s0.cegaxwwurgzs.us-east-1.rds.amazonaws.com";
break;
default:
this.Server = "instinctserver";
break;
}
SetConnectionString();
}
