protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
SetContentView(Resource.Layout.activity_section_uer);
SetBackBtn();
SetTitle("Section Use");
_recyclerView = FindViewById <RecyclerView>(Resource.Id.rv_list);
_recyclerView.SetLayoutManager(new GridLayoutManager(this, 2));
_data = DataServer.GetSampleData();
var sectionAdapter = new SectionAdapter(Resource.Layout.item_section_content, Resource.Layout.def_section_head, _data);
sectionAdapter.ItemClick += (s, e) =>
{
var mySection = _data[e.Position];
if (mySection.IsHeader)
{
Toast.MakeText(this, mySection.Header, ToastLength.Long).Show();
}
else
{
Toast.MakeText(this, (mySection.T as Video).Name, ToastLength.Long).Show();
}
};
sectionAdapter.ItemChildClick += (s, e) =>
{
Toast.MakeText(this, "onItemChildClick" + e.Position, ToastLength.Long).Show();
};
_recyclerView.SetAdapter(sectionAdapter);
}
/// <summary>
/// Inserts a list of period ids into the database.
/// </summary>
/// <param name="context">Web service request context.</param>
/// <param name="periodIds">Id for periods to insert.</param>
/// <param name="periodUsage">How user selected periods should be used.</param>
public static void AddUserSelectedPeriods(WebServiceContext context,
List <Int32> periodIds,
UserSelectedPeriodUsage periodUsage)
{
DataColumn column;
DataRow row;
DataTable periodTable;
if (periodIds.IsNotEmpty())
{
// Delete all periods that belong to this request from the "temporary" tables.
// This is done to avoid problem with restarts of the webservice.
DeleteUserSelectedPeriods(context);
// Insert the new list of periods.
periodTable = new DataTable(UserSelectedPeriodData.TABLE_NAME);
column = new DataColumn(UserSelectedPeriodData.REQUEST_ID, typeof(Int32));
periodTable.Columns.Add(column);
column = new DataColumn(UserSelectedPeriodData.PERIOD_ID, typeof(Int32));
periodTable.Columns.Add(column);
column = new DataColumn(UserSelectedPeriodData.PERIOD_USAGE, typeof(String));
periodTable.Columns.Add(column);
foreach (Int32 periodId in periodIds)
{
row = periodTable.NewRow();
row[0] = context.RequestId;
row[1] = periodId;
row[2] = periodUsage.ToString();
periodTable.Rows.Add(row);
}
DataServer.AddUserSelectedPeriods(context, periodTable);
}
}
/// <summary>
/// Get all factor update modes.
/// </summary>
/// <param name="context">Web service request context.</param>
/// <returns>Factor update modes.</returns>
public static List <WebFactorUpdateMode> GetFactorUpdateModes(WebServiceContext context)
{
List <WebFactorUpdateMode> factorUpdateModes;
String cacheKey;
// Get cached information.
cacheKey = "AllFactorUpdateModes";
factorUpdateModes = (List <WebFactorUpdateMode>)context.GetCachedObject(cacheKey);
if (factorUpdateModes.IsNull())
{
// Get information from database.
factorUpdateModes = new List <WebFactorUpdateMode>();
using (DataReader dataReader = DataServer.GetFactorUpdateModes(context))
{
while (dataReader.Read())
{
factorUpdateModes.Add(new WebFactorUpdateMode(dataReader));
}
// Add information to cache.
context.AddCachedObject(cacheKey, factorUpdateModes, DateTime.Now + new TimeSpan(12, 0, 0), CacheItemPriority.AboveNormal);
}
}
return(factorUpdateModes);
}
/// <summary>
/// Inserts a list of reference ids into the database.
/// </summary>
/// <param name="context">Web service request context.</param>
/// <param name="referenceIds">Id for references to insert.</param>
/// <param name="referenceUsage">How user selected references should be used.</param>
public static void AddUserSelectedReferences(WebServiceContext context,
List <Int32> referenceIds,
UserSelectedReferenceUsage referenceUsage)
{
DataColumn column;
DataRow row;
DataTable referenceTable;
if (referenceIds.IsNotEmpty())
{
// Delete all references that belong to this request from the "temporary" tables.
// This is done to avoid problem with restarts of the webservice.
DeleteUserSelectedReferences(context);
// Insert the new list of references.
referenceTable = new DataTable(UserSelectedReferenceData.TABLE_NAME);
column = new DataColumn(UserSelectedReferenceData.REQUEST_ID, typeof(Int32));
referenceTable.Columns.Add(column);
column = new DataColumn(UserSelectedReferenceData.REFERENCE_ID, typeof(Int32));
referenceTable.Columns.Add(column);
column = new DataColumn(UserSelectedReferenceData.REFERENCE_USAGE, typeof(String));
referenceTable.Columns.Add(column);
foreach (Int32 referenceId in referenceIds)
{
row = referenceTable.NewRow();
row[0] = context.RequestId;
row[1] = referenceId;
row[2] = referenceUsage.ToString();
referenceTable.Rows.Add(row);
}
DataServer.AddUserSelectedReferences(context, referenceTable);
}
}
/// <summary>
/// Get information about species facts.
/// </summary>
/// <param name="context">Web service request context.</param>
/// <param name="speciesFacts">Species facts to get information about.</param>
/// <returns>Species facts information.</returns>
public static List <WebSpeciesFact> GetSpeciesFactsByIdentifier(WebServiceContext context,
List <WebSpeciesFact> speciesFacts)
{
List <WebSpeciesFact> outSpeciesFacts;
// Check arguments.
speciesFacts.CheckNotEmpty("speciesFacts");
if (speciesFacts.Count > MAX_SPECIES_FACTS)
{
// Exceeding max numbers of species facts that
// can be retrieved in one request.
throw new ArgumentException("Max " + MAX_SPECIES_FACTS + " species facts can be retrieved in one call.");
}
// Get data from database.
try
{
AddUserSelectedSpeciesFacts(context, speciesFacts, UserSelectedSpeciesFactUsage.Output);
outSpeciesFacts = new List <WebSpeciesFact>();
using (DataReader dataReader = DataServer.GetSpeciesFactsByIdentifier(context))
{
while (dataReader.Read())
{
outSpeciesFacts.Add(new WebSpeciesFact(dataReader));
}
}
}
finally
{
DeleteUserSelectedSpeciesFacts(context);
}
return(outSpeciesFacts);
}
/// <summary>
/// Inserts a list of host ids into the database.
/// </summary>
/// <param name="context">Web service request context.</param>
/// <param name="hostIds">Id for hosts to insert.</param>
/// <param name="hostUsage">How user selected hosts should be used.</param>
public static void AddUserSelectedHosts(WebServiceContext context,
List <Int32> hostIds,
UserSelectedTaxonUsage hostUsage)
{
DataColumn column;
DataRow row;
DataTable hostTable;
if (hostIds.IsNotEmpty())
{
// Delete all hosts that belong to this request from the "temporary" tables.
// This is done to avoid problem with restarts of the webservice.
DeleteUserSelectedHosts(context);
// Insert the new list of hosts.
hostTable = new DataTable(UserSelectedHostData.TABLE_NAME);
column = new DataColumn(UserSelectedHostData.REQUEST_ID, typeof(Int32));
hostTable.Columns.Add(column);
column = new DataColumn(UserSelectedHostData.HOST_ID, typeof(Int32));
hostTable.Columns.Add(column);
column = new DataColumn(UserSelectedHostData.HOST_USAGE, typeof(String));
hostTable.Columns.Add(column);
foreach (Int32 hostId in hostIds)
{
row = hostTable.NewRow();
row[0] = context.RequestId;
row[1] = hostId;
row[2] = hostUsage.ToString();
hostTable.Rows.Add(row);
}
DataServer.AddUserSelectedHosts(context, hostTable);
}
}
/// <summary>
/// Inserts a list of speciesFact ids into the database.
/// </summary>
/// <param name="context">Web service request context.</param>
/// <param name="speciesFactIds">Id for speciesFacts to insert.</param>
/// <param name="speciesFactUsage">How user selected speciesFacts should be used.</param>
public static void AddUserSelectedSpeciesFacts(WebServiceContext context,
List <Int32> speciesFactIds,
UserSelectedSpeciesFactUsage speciesFactUsage)
{
DataRow row;
DataTable speciesFactTable;
if (speciesFactIds.IsNotEmpty())
{
// Delete all speciesFact ids that belong to this request from the "temporary" tables.
// This is done to avoid problem with restarts of the webservice.
DeleteUserSelectedSpeciesFacts(context);
// Insert the new list of speciesFacts.
speciesFactTable = GetUserSelectedSpeciesFactTable();
foreach (Int32 speciesFactId in speciesFactIds)
{
row = speciesFactTable.NewRow();
row[0] = context.RequestId;
row[1] = speciesFactId;
row[2] = speciesFactUsage.ToString();
speciesFactTable.Rows.Add(row);
}
DataServer.AddUserSelectedSpeciesFacts(context, speciesFactTable);
}
}
/// <summary>
/// Get all periods.
/// </summary>
/// <param name="context">Web service request context.</param>
/// <returns>Periods.</returns>
public static List <WebPeriod> GetPeriods(WebServiceContext context)
{
List <WebPeriod> periods;
String cacheKey;
// Get cached information.
cacheKey = "AllPeriods";
periods = (List <WebPeriod>)context.GetCachedObject(cacheKey);
if (periods.IsNull())
{
// Get information from database.
periods = new List <WebPeriod>();
using (DataReader dataReader = DataServer.GetPeriods(context))
{
while (dataReader.Read())
{
periods.Add(new WebPeriod(dataReader));
}
// Add information to cache.
context.AddCachedObject(cacheKey, periods, DateTime.Now + new TimeSpan(12, 0, 0), CacheItemPriority.AboveNormal);
}
}
return(periods);
}
/// <summary>
/// Get information about database update.
/// </summary>
/// <param name="context">Web service request context.</param>
/// <returns>Database update information.</returns>
public static WebDatabaseUpdate GetDatabaseUpdate(WebServiceContext context)
{
String cacheKey;
WebDatabaseUpdate databaseUpdate;
// Get cached information.
cacheKey = "DatabaseUpdate";
databaseUpdate = (WebDatabaseUpdate)context.GetCachedObject(cacheKey);
if (databaseUpdate.IsNull())
{
// Get information from database.
using (DataReader dataReader = DataServer.GetDatabaseUpdate(context))
{
if (dataReader.Read())
{
databaseUpdate = new WebDatabaseUpdate(dataReader);
// Add information to cache.
context.AddCachedObject(cacheKey, databaseUpdate, DateTime.Now + new TimeSpan(12, 0, 0), CacheItemPriority.BelowNormal);
}
else
{
throw new ApplicationException("Could not get database update information!");
}
}
}
return(databaseUpdate);
}
/// <summary>
/// Get information about different endangered lists.
/// </summary>
/// <param name="context">Web service request context.</param>
/// <returns>Information about endangered lists.</returns>
public static List <WebEndangeredList> GetEndangeredLists(WebServiceContext context)
{
List <WebEndangeredList> endangeredLists;
String cacheKey;
// Get cached information.
cacheKey = "AllEndangeredLists";
endangeredLists = (List <WebEndangeredList>)context.GetCachedObject(cacheKey);
if (endangeredLists.IsNull())
{
// Get information from database.
endangeredLists = new List <WebEndangeredList>();
using (DataReader dataReader = DataServer.GetEndangeredLists(context))
{
while (dataReader.Read())
{
endangeredLists.Add(new WebEndangeredList(dataReader));
}
}
// Add information to cache.
context.AddCachedObject(cacheKey, endangeredLists, DateTime.Now + new TimeSpan(24, 0, 0), CacheItemPriority.BelowNormal);
}
return(endangeredLists);
}
/// <summary>
/// Inserts a list of individual category ids into the database.
/// </summary>
/// <param name="context">Web service request context.</param>
/// <param name="individualCategoryIds">Id for individual categories to insert.</param>
/// <param name="individualCategoryUsage">How user selected individual categories should be used.</param>
public static void AddUserSelectedIndividualCategories(WebServiceContext context,
List <Int32> individualCategoryIds,
UserSelectedIndividualCategoryUsage individualCategoryUsage)
{
DataColumn column;
DataRow row;
DataTable individualCategoryTable;
if (individualCategoryIds.IsNotEmpty())
{
// Delete all individual categories that belong to this request from the "temporary" tables.
// This is done to avoid problem with restarts of the webservice.
DeleteUserSelectedIndividualCategories(context);
// Insert the new list of individual categories.
individualCategoryTable = new DataTable(UserSelectedIndividualCategoryData.TABLE_NAME);
column = new DataColumn(UserSelectedIndividualCategoryData.REQUEST_ID, typeof(Int32));
individualCategoryTable.Columns.Add(column);
column = new DataColumn(UserSelectedIndividualCategoryData.INDIVIDUAL_CATEGORY_ID, typeof(Int32));
individualCategoryTable.Columns.Add(column);
column = new DataColumn(UserSelectedIndividualCategoryData.INDIVIDUAL_CATEGORY_USAGE, typeof(String));
individualCategoryTable.Columns.Add(column);
foreach (Int32 individualCategoryId in individualCategoryIds)
{
row = individualCategoryTable.NewRow();
row[0] = context.RequestId;
row[1] = individualCategoryId;
row[2] = individualCategoryUsage.ToString();
individualCategoryTable.Rows.Add(row);
}
DataServer.AddUserSelectedIndividualCategories(context, individualCategoryTable);
}
}
public void Save(string connectionString)
{
try
{
IDataServer ds = new DataServer(connectionString);
ds.RunTransaction(delegate
{
ds.CreateAdapter<ColumnDomainTableAdapter>().Update(this.ColumnDomain);
ds.CreateAdapter<DomainTableTableAdapter>().Update(this.DomainTable);
ds.CreateAdapter<FontTableAdapter>().Update(this.Font);
ds.CreateAdapter<IdGroupTableAdapter>().Update(this.IdGroup);
ds.CreateAdapter<EntityTypeTableAdapter>().Update(this.EntityType);
ds.CreateAdapter<ThemeTableAdapter>().Update(this.Theme);
ds.CreateAdapter<LayerTableAdapter>().Update(this.Layer);
ds.CreateAdapter<SysIdTableAdapter>().Update(this.SysId);
ds.CreateAdapter<PropertyTableAdapter>().Update(this.Property);
ds.CreateAdapter<SchemaTableAdapter>().Update(this.Schema);
ds.CreateAdapter<TemplateTableAdapter>().Update(this.Template);
ds.CreateAdapter<SchemaTemplateTableAdapter>().Update(this.SchemaTemplate);
ds.CreateAdapter<EntityTypeSchemaTableAdapter>().Update(this.EntityTypeSchema);
ds.CreateAdapter<ZoneTableAdapter>().Update(this.Zone);
});
}
finally
{
AcceptChanges();
}
}
/// <summary>
/// Get all Individual Categories.
/// </summary>
/// <param name="context">Web service request context.</param>
/// <returns>Individual Categories.</returns>
public static List <WebIndividualCategory> GetIndividualCategories(WebServiceContext context)
{
List <WebIndividualCategory> individualcategories;
String cacheKey;
// Get cached information.
cacheKey = "AllIndividualCategories";
individualcategories = (List <WebIndividualCategory>)context.GetCachedObject(cacheKey);
if (individualcategories.IsNull())
{
// Get information from database.
individualcategories = new List <WebIndividualCategory>();
using (DataReader dataReader = DataServer.GetIndividualCategories(context))
{
while (dataReader.Read())
{
individualcategories.Add(new WebIndividualCategory(dataReader));
}
// Add information to cache.
context.AddCachedObject(cacheKey, individualcategories, DateTime.Now + new TimeSpan(12, 0, 0), CacheItemPriority.AboveNormal);
}
}
return(individualcategories);
}
/// <summary>
/// Get information about databases.
/// </summary>
/// <param name="context">Web service request context.</param>
/// <returns>Information about databases.</returns>
public static List <WebDatabase> GetDatabases(WebServiceContext context)
{
List <WebDatabase> databases;
String cacheKey;
// Get cached information.
cacheKey = "AllDatabases";
databases = (List <WebDatabase>)context.GetCachedObject(cacheKey);
if (databases.IsNull())
{
// Get information from database.
databases = new List <WebDatabase>();
using (DataReader dataReader = DataServer.GetDatabases(context))
{
while (dataReader.Read())
{
databases.Add(new WebDatabase(dataReader));
}
// Add information to cache.
context.AddCachedObject(cacheKey, databases, DateTime.Now + new TimeSpan(24, 0, 0), CacheItemPriority.BelowNormal);
}
}
return(databases);
}
/// <summary>
/// Replaces the content of this database with the content of some other container.
/// </summary>
/// <param name="ed">The environment data to copy into this database</param>
public void Replace(EnvironmentData ed)
{
TableFactory tf = new TableFactory();
DataServer ds = new DataServer(m_ConnectionString);
try
{
// Disable all foreign key constraints
tf.EnableForeignKeys(ds, false);
ds.RunTransaction(delegate
{
// Get rid of everything in this database.
tf.RemoveAll(ds);
// Add the entire content of the specified container
tf.Import(ds, ed.Data);
});
Data.Clear();
Data.Load(m_ConnectionString);
}
finally
{
// Restore all foreign key constraints
tf.EnableForeignKeys(ds, true);
}
}
/// <summary>
/// Rollback a transaction.
/// </summary>
public void RollbackTransaction()
{
DataServer transactionDatabase = null;
lock (_transactionInformation)
{
// Undo transaction.
if (_transactionInformation.ContainsKey(TransactionKey))
{
transactionDatabase = (DataServer)(_transactionInformation[TransactionKey]);
_transactionInformation.Remove(TransactionKey);
}
if (_transactionInformation.ContainsKey(TransactionIdKey))
{
_transactionInformation.Remove(TransactionIdKey);
}
}
if (transactionDatabase.IsNotNull())
{
lock (transactionDatabase)
{
transactionDatabase.RollbackTransaction();
transactionDatabase.Disconnect();
}
}
}
public void GetDouble()
{
Double value, defaultValue;
defaultValue = 53545.543;
try
{
SpeciesFactManager.AddUserSelectedSpeciesFacts(GetContext(), SpeciesFactManagerTest.GetSomeSpeciesFactIds(GetContext()), UserSelectedSpeciesFactUsage.Output);
using (DataReader dataReader = DataServer.GetSpeciesFactsById(GetContext()))
{
while (dataReader.Read())
{
if (dataReader.IsDBNull(SpeciesFactData.FIELD_VALUE_1))
{
value = dataReader.GetDouble(SpeciesFactData.FIELD_VALUE_1, defaultValue);
Assert.AreEqual(value, defaultValue);
}
else
{
value = dataReader.GetDouble(SpeciesFactData.FIELD_VALUE_1);
Assert.AreNotEqual(value, defaultValue);
value = dataReader.GetDouble(SpeciesFactData.FIELD_VALUE_1, defaultValue);
Assert.AreNotEqual(value, defaultValue);
}
}
}
}
finally
{
SpeciesFactManager.DeleteUserSelectedSpeciesFacts(GetContext());
}
}
public void Constructor()
{
using (DataReader dataReader = DataServer.GetDatabaseUpdate(GetContext()))
{
Assert.IsNotNull(dataReader);
}
}
/// <summary>
/// Commit a transaction.
/// </summary>
public void CommitTransaction()
{
DataServer transactionDatabase = null;
lock (_transactionInformation)
{
if (HasTransaction())
{
transactionDatabase = (DataServer)(_transactionInformation[TransactionKey]);
_transactionInformation.Remove(TransactionKey);
if (_transactionInformation.ContainsKey(TransactionIdKey))
{
_transactionInformation.Remove(TransactionIdKey);
}
}
else
{
throw new ApplicationException("No transaction to commit!");
}
}
if (transactionDatabase.IsNotNull())
{
lock (transactionDatabase)
{
transactionDatabase.CommitTransaction();
transactionDatabase.Disconnect();
}
}
}
public void GetBoolean()
{
Boolean value, defaultValue;
defaultValue = true;
using (DataReader dataReader = DataServer.GetFactors(GetContext()))
{
Assert.IsTrue(dataReader.Read());
value = dataReader.GetBoolean(FactorData.IS_PUBLIC, defaultValue);
Assert.IsTrue(value);
Assert.IsTrue(dataReader.Read());
if (dataReader.IsDBNull(FactorData.IS_PERIODIC))
{
value = dataReader.GetBoolean(FactorData.IS_PERIODIC, defaultValue);
Assert.AreEqual(value, defaultValue);
}
else
{
value = dataReader.GetBoolean(FactorData.IS_PERIODIC);
Assert.AreNotEqual(value, defaultValue);
value = dataReader.GetBoolean(FactorData.IS_PERIODIC, defaultValue);
Assert.AreNotEqual(value, defaultValue);
}
}
}
public void GetDateTime()
{
DateTime value, defaultValue;
defaultValue = DateTime.Now;
using (DataReader dataReader = DataServer.GetDatabaseUpdate(GetContext()))
{
Assert.IsTrue(dataReader.Read());
value = dataReader.GetDateTime(DatabaseData.UPDATE_START);
Assert.AreNotEqual(defaultValue, value);
if (dataReader.IsDBNull(DatabaseData.UPDATE_END))
{
value = dataReader.GetDateTime(DatabaseData.UPDATE_END, defaultValue);
Assert.AreEqual(value, defaultValue);
}
else
{
value = dataReader.GetDateTime(DatabaseData.UPDATE_END);
Assert.AreNotEqual(value, defaultValue);
value = dataReader.GetDateTime(DatabaseData.UPDATE_END, defaultValue);
Assert.AreNotEqual(value, defaultValue);
}
}
}
public void NextResultSet()
{
using (DataReader dataReader = DataServer.GetDatabases(GetContext()))
{
Assert.IsFalse(dataReader.NextResultSet());
}
}
public RerunForm(SessionSettings settings, DataServer server)
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
//
// TODO: Add any constructor code after InitializeComponent call
//
DataTable experimentTable;
Identifiable [] experiments;
MySessionSettings = settings;
MyDataServer = server;
StatusLabel.Text = "Ready";
//Initialize experiment list with all experiments.
experimentTable = MyDataServer.GetResultExperiments();
experiments = new Identifiable[experimentTable.Rows.Count];
for (int i = 0; i < experimentTable.Rows.Count; i++)
{
experiments[i] = new Identifiable(Convert.ToInt32(experimentTable.Rows[i]["experiment_id"]),
experimentTable.Rows[i]["identifier"].ToString());
}
ExperimentList.TheCheckedListBox.Items.AddRange(experiments);
ExperimentList.SetAllCheckStatus(true);
}
protected internal virtual void Initialize(XmlSerializer serializer, Service service)
{
if (serializer == null)
{
throw new ArgumentNullException("serializer");
}
else if (service == null)
{
throw new ArgumentNullException("service");
}
else if (service.ScpdUrl == null)
{
throw new ArgumentException("The service has no ScpdUrl.", "service");
}
else if (service.ControlUrl == null)
{
throw new ArgumentException("The service has no ControlUrl.", "service");
}
else if (service.EventUrl == null)
{
throw new ArgumentException("The service has no EventUrl.", "service");
}
scpd_server = new DataServer(serializer.GetBytes(this), @"text/xml; charset=""utf-8""", service.ScpdUrl);
control_server = new ControlServer(actions, service.Type.ToString(), service.ControlUrl, serializer);
event_server = new EventServer(state_variables.Values, service.EventUrl);
foreach (var state_variable in state_variables.Values)
{
state_variable.Initialize(this);
}
}
public void Constructor()
{
DateTime changedFrom, changedTo;
Int32 maxProtectionLevel;
WebSpeciesObservationChange change;
// Get some changes.
changedFrom = new DateTime(2011, 2, 1, 0, 0, 0);
changedTo = new DateTime(2011, 2, 2, 0, 0, 0);
maxProtectionLevel = 2;
using (DataReader dataReader = DataServer.GetSpeciesObservationChange(GetContext(), maxProtectionLevel, changedFrom, changedTo))
{
change = new WebSpeciesObservationChange(dataReader);
}
Assert.IsNotNull(change);
Assert.IsTrue(change.NewSpeciesObservations.IsNotEmpty());
Assert.IsTrue(change.NewSpeciesObservationIds.IsEmpty());
// Get many changes.
changedFrom = new DateTime(2011, 2, 1, 0, 0, 0);
changedTo = new DateTime(2011, 2, 3, 0, 0, 0);
maxProtectionLevel = 2;
using (DataReader dataReader = DataServer.GetSpeciesObservationChange(GetContext(), maxProtectionLevel, changedFrom, changedTo))
{
change = new WebSpeciesObservationChange(dataReader);
}
Assert.IsNotNull(change);
Assert.IsTrue(change.NewSpeciesObservations.IsEmpty());
Assert.IsTrue(change.NewSpeciesObservationIds.IsNotEmpty());
}
public void RemoteClient(DataServer ds)
{
if (dataServers != null && dataServers.Contains(ds))
{
dataServers.Remove(ds);
}
}
/// <summary>
/// Get all categories of species fact qualty.
/// </summary>
/// <param name="context">Web service request context.</param>
/// <returns>Species fact qualities.</returns>
public static List <WebSpeciesFactQuality> GetSpeciesFactQualities(WebServiceContext context)
{
List <WebSpeciesFactQuality> speciesFactQuality;
String cacheKey;
// Get cached information.
cacheKey = "AllSpeciesFactQualities";
speciesFactQuality = (List <WebSpeciesFactQuality>)context.GetCachedObject(cacheKey);
if (speciesFactQuality.IsNull())
{
// Get information from database.
speciesFactQuality = new List <WebSpeciesFactQuality>();
using (DataReader dataReader = DataServer.GetSpeciesFactQualities(context))
{
while (dataReader.Read())
{
speciesFactQuality.Add(new WebSpeciesFactQuality(dataReader));
}
// Add information to cache.
context.AddCachedObject(cacheKey, speciesFactQuality, DateTime.Now + new TimeSpan(12, 0, 0), CacheItemPriority.AboveNormal);
}
}
return(speciesFactQuality);
}
public void GetBooleanColumnNameError()
{
using (DataReader dataReader = DataServer.GetFactors(GetContext()))
{
Assert.IsTrue(dataReader.Read());
dataReader.GetBoolean("No column name");
}
}
public void GetStringColumnNameError()
{
using (DataReader dataReader = DataServer.GetDatabases(GetContext()))
{
Assert.IsTrue(dataReader.Read());
dataReader.GetString("No column name");
}
}
public Form1()
{
InitializeComponent();
log = LogManager.GetLogger("Device");
data = new DataServer(textBox2.Text);
textBox1.Text += "TestHarness started";
log.Info("Testharness started");
}
public void AddClient(DataServer ds)
{
if (dataServers == null)
{
dataServers = new List <DataServer>();
}
dataServers.Add(ds);
}
public void Load(string connectionString)
{
IDataServer ds = new DataServer(connectionString);
ds.RunTransaction(delegate
{
ColumnDomainTableAdapter columnDomain = ds.CreateAdapter<ColumnDomainTableAdapter>();
DomainTableTableAdapter domainTable = ds.CreateAdapter<DomainTableTableAdapter>();
FontTableAdapter font = ds.CreateAdapter<FontTableAdapter>();
IdGroupTableAdapter idGroup = ds.CreateAdapter<IdGroupTableAdapter>();
EntityTypeTableAdapter entity = ds.CreateAdapter<EntityTypeTableAdapter>();
ThemeTableAdapter theme = ds.CreateAdapter<ThemeTableAdapter>();
LayerTableAdapter layer = ds.CreateAdapter<LayerTableAdapter>();
SysIdTableAdapter sysid = ds.CreateAdapter<SysIdTableAdapter>();
PropertyTableAdapter prop = ds.CreateAdapter<PropertyTableAdapter>();
SchemaTableAdapter schema = ds.CreateAdapter<SchemaTableAdapter>();
TemplateTableAdapter template = ds.CreateAdapter<TemplateTableAdapter>();
SchemaTemplateTableAdapter schemaTemplate = ds.CreateAdapter<SchemaTemplateTableAdapter>();
EntityTypeSchemaTableAdapter entityTypeSchema = ds.CreateAdapter<EntityTypeSchemaTableAdapter>();
ZoneTableAdapter zone = ds.CreateAdapter<ZoneTableAdapter>();
columnDomain.Fill(this.ColumnDomain);
domainTable.Fill(this.DomainTable);
font.Fill(this.Font);
idGroup.Fill(this.IdGroup);
entity.Fill(this.EntityType);
theme.Fill(this.Theme);
layer.Fill(this.Layer);
sysid.Fill(this.SysId);
prop.Fill(this.Property);
schema.Fill(this.Schema);
template.Fill(this.Template);
schemaTemplate.Fill(this.SchemaTemplate);
entityTypeSchema.Fill(this.EntityTypeSchema);
zone.Fill(this.Zone);
});
}
static void Main(string[] args)
{
Console.Write("Choose port:");
int port = Convert.ToInt32(Console.ReadLine());
string dataServerUrl = "tcp://" + Util.getLocalIP() + ":" + port + "/" + Constants.REMOTE_DATASERV_OBJ_NAME;
IMaster masterServer = null;
TcpChannel channelServ = new TcpChannel(port);
ChannelServices.RegisterChannel(channelServ, true);
masterServer = (IMaster)Activator.GetObject(typeof(IMaster), Constants.MASTER_SERVER_URL);
DataServer dataServer = new DataServer(masterServer, dataServerUrl);
RemotingServices.Marshal(
dataServer,
Constants.REMOTE_DATASERV_OBJ_NAME,
typeof(IDataServer) );
dataServer.setId(masterServer.registerDataServer(dataServerUrl));
dataServer.startImAlives();
Console.WriteLine("Press <enter> to exit");
Console.ReadLine();
}
/// <summary>
/// Loads the domain table from the database
/// </summary>
/// <param name="connectionString">The connection string for the database holding domain data.</param>
/// <returns>A index of the domain table, keyed by the short value</returns>
Dictionary<string, string> LoadDomainTable(string connectionString)
{
IDataServer ds = new DataServer(connectionString);
Dictionary<string, string> result = new Dictionary<string, string>();
DataTable table = ds.ExecuteSelect("SELECT [ShortValue], [LongValue] FROM " + TableName);
foreach (DataRow row in table.Select())
{
string key = row[0].ToString();
string val = row[1].ToString();
result.Add(key, val);
}
return result;
}
