public static Task <string[]> GetDescriptions(DatabaseConnectionProperties dbconnprop, string table_name)
{
return(Task.Run(new Func <string[]>(() =>
{
List <string> descriptions = new List <string>();
using (MySqlConnection sqlconn = new MySqlConnection(dbconnprop.ConnectionString))
{
sqlconn.Open();
using (MySqlCommand cmdName = new MySqlCommand("select description from `" + table_name + "`", sqlconn))
using (MySqlDataReader reader = cmdName.ExecuteReader())
while (reader.Read())
{
if (reader.IsDBNull(0))
{
descriptions.Add(null);
}
else
{
descriptions.Add(reader.GetString(0));
}
}
}
return descriptions.ToArray();
})));
}
public MainForm()
{
InitializeComponent();
dbconnprop = new DatabaseConnectionProperties("mccsrv0", null, "accesscontrol", "MaMCaq9Jb3fvVr7d");
try
{
if (File.Exists("appstate.bin"))
{
FileStream fstream = new FileStream("appstate.bin", FileMode.Open);
BinaryFormatter bFormatter = new BinaryFormatter();
dbconnprop = (DatabaseConnectionProperties)bFormatter.Deserialize(fstream);
expander_monitors = (List <ExpanderMonitor>)bFormatter.Deserialize(fstream);
panel_monitors = (List <PanelMonitor>)bFormatter.Deserialize(fstream);
control_groups = (List <AccessControlGroup>)bFormatter.Deserialize(fstream);
fstream.Close();
}
}
catch (Exception ex)
{
ErrorLogManager.AppendLog("Failed To Read Configuration From File", true);
try{ File.Delete("appstate.bin"); }
catch (Exception ex2) { ErrorLogManager.AppendLog("Failed To Delete Configuration File", true); }
}
AccessControlLogManager.DatabaseConnectionProperties = dbconnprop;
ErrorLogManager.AppendLog("Application Initialized", true);
}
private void button1_Click(object sender, EventArgs e)
{
//accept button
dbconnprop = DatabaseConnectionProperties.FromArray(GetTextBoxStrings());
DialogResult = DialogResult.OK;
}
public static void Perform(string[] args, DatabaseConnectionProperties databaseProperties, SyrinxProperties syrinxProperties, Assembly assembly,
Action <IServiceCollection> serviceHandler = null)
{
var parser = new Parser(settings => settings.CaseInsensitiveEnumValues = true);
parser.ParseArguments <CamundaDeploymentToolOptions>(args)
.WithParsed(options =>
{
var serviceCollection = CreateServices(databaseProperties, syrinxProperties, assembly);
serviceHandler?.Invoke(serviceCollection);
using var scope = serviceCollection.BuildServiceProvider(false).CreateScope();
var service = scope.ServiceProvider.GetRequiredService <ICamundaDeploymentService>();
switch (options.Action)
{
case MigrationAction.Upgrade:
service.Upgrade();
break;
case MigrationAction.Rollback:
service.DowngradeToPrevious();
break;
case MigrationAction.Downgrade:
service.Downgrade();
break;
default:
throw CommonExceptions.CamundaCouldNotBeDeployed();
}
})
.WithNotParsed(_ => throw CommonExceptions.CamundaCouldNotBeDeployed());
}
private async Task addFeatureLayer()
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
ArcGIS.Core.Data.DatabaseConnectionProperties connectionProperties = new DatabaseConnectionProperties(EnterpriseDatabaseType.PostgreSQL)
{
AuthenticationMode = AuthenticationMode.DBMS,
Instance = @"127.0.0.1",
Database = "geomapmaker",
User = "******",
Password = "******",
//Version = "dbo.DEFAULT"
};
using (Geodatabase geodatabase = new Geodatabase(connectionProperties))
{
// Use the geodatabase
CIMSqlQueryDataConnection sqldc = new CIMSqlQueryDataConnection()
{
WorkspaceConnectionString = geodatabase.GetConnectionString(),
GeometryType = esriGeometryType.esriGeometryPoint,
OIDFields = "OBJECTID",
Srid = "4326",
SqlQuery = "select * from public.features where user_id = " + DataHelper.userID + " and ST_GeometryType(geom)='ST_Point'",
Dataset = "features"
};
featureLayer = (FeatureLayer)LayerFactory.Instance.CreateLayer(sqldc, MapView.Active.Map, layerName: DataHelper.userName + "'s points");
}
});
}
public AltMonitor(ExpanderMonitor expmon, List <PanelMonitor> pnlmons, DatabaseConnectionProperties dbconnprop, string table_name)
{
this.expmon = expmon;
this.pnlmons = pnlmons;
this.dbconnprop = dbconnprop;
this.table_name = table_name;
}
private Task addFeatureLayer()
{
Debug.WriteLine("addFeatureLayer enter");
return(ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
ArcGIS.Core.Data.DatabaseConnectionProperties connectionProperties = new DatabaseConnectionProperties(EnterpriseDatabaseType.PostgreSQL)
{
AuthenticationMode = AuthenticationMode.DBMS,
Instance = @"127.0.0.1",
Database = "geomapmaker2",
User = "******",
Password = "******",
//Version = "dbo.DEFAULT"
};
using (Geodatabase geodatabase = new Geodatabase(connectionProperties))
{
using (FeatureClass featureClass = geodatabase.OpenDataset <FeatureClass>("geomapmaker2.geomapmaker2.line_features"))
{
var layerParamsQueryDefn = new FeatureLayerCreationParams(featureClass)
{
IsVisible = true,
DefinitionFilter = new CIMDefinitionFilter()
{
Name = "User",
DefinitionExpression = "user_id = " + DataHelper.userID
}
};
featureLayer = LayerFactory.Instance.CreateLayer <FeatureLayer>(layerParamsQueryDefn, MapView.Active.Map);
}
}
}));
}
private async Task openDatabase(JObject props)
{
await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
//Get Layers that are NOT Group layers and are unchecked
//var layers = MapView.Active.Map.Layers.ToList();
//MapView.Active.Map.RemoveLayers(layers);
// Opening a Non-Versioned SQL Server instance.
ArcGIS.Core.Data.DatabaseConnectionProperties connectionProperties = new DatabaseConnectionProperties(EnterpriseDatabaseType.PostgreSQL)
{
AuthenticationMode = AuthenticationMode.DBMS,
// Where testMachine is the machine where the instance is running and testInstance is the name of the SqlServer instance.
//Instance = @"127.0.0.1",
Instance = props["instance"].ToString(),
// Provided that a database called LocalGovernment has been created on the testInstance and geodatabase has been enabled on the database.
//Database = "geomapmaker",
Database = props["database"].ToString(),
// Provided that a login called gdb has been created and corresponding schema has been created with the required permissions.
//User = "******",
User = props["user"].ToString(),
//Password = "******",
Password = props["password"].ToString(),
//Version = "dbo.DEFAULT"
};
using (Geodatabase geodatabase = new Geodatabase(connectionProperties))
{
DataHelper.connectionString = geodatabase.GetConnectionString();
Debug.WriteLine("DataHelper.connectionString set to " + DataHelper.connectionString);
// Use the geodatabase
/*
* CIMSqlQueryDataConnection sqldc = new CIMSqlQueryDataConnection()
* {
* WorkspaceConnectionString = geodatabase.GetConnectionString(),
* GeometryType = esriGeometryType.esriGeometryPoint,
* OIDFields = "OBJECTID",
* Srid = "4326",
* //SqlQuery = "select * from geomapmaker2.features where id = " + DataHelper.userID + " and ST_GeometryType(geom)='ST_Point'",
* Dataset = "somepoints"
* };
* FeatureLayer flyr = (FeatureLayer)LayerFactory.Instance.CreateLayer(sqldc, MapView.Active.Map, layerName: DataHelper.userName + "'s points");
*/
//FeatureClass fC = geodatabase.OpenDataset<FeatureClass>("somepoints");
//FeatureLayer flyr = LayerFactory.Instance.CreateFeatureLayer(fC, MapView.Active.Map);
var featureClasses = geodatabase.GetDefinitions <FeatureClassDefinition>();
foreach (FeatureClassDefinition fCD in featureClasses)
{
FeatureClass fC = geodatabase.OpenDataset <FeatureClass>(fCD.GetName());
FeatureLayer flyr = LayerFactory.Instance.CreateFeatureLayer(fC, MapView.Active.Map);
}
}
});
}
private void databaseToolStripMenuItem_Click(object sender, EventArgs e)
{
DatabaseConnectionForm dbconfm = new DatabaseConnectionForm(dbconnprop);
dbconfm.ShowDialog(this);
dbconnprop = dbconfm.DBConnProp;
dbconfm.Dispose();
}
public ImportForm(DatabaseConnectionProperties dbconnprop)
{
InitializeComponent();
this.dbconnprop = dbconnprop;
RefreshTableNames();
}
Dictionary <string, bool> GetFeatureClassExistsMap(ProSymbolUtilities.SupportedStandardsType standard,
Geodatabase gdb = null)
{
EGDBPrefixName = string.Empty;
_egdbConnectionString = string.Empty;
if (gdb != null)
{
GeodatabaseType gdbType = gdb.GetGeodatabaseType();
if (gdbType == GeodatabaseType.RemoteDatabase)
{
// if an SDE/EGDB, then feature class name format will differ:
// Database + User + Feature Class Name
DatabaseConnectionProperties dbcps = gdb.GetConnector() as DatabaseConnectionProperties;
if (dbcps != null)
{
EGDBPrefixName = dbcps.Database + "." + dbcps.User + ".";
// Also save this connection string to identify this EGDB later
_egdbConnectionString = ((Datastore)gdb).GetConnectionString();
}
}
}
Dictionary <string, bool> featureClassExists = new Dictionary <string, bool>();
List <SymbolSetMapping> symbolSetMapping = null;
switch (standard)
{
case ProSymbolUtilities.SupportedStandardsType.app6b: symbolSetMapping = _symbolSetMappingAPP6B; break;
case ProSymbolUtilities.SupportedStandardsType.app6d: symbolSetMapping = _symbolSetMappingAPP6D; break;
case ProSymbolUtilities.SupportedStandardsType.mil2525b: symbolSetMapping = _symbolSetMapping2525B; break;
case ProSymbolUtilities.SupportedStandardsType.mil2525c: symbolSetMapping = _symbolSetMapping2525C; break;
default:
symbolSetMapping = _symbolSetMapping2525D;
break;
}
foreach (SymbolSetMapping mapping in symbolSetMapping)
{
string featureClassName = EGDBPrefixName + mapping.FeatureClassName;
if (!featureClassExists.ContainsKey(featureClassName))
{
featureClassExists.Add(featureClassName, false);
}
}
return(featureClassExists);
}
public AccessPropertiesEditor(DatabaseConnectionProperties dbconnprop, string table_name, UInt64 uid)
{
InitializeComponent();
this.dbconnprop = dbconnprop;
this.table_name = table_name;
this.uid = uid;
this.Text = table_name + " - " + uid;
}
public DatabaseConnectionForm(DatabaseConnectionProperties dbprop)
{
InitializeComponent();
this.dbprop = new DatabaseConnectionProperties(dbprop);
textBox1.Text = dbprop.Hostname;
textBox2.Text = dbprop.UID;
textBox3.Text = dbprop.Password;
}
public GroupListForm(List <ExpanderMonitor> expmons, List <PanelMonitor> pnlmons, List <AccessControlGroup> acctlgp, DatabaseConnectionProperties dbconnprop)
{
InitializeComponent();
this.expmons = expmons;
this.pnlmons = pnlmons;
this.acctlgp = acctlgp;
this.dbconnprop = dbconnprop;
listBox1.DataSource = acctlgp;
}
/// <summary>
/// Illustrates deleting rows from a table in an enterprise geodatabase.
/// </summary>
/// <returns></returns>
private static async Task EnterpriseGeodabaseWorkFlow()
{
// Opening a Non-Versioned SQL Server instance.
DatabaseConnectionProperties connectionProperties = new DatabaseConnectionProperties(EnterpriseDatabaseType.SQLServer)
{
AuthenticationMode = AuthenticationMode.DBMS,
// Where testMachine is the machine where the instance is running and testInstance is the name of the SqlServer instance.
Instance = @"testMachine\testInstance",
// Provided that a database called LocalGovernment has been created on the testInstance and geodatabase has been enabled on the database.
Database = "LocalGovernment",
// Provided that a login called gdb has been created and corresponding schema has been created with the required permissions.
User = "******",
Password = "******",
Version = "dbo.DEFAULT"
};
using (Geodatabase geodatabase = new Geodatabase((connectionProperties)))
{
using (Table enterpriseTable = geodatabase.OpenDataset <Table>("LocalGovernment.GDB.piCIPCost"))
{
EditOperation editOperation = new EditOperation();
editOperation.Callback(context =>
{
QueryFilter openCutFilter = new QueryFilter {
WhereClause = "ACTION = 'Open Cut'"
};
using (RowCursor rowCursor = enterpriseTable.Search(openCutFilter, false))
{
while (rowCursor.MoveNext())
{
using (Row row = rowCursor.Current)
{
// In order to update the Map and/or the attribute table. Has to be called before the delete
context.Invalidate(row);
row.Delete();
}
}
}
}, enterpriseTable);
bool editResult = editOperation.Execute();
// If the table is non-versioned this is a no-op. If it is versioned, we need the Save to be done for the edits to be persisted.
bool saveResult = await Project.Current.SaveEditsAsync();
}
}
}
public static Task <bool> ContainsUID(DatabaseConnectionProperties dbconnprop, string table_name, UInt64 uid)
{
return(Task.Run(() =>
{
using (MySqlConnection sqlconn = new MySqlConnection(dbconnprop.ConnectionString))
{
sqlconn.Open();
return ContainsUID(sqlconn, table_name, uid);
}
}));
}
public static Task DeleteRow(DatabaseConnectionProperties dbconnprop, string table_name, UInt64 uid)
{
return(Task.Run(() =>
{
using (MySqlConnection sqlconn = new MySqlConnection(dbconnprop.ConnectionString))
{
sqlconn.Open();
using (MySqlCommand sqlcmd = new MySqlCommand("delete from `" + table_name + "` where uid=" + uid, sqlconn))
sqlcmd.ExecuteNonQuery();
}
}));
}
/// <summary>
/// Since the LocalGovernment Geodatabase does not have AttributedRelationshipClasses, the following method illustrates the behavior
/// if such a dataset existed.
/// </summary>
public void MainMethodCode()
{
// Opening a Non-Versioned SQL Server instance.
DatabaseConnectionProperties connectionProperties = new DatabaseConnectionProperties(EnterpriseDatabaseType.SQLServer)
{
AuthenticationMode = AuthenticationMode.DBMS,
// Where testMachine is the machine where the instance is running and testInstance is the name of the SqlServer instance.
Instance = @"testMachine\testInstance",
// Provided that a database called LocalGovernment has been created on the testInstance and geodatabase has been enabled on the database.
Database = "LocalGovernment",
// Provided that a login called gdb has been created and corresponding schema has been created with the required permissions.
User = "******",
Password = "******",
Version = "dbo.DEFAULT"
};
using (Geodatabase geodatabase = new Geodatabase(connectionProperties))
using (AttributedRelationshipClass attributedRelationshipClass = geodatabase.OpenDataset <AttributedRelationshipClass>("LocalGovernment.GDB.ParcelToBuilding"))
using (FeatureClass parcelFeatureClass = geodatabase.OpenDataset <FeatureClass>("LocalGovernment.GDB.Parcel"))
using (FeatureClass buildingFeatureClass = geodatabase.OpenDataset <FeatureClass>("LocalGovernment.GDB.Building"))
{
QueryFilter parcelQueryFilter = new QueryFilter {
WhereClause = "APN = 1234 OR APN = 5678"
};
QueryFilter buildingQueryFilter = new QueryFilter {
WhereClause = "BUILDID = 4321 OR BUILDID = 8765"
};
Selection parcelsSelection = parcelFeatureClass.Select(parcelQueryFilter, SelectionType.ObjectID, SelectionOption.Normal);
Selection buildingSelection = buildingFeatureClass.Select(buildingQueryFilter, SelectionType.ObjectID, SelectionOption.Normal);
IReadOnlyList <AttributedRelationship> relationshipsForOrigin = null;
IReadOnlyList <AttributedRelationship> relationshipsForDestination = null;
try
{
relationshipsForOrigin = attributedRelationshipClass.GetRelationshipsForOriginRows(parcelsSelection.GetObjectIDs());
relationshipsForDestination = attributedRelationshipClass.GetRelationshipsForDestinationRows(buildingSelection.GetObjectIDs());
}
finally
{
Dispose(relationshipsForOrigin);
Dispose(relationshipsForDestination);
}
}
}
private static IServiceCollection CreateServices(DatabaseConnectionProperties databaseProperties, SyrinxProperties syrinxProperties, Assembly assembly) => new ServiceCollection()
.AddSingleton <ILoggerStore>(factory => new LoggerStore(databaseProperties.LogStoreConnectionString, Scope))
.AddSingleton(factory => new CamundaDeploymentParameters
{
Assembly = assembly
})
.AddScoped <IOperationService>(factory =>
{
var loggerStore = factory.GetService <ILoggerStore>();
var dataStoreConnectionString = databaseProperties.DataStoreConnectionString;
return(new OperationService(loggerStore, dataStoreConnectionString, Scope));
})
.AddScoped <ISyrinxCamundaClientService>(factory => new SyrinxCamundaClientService(syrinxProperties))
.AddScoped <ICamundaDeploymentService, CamundaDeploymentService>();
public static Task RenameTable(DatabaseConnectionProperties dbconnprop, string original_table_name, string new_table_name)
{
return(Task.Run(() =>
{
using (MySqlConnection sqlconn = new MySqlConnection(dbconnprop.ConnectionString))
{
string cmdstr = "RENAME TABLE `accesscontrol`.`" + original_table_name + "` TO `" + new_table_name + "`;";
sqlconn.Open();
using (MySqlCommand sqlcmd = new MySqlCommand(cmdstr, sqlconn))
sqlcmd.ExecuteNonQuery();
}
}));
}
public static Task CreateTable(DatabaseConnectionProperties dbconnprop, string table_name)
{
return(Task.Run(() =>
{
using (MySqlConnection sqlconn = new MySqlConnection(dbconnprop.ConnectionString))
{
string cmdstr = "CREATE TABLE `accesscontrol`.`" + table_name + "` (`uid` BIGINT NOT NULL COMMENT '',`description` VARCHAR(255) NULL COMMENT '',`notes` BLOB NULL COMMENT '',`data` BLOB NULL COMMENT '',PRIMARY KEY (`uid`) COMMENT '');";
sqlconn.Open();
using (MySqlCommand sqlcmd = new MySqlCommand(cmdstr, sqlconn))
sqlcmd.ExecuteNonQuery();
}
}));
}
public static Task SetDescription(DatabaseConnectionProperties dbconnprop, string table_name, UInt64 uid, string description)
{
return(Task.Run(() =>
{
using (MySqlConnection sqlconn = new MySqlConnection(dbconnprop.ConnectionString))
{
sqlconn.Open();
using (MySqlCommand cmdName = new MySqlCommand("update `" + table_name + "` set description = @description where uid=" + uid, sqlconn))
{
cmdName.Parameters.AddWithValue("@description", description);
cmdName.ExecuteNonQuery();
}
}
}));
}
public static Task SetAccessProperties(DatabaseConnectionProperties dbconnprop, string table_name, UInt64 uid, AccessProperties accessprops)
{
return(Task.Run(() =>
{
using (MySqlConnection sqlconn = new MySqlConnection(dbconnprop.ConnectionString))
{
sqlconn.Open();
using (MySqlCommand cmdName = new MySqlCommand("update `" + table_name + "` set data = @data where uid=" + uid, sqlconn))
{
cmdName.Parameters.AddWithValue("@data", accessprops == null ? null : Utilities.ConvertObjectToByteArray <AccessProperties>(accessprops));
cmdName.ExecuteNonQuery();
}
}
}));
}
public static Task DeleteTable(DatabaseConnectionProperties dbconnprop, string table_name)
{
return(Task.Run(() =>
{
using (MySqlConnection sqlconn = new MySqlConnection(dbconnprop.ConnectionString))
{
sqlconn.Open();
using (MySqlCommand sqlcmd = new MySqlCommand("drop table `" + table_name + "`", sqlconn))
sqlcmd.ExecuteNonQuery();
sqlconn.Close();
}
}));
}
private async void databaseToolStripMenuItem_Click(object sender, EventArgs e)
{
dbconnprop = DatabaseConnectionProperties.FromArray(GetTextBoxStrings());
MCv2Persistance.Instance.Config.DatabaseConfiguration.DatabaseConnectionProperties = dbconnprop;
List <string> files_to_import = new List <string>();
using (OpenFileDialog ofd = new OpenFileDialog())
{
ofd.Multiselect = true;
ofd.Filter = "Supported Extentions (*.db2bak)|*.db2bak";
ofd.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
ofd.FileName = "";
if (ofd.ShowDialog() == DialogResult.OK)
{
files_to_import.AddRange(ofd.FileNames);
}
}
if (files_to_import.Count() == 0)
{
return;
}
ProgressDialog pgd = new ProgressDialog("Restoring Database");
pgd.Show();
pgd.SetMarqueeStyle();
foreach (var file in files_to_import)
{
pgd.LabelText = "Processing " + file;
try
{
await DBBackupAndRestore.Restore(file, DatabaseConnectionProperties.FromArray(GetTextBoxStrings()));
}
catch (Exception ex)
{
MessageBox.Show("An error occured while restoring from " + file + ".");
}
}
pgd.Dispose();
}
public DatabaseConnectionEditor(DatabaseConnectionProperties dbconnprop, bool IsCancellable)
{
this.dbconnprop = dbconnprop;
InitializeComponent();
if (File.Exists("auto_backup.db2bak"))
{
restoreDBFromAutosaveToolStripMenuItem.Enabled = true;
}
if (!IsCancellable)
{
button2.Enabled = false;
}
tbs = new TextBox[] { textBox1, textBox4, textBox2, textBox3 };
text_change_handler = new EventHandler(HandleTextChanged);
tb_background_checker = new Task(async() =>
{
tb_bg_check_active = true;
await TestTextBoxValues();
DateTime last_check = DateTime.Now;
while (tb_bg_check_active)
{
while (DateTime.Now - last_check < tb_bg_check_ival)
{
if (!tb_bg_check_active)
{
return;
}
else
{
await Task.Delay(250);
}
}
await TestTextBoxValues();
last_check = DateTime.Now;
}
});
}
public void MainMethodCode()
{
// Opening a Non-Versioned SQL Server instance.
DatabaseConnectionProperties connectionProperties = new DatabaseConnectionProperties(EnterpriseDatabaseType.SQLServer)
{
AuthenticationMode = AuthenticationMode.DBMS,
// Where testMachine is the machine where the instance is running and testInstance is the name of the SqlServer instance.
Instance = @"testMachine\testInstance",
// Provided that a database called LocalGovernment has been created on the testInstance and geodatabase has been enabled on the database.
Database = "LocalGovernment",
// Provided that a login called gdb has been created and corresponding schema has been created with the required permissions.
User = "******",
Password = "******",
Version = "dbo.DEFAULT"
};
using (Geodatabase geodatabase = new Geodatabase(connectionProperties))
using (FeatureClassDefinition featureClassDefinition = geodatabase.GetDefinition <FeatureClassDefinition>("LocalGovernment.GDB.ServiceRequestComment"))
{
int rankIndex = featureClassDefinition.FindField("RANK");
Field field = featureClassDefinition.GetFields()[rankIndex];
Domain domain = field.GetDomain();
RangeDomain rangeDomain = (RangeDomain)domain;
// Will be "ServiceRequestRanking".
string name = rangeDomain.GetName();
// Will be FieldType.Integer.
FieldType fieldType = rangeDomain.GetFieldType();
// Will be "A factor assigned to unassigned service requests indicating importance".
string description = rangeDomain.GetDescription();
// Will be 1.
int minValue = Convert.ToInt32(rangeDomain.GetMinValue());
// Will be 5.
int maxValue = Convert.ToInt32(rangeDomain.GetMaxValue());
}
}
public static Task <UInt64[]> GetUIDs(DatabaseConnectionProperties dbconnprop, string table_name)
{
return(Task.Run(new Func <UInt64[]>(() =>
{
List <UInt64> uids = new List <UInt64>();
using (MySqlConnection sqlconn = new MySqlConnection(dbconnprop.ConnectionString))
{
sqlconn.Open();
using (MySqlCommand cmdName = new MySqlCommand("select uid from `" + table_name + "`", sqlconn))
using (MySqlDataReader reader = cmdName.ExecuteReader())
while (reader.Read())
{
uids.Add(reader.GetUInt64(0));
}
}
return uids.ToArray();
})));
}
public static Task AddRow(DatabaseConnectionProperties dbconnprop, string table_name, UInt64 uid, string description, string[] notes, AccessProperties accessprop)
{
return(Task.Run(() =>
{
using (MySqlConnection sqlconn = new MySqlConnection(dbconnprop.ConnectionString))
{
sqlconn.Open();
using (MySqlCommand sqlcmd = new MySqlCommand("insert into `" + table_name + "` (uid, description, notes, data) values (@uid, @description, @notes, @data)", sqlconn))
{
sqlcmd.Parameters.AddWithValue("@uid", uid);
sqlcmd.Parameters.AddWithValue("@description", description);
sqlcmd.Parameters.AddWithValue("@notes", notes == null ? null : Utilities.ConvertObjectToByteArray <string[]>(notes));
sqlcmd.Parameters.AddWithValue("@data", accessprop == null ? null : Utilities.ConvertObjectToByteArray <AccessProperties>(accessprop));
sqlcmd.ExecuteNonQuery();
}
}
}));
}
private static void Main(string[] args)
{
if (args.Length < 3)
{
Console.Error.WriteLine("Error: No se han especificado parámetros.");
Console.Error.WriteLine("El formato es: MuestraAtributosBBDDGeometriasArchivoBinD.exe [tabla de códigos] [base de datos.mdb] [archivo bin a enumerar]");
Console.Error.WriteLine("Ejemplo: MuestraAtributosBBDDGeometriasArchivoBinD.exe prueba.Tab.xml prueba.mdb prueba.bind");
return;
}
try
{
var tabla = DigiTab.Load(args[0]);
var parámetrosbbdd = new DatabaseConnectionProperties
{
ConnectionString = $"Provider=Microsoft.ACE.OLEDB.16.0;Data Source={args[1]};Persist Security Info=False",
DataModel = "CATDBS"
};
using (var archivoEntrada = new BinDouble(args[2], parámetrosbbdd, tabla))
{
foreach (var entidad in archivoEntrada)
{
var atributos = archivoEntrada.GetDatabaseAttributes(entidad);
foreach (var código in entidad.Codes)
{
foreach (var clave in atributos[código.Name])
{
Console.WriteLine($"{clave.Key}: {clave.Value}");
}
}
Console.Write("-----------------");
}
}
}
catch (Exception excepción)
{
Console.Error.WriteLine("Se localizó el siguiente error:");
Console.Error.WriteLine(excepción.Message);
}
}
