/// <summary>
/// Executes a non-blocking request.
/// </summary>
protected override bool ExecuteNonQueryImpl(string rawQuery)
{
try
{
Log.Debug("mssqlObject", rawQuery);
int res = Connection.ExecuteNonQuery(rawQuery);
if (res == 0)
{
Log.Error("mssqlObject", "Execution error : " + rawQuery);
return(false);
}
return(true);
}
catch (Exception e)
{
Log.Error("mssqlObject", "Execution error : " + rawQuery + e);
}
return(false);
}
private void btDel_Click(object sender, System.EventArgs e)
{
int n = listBox1.SelectedIndex;
if (n >= 0)
{
string sep1 = _connection.NameDelimiterBegin;
string sep2 = _connection.NameDelimiterEnd;
TableIndex tbl = listBox1.Items[n] as TableIndex;
string sSQL = "DROP INDEX ";
if (!_connection.IsOdbc || !chkPK.Checked)
{
sSQL += sep1 + tbl.IndexName + sep2;
sSQL += " ON " + sep1;
sSQL += lblTable.Text;
sSQL += sep2;
}
else
{
sSQL = " ALTER Table ";
sSQL += sep1 + lblTable.Text + sep2;
sSQL += " DROP PRIMARY KEY";
}
try
{
_connection.ExecuteNonQuery(sSQL);
listBox1.Items.RemoveAt(n);
btDel.Enabled = (listBox1.Items.Count > 0);
bChanged = true;
}
catch (Exception er)
{
MessageBox.Show(this, er.Message, this.Text, System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Stop);
}
}
}
/// <summary>
/// 대상 업무 영역에 데이터 업로더를 리스트 단위로 추가한다. (이미 있다면 무시하고, 삭제된 유저가 있다면 프로시저 내부에서 상태만 변경한다.)
/// </summary>
public bool InsertFormTableSectionGroupMembers(Guid formId, Guid formSectionId, IEnumerable <string> userIds, DateTimeOffset date)
{
string procCommandName = "up_FormTableSectionGroup_InsertList";
try
{
using (var spParamUserIDList = new DataTable()) // dbo.type_UserIDList
{
var command = Connection.GetStoredProcCommand(procCommandName);
spParamUserIDList.Columns.Add("UserID", typeof(string));
foreach (var userId in userIds)
{
var tempObj = new object[]
{
userId
};
spParamUserIDList.Rows.Add(tempObj);
}
var param = command.Parameters.AddWithValue("UserIDs", spParamUserIDList);
param.SqlDbType = SqlDbType.Structured;
Connection.AddInParameter(command, "FormID", DbType.Guid, formId);
Connection.AddInParameter(command, "FormSectionID", DbType.Guid, formSectionId);
Connection.AddInParameter(command, "CreatedDate", DbType.DateTimeOffset, date);
return((int)Connection.ExecuteNonQuery(command) > 0);
}
}
catch (Exception ex)
{
throw new DataException($"프로시져 실행 중 예기치 못한 에러가 발생했습니다.\r\n 프로시저: \"{procCommandName}\"", ex);
}
}
/// <summary>
/// 대시보드 테이블 html 양식을 업데이트한다.
/// </summary>
public bool UpdateFormHtmlTemplate(FormHtmlTemplate template)
{
template.ThrowIfNull(nameof(template));
string procCommandName = "up_FormHtmlTemplate_Update";
try
{
var command = Connection.GetStoredProcCommand(procCommandName);
Connection.AddInParameter(command, "FormID", DbType.Guid, template.FormId);
Connection.AddInParameter(command, "HtmlTemplateID", DbType.Guid, template.HtmlTemplateId);
Connection.AddInParameter(command, "Description", DbType.String, template.Description);
Connection.AddInParameter(command, "ScriptContent", DbType.String, template.ScriptContent);
Connection.AddInParameter(command, "HtmlContent", DbType.String, template.HtmlContent);
Connection.AddInParameter(command, "StyleContent", DbType.String, template.StyleContent);
Connection.AddInParameter(command, "UpdatedDate", DbType.DateTimeOffset, template.UpdatedDate);
return((int)Connection.ExecuteNonQuery(command) > 0);
}
catch (Exception ex)
{
throw new DataException($"프로시져 실행 중 예기치 못한 에러가 발생했습니다.\r\n 프로시저: \"{procCommandName}\"", ex);
}
}
public override Lfx.Types.OperationResult Guardar()
{
qGen.IStatement Comando;
if (this.Existe == false)
{
Comando = new qGen.Insert(this.TablaDatos);
if (this.Id > 0)
{
Comando.ColumnValues.AddWithValue(this.CampoId, this.Id);
}
Comando.ColumnValues.AddWithValue("fecha", new qGen.SqlExpression("NOW()"));
}
else
{
Comando = new qGen.Update(this.TablaDatos);
Comando.WhereClause = new qGen.Where(this.CampoId, this.Id);
}
Comando.ColumnValues.AddWithValue("imagen", this.Imagen);
Connection.ExecuteNonQuery(Comando);
return(base.Guardar());
}
/// <summary>
/// 메뉴 아이템을 업데이트한다.
/// </summary>
public bool UpdateMenu(MenuItem menu)
{
menu.ThrowIfNull(nameof(menu));
string procCommandName = "up_Menu_Update";
try
{
var command = Connection.GetStoredProcCommand(procCommandName);
Connection.AddInParameter(command, "MenuID", DbType.Guid, menu.MenuId);
Connection.AddInParameter(command, "Name", DbType.String, menu.Name);
Connection.AddInParameter(command, "GroupName", DbType.String, menu.GroupName);
Connection.AddInParameter(command, "IconName", DbType.String, menu.IconName);
Connection.AddInParameter(command, "SortOrder", DbType.Int32, menu.SortOrder);
Connection.AddInParameter(command, "IsVisible", DbType.Boolean, menu.IsVisible);
Connection.AddInParameter(command, "UpdatedDate", DbType.DateTimeOffset, menu.UpdatedDate);
return((int)Connection.ExecuteNonQuery(command) > 0);
}
catch (Exception ex)
{
throw new DataException($"프로시져 실행 중 예기치 못한 에러가 발생했습니다.\r\n 프로시저: \"{procCommandName}\"", ex);
}
}
/// <summary>
/// Creates the table.
/// </summary>
public override void Create()
{
var commandBuilder = new StringBuilder();
commandBuilder.AppendLine($"CREATE TABLE IF NOT EXISTS {Metadata.Table} (");
var fieldDefinitions = new List <string>();
fieldDefinitions.Add("Id INTEGER PRIMARY KEY AUTO_INCREMENT");
fieldDefinitions.Add("Deleted TINYINT(1) NOT NULL");
fieldDefinitions.Add("Version int NOT NULL");
foreach (var field in Metadata.Fields.Where(x => x.Name != "Id" && x.Name != "Deleted" && x.Name != "Version"))
{
fieldDefinitions.Add($"{field.Name} {GetDataTypeMapping(field)}{GetDecimalPrecisionCommand(field)} {GetMandatoryCommand(field.Mandatory)} {GetUniqueCommand(field.Unique)}");
}
commandBuilder.AppendLine(string.Join(",", fieldDefinitions));
commandBuilder.AppendLine(");");
var query = new Query(commandBuilder.ToString(), Type);
Connection.ExecuteNonQuery(query);
}
/// <summary>
/// 메뉴에 대상 대시보드 테이블을 매핑시킨다. (기존 매핑된 테이블을 지우고 새로 매핑함)
/// </summary>
public bool UpdateMenuFormMap(Guid menuId, Guid[] formIds, DateTimeOffset createdDate)
{
menuId.ThrowIfEmpty(nameof(menuId));
string procCommandName = "up_MenuFormMap_Update";
try
{
using (var spParamFormMap = new DataTable())
{
var command = Connection.GetStoredProcCommand(procCommandName);
Connection.AddInParameter(command, "MenuID", DbType.Guid, menuId);
Connection.AddInParameter(command, "CreatedDate", DbType.DateTimeOffset, createdDate);
// @FormMap
{
spParamFormMap.Columns.Add("FormID", typeof(Guid));
spParamFormMap.Columns.Add("SortOrder", typeof(int));
for (int i = 0; i < formIds.Length; i++)
{
spParamFormMap.Rows.Add(formIds[i], i + 1);
}
var param = command.Parameters.AddWithValue("FormMap", spParamFormMap);
param.SqlDbType = SqlDbType.Structured;
}
return((int)Connection.ExecuteNonQuery(command) > 0);
}
}
catch (Exception ex)
{
throw new DataException($"프로시져 실행 중 예기치 못한 에러가 발생했습니다.\r\n 프로시저: \"{procCommandName}\"", ex);
}
}
public bool Update(Car entity)
{
Connection c = GetConnection();
Command cmd = new Command("dbo.UpdateVoiture", true);
cmd.AddParameter("IdCar", entity.IdCar);
cmd.AddParameter("ChassisNumber", entity.ChassisNumber);
cmd.AddParameter("IdModel", entity.IdModel);
cmd.AddParameter("Version", entity.Version);
cmd.AddParameter("Year", entity.Year);
cmd.AddParameter("ChassisType", entity.ChassisType);
cmd.AddParameter("Condition", entity.Condition);
cmd.AddParameter("Mileage", entity.Mileage);
cmd.AddParameter("Power", entity.Power);
cmd.AddParameter("Cylinder", entity.Cylinder);
cmd.AddParameter("Location", entity.Location);
cmd.AddParameter("Fuel", entity.Fuel);
cmd.AddParameter("Transmition", entity.Transmition);
cmd.AddParameter("Color", entity.Color);
cmd.AddParameter("MetalPainting", Convert.ToByte(entity.MetalPainting));
cmd.AddParameter("ServiceBook", Convert.ToByte(entity.ServiceBook));
cmd.AddParameter("LeftHand", Convert.ToByte(entity.LeftHand));
return(1 == c.ExecuteNonQuery(cmd));
}
/// <summary>
/// Deletes a table from the database.
/// </summary>
/// <param name="tableName">Name of the table to be deleted.</param>
public void DeleteTable(string tableName)
{
string sql;
// If there is only 1 checkpointID in the database, we can just drop the table.
// If this table doesn't have a CheckpointID column, we also just drop the table.
// Otherwise, we delete all data corresponding to the "Current" checkpoint ID.
bool tableHasCheckpointID = Connection.GetColumns(tableName).Any(c => c.Item1 == "CheckpointID");
if (checkpointIDs.Count <= 1 || !tableHasCheckpointID)
{
sql = $"DROP TABLE \"{tableName}\"";
}
else
{
int currentCheckpointID = checkpointIDs["Current"].ID;
sql = $"DELETE FROM \"{tableName}\" WHERE CheckpointID = {currentCheckpointID}";
}
Connection.ExecuteNonQuery(sql);
lock (lockObject)
if (!TablesModified.Contains(tableName))
{
TablesModified.Add(tableName);
}
}
public DBErrors Create(Contact entity)
{
Command cmd = new Command("CreateContact", true);
cmd.AddParameter("nationalNumber", entity.NationalNumber);
cmd.AddParameter("lastName", entity.LastName);
cmd.AddParameter("firstName", entity.FirstName);
cmd.AddParameter("birthdate", entity.BirthDate);
cmd.AddParameter("adCity", entity.AdCity);
cmd.AddParameter("adPostalCode", entity.AdPostalCode);
cmd.AddParameter("adStreet", entity.AdStreet);
cmd.AddParameter("adNumber", entity.AdNumber);
cmd.AddParameter("adBox", entity.AdBox);
cmd.AddParameter("mobilePhone", entity.MobilePhone);
cmd.AddParameter("gender", entity.Gender);
cmd.AddParameter("email", entity.Email);
cmd.AddParameter("personalNote", entity.PersonalNote);
try
{
_connection.ExecuteNonQuery(cmd);
}
catch (SqlException ex)
{
if (ex.Message.Contains("UK_Users_NationalNumber"))
{
return(DBErrors.NationalNumber_Exist);
}
if (ex.Message.Contains("NULL"))
{
return(DBErrors.NullExeption);
}
else
{
return(DBErrors.NotKnowedError);
}
}
return(DBErrors.Success);
}
/// <summary>
/// Executes the SQL statement using <see cref="Connection"/>, and returns the number of rows affected.
/// </summary>
/// <param name="timeout">The time in seconds to wait for the SQL statement to execute.</param>
/// <param name="sqlFormat">Format string for the SQL statement to be executed.</param>
/// <param name="parameters">The parameter values to be used to fill in <see cref="IDbDataParameter"/> parameters.</param>
/// <returns>The number of rows affected.</returns>
public int ExecuteNonQuery(int timeout, string sqlFormat, params object?[] parameters)
{
string sql = GenericParameterizedQueryString(sqlFormat, parameters);
return(Connection.ExecuteNonQuery(timeout, sql, ResolveParameters(parameters)));
}
/// <summary>
/// Checks if an ID is already in use. Prompts to overwrite if needed.
/// Deletes original row with given id if user agrees.
/// </summary>
/// <param name="type">creation type</param>
/// <param name="id">creation id</param>
/// <returns>True if user gave permission to insert</returns>
public static bool CheckDuplicateHandleOverride(Export.C type, int id)
{
// Get primary keys to base update queries on
var fieldsToCheck = GetRelevantTablesAndIds(type, id);
if (fieldsToCheck == null)
{
return(true); // Irrelevant to this type or error
}
// Look for duplicates
bool alreadyExists = false;
try
{
// Query every relevant table to see if ID already exists
foreach (var kvp in fieldsToCheck)
{
if (kvp.Key.Contains("%t"))
{
continue; // I'm not gonna even
}
var result = Connection.ExecuteScalar($"SELECT COUNT(*) AS matches FROM {kvp.Key} WHERE {kvp.Value} = {id};");
if ((dynamic)result > 0)
{
alreadyExists = true;
break;
}
}
}
catch (Exception ex)
{
Logger.Log("Database Error: There was an error looking for duplicates. Creation will not export.", Logger.Status.Error, true);
Logger.Log(ex.Message);
return(false); // Failed, cancel insert
}
// Ask if user wants to overwrite
if (alreadyExists)
{
var dr = MessageBox.Show($"WARNING: {type} with ID {id} already exists.{Environment.NewLine}Would you like to replace it?",
"Already Exists", MessageBoxButton.YesNoCancel, MessageBoxImage.Warning, MessageBoxResult.No);
if (dr == MessageBoxResult.Yes)
{
// Delete from database
foreach (var kvp in fieldsToCheck)
{
// Handle quest customs
if (type == Export.C.Quest)
{
// Handle %t tablenames
if (kvp.Key.Contains("%t"))
{
string[] starterEnderTypes = new string[]
{
"creature",
"gameobject",
};
string overrideTableName = "";
foreach (string replacement in starterEnderTypes)
{
if (kvp.Key.Contains("queststarter"))
{
overrideTableName = kvp.Key.Replace("%t", replacement);
Connection.ExecuteNonQuery($"DELETE FROM {overrideTableName} WHERE {kvp.Value} = {id};");
}
else if (kvp.Key.Contains("questender"))
{
overrideTableName = kvp.Key.Replace("%t", replacement);
Connection.ExecuteNonQuery($"DELETE FROM {overrideTableName} WHERE {kvp.Value} = {id};");
}
else
{
Logger.Log("Profile Error: QuestGiver customs with wildcard only accept tablenames containing 'queststarter' and 'questender'." + Environment.NewLine +
"This is because customs have no other way to identify that the custom is in relation to queststarter/ender." + Environment.NewLine +
"If this causes issues, it's preferable to just use 'creature_questender' instead of '%t_questender' and starter.",
Logger.Status.Error, true);
}
}
}
}
else if (type == Export.C.Creature)
{
if (Profile.Active.IsKeyDefined(Export.C.Creature, "SpellCreatureID"))
{
var d = new ExpKvp("SpellCreatureID", null, Export.C.Creature);
Connection.ExecuteNonQuery($"DELETE FROM {d.SqlTableName} WHERE {d.SqlKey} = {id};");
}
if (Profile.Active.IsKeyDefined(Export.C.Creature, "ResistanceCreatureId"))
{
var d = new ExpKvp("ResistanceCreatureId", null, Export.C.Creature);
Connection.ExecuteNonQuery($"DELETE FROM {d.SqlTableName} WHERE {d.SqlKey} = {id};");
}
if (Profile.Active.IsKeyDefined(Export.C.Creature, "InhabitCreatureID"))
{
var d = new ExpKvp("InhabitCreatureID", null, Export.C.Creature);
Connection.ExecuteNonQuery($"DELETE FROM {d.SqlTableName} WHERE {d.SqlKey} = {id};");
}
}
// No special, just delete.
if (!kvp.Key.Contains("%t"))
{
Connection.ExecuteNonQuery($"DELETE FROM {kvp.Key} WHERE {kvp.Value} = {id};");
}
}
return(true); // Duplicate, deleted & permission to insert
}
else
{
return(false); // Duplicate found, user does not wish to override
}
}
else
{
return(true); // Not duplicate, proceed as normal.
}
}
public void insert()
{
Connection.ExecuteNonQuery("sp_addNgansach @kinhphi , @nam , @matinh", new object[] { kinhphi, namcap, matinh });
}
internal void WipeOutEnums(Connection c)
{
foreach (Type t in _enumTableMaps.Keys)
c.ExecuteNonQuery("DELETE FROM " + _enumTableMaps[t]);
}
public bool Run()
{
bool result = true;
PerformStepInvoke("Iniciando base de dados local ...");
string line = null;
double progress = 0;
double progressValue = 0;
try
{
//-------------------------------------------------------------------------
// Ajustar a conexão no Unimake.Data.Generic de acordo com os dados informados na tela anterior
//-------------------------------------------------------------------------
Unimake.Data.Generic.Configuration.DataGenericSettings.Settings.ConnectionStrings.Add(new Unimake.Data.Generic.Configuration.ConnectionString
{
DatabaseType = CurrentConfig.ServerConfig.DatabaseType,
ConnectionString = CurrentConfig.ServerConfig.ToConnectionString(),
Name = "Setup"
});
Unimake.Data.Generic.Configuration.DataGenericSettings.ChangeConnection("Setup");
if(!CreateDatabase())
{
MessageBox.ShowError("Não foi possível criar a base de dados. O instalador não irá continuar.");
return false;
}
Connection = DbContext.CreateConnection();
Connection.BeginTransaction();
#region Endereços ...
InitInstallEnd(Connection);
#endregion
result = RunPreInstall(Connection);
if(result)
{
#region create table
string[] linesCreate = null;
string[] linesInsert = null;
using(StreamReader sr = CreateFile.OpenText())
{
line = sr.ReadToEnd();
linesCreate = line.Split(new string[] { ";" + "\r\n", ";" + "\n" }, StringSplitOptions.RemoveEmptyEntries);
}
line = "";
#endregion
#region insert
using(StreamReader sr = InsertFile.OpenText())
{
line = sr.ReadToEnd();
linesInsert = line.Split(new string[] { ";" + "\r\n", ";" + "\n" }, StringSplitOptions.RemoveEmptyEntries);
}
line = "";
#endregion
//-------------------------------------------------------------------------
// Ao final, some todas as ações extras que deverão ser realizadas
// Tipo de Usuário : +2 (Administrador e Operador)
//-------------------------------------------------------------------------
progress = 100 / (double)(linesCreate.Length + linesInsert.Length + 3);
#region execute
foreach(string l in linesCreate)
{
line = l;
//-------------------------------------------------------------------------
// Algumas tabelas são ignoradas por serem pesadas na importação
// Então já foram previamente criadas
//-------------------------------------------------------------------------
if(IgnoreTables(line)) continue;
PerformStepInvoke("Executando comando: " + line);
Connection.ExecuteNonQuery(line);
ProgressInvoke((int)(progressValue += progress));
Application.DoEvents();
}
foreach(string l in linesInsert)
{
line = l;
PerformStepInvoke("Executando comando: " + line);
Connection.ExecuteNonQuery(line);
ProgressInvoke((int)(progressValue += progress));
Application.DoEvents();
}
#endregion
result = RunPostInstall(Connection);
Settings.Tables = Tables.GetTables(Connection);
#region Outras ações
ProgressInvoke((int)(progressValue += progress));
#endregion
if(result)
{
Connection.CommitTransaction();
MessageBox.Show("A instalação da base de dados foi concluída com sucesso. Clique em \"Avançar >\" para continuar a instalação do OpenPOS.");
ProgressInvoke(100);
}
}
}
catch(Exception ex)
{
if(Connection != null)
{
if(Connection.Transaction != null && Connection.Transaction.State == TransactionState.Begin)
Connection.RollbackTransaction();
}
MessageBox.ShowError(ex, (String.IsNullOrEmpty(line) ? ex.Message : line) + Environment.NewLine);
result = false;
}
finally
{
if(Connection != null)
Connection.Close();
}
return result;
}
private List<string> _UpdateStructure(List<ExtractedTableMap> tables, List<Trigger> triggers, List<Generator> generators, List<IdentityField> identities, List<View> views, List<StoredProcedure> procedures,Connection conn)
{
List<string> ret = new List<string>();
List<string> alteredTables = new List<string>();
foreach (ExtractedTableMap map in tables)
{
foreach (ExtractedTableMap cmap in _tables)
{
if (map.TableName == cmap.TableName)
{
if (map.ToString() != cmap.ToString())
alteredTables.Add(map.TableName);
else if (!(conn is MsSqlConnection ? Utility.StringsEqualIgnoreWhitespaceBracketsCase(map.ToComputedString(), cmap.ToComputedString()) : Utility.StringsEqualIgnoreWhitespace(map.ToComputedString(), cmap.ToComputedString())))
alteredTables.Add(map.TableName);
break;
}
}
}
List<Trigger> dropTriggers = new List<Trigger>();
List<Trigger> createTriggers = new List<Trigger>();
List<StoredProcedure> createProcedures = new List<StoredProcedure>();
List<StoredProcedure> dropProcedures = new List<StoredProcedure>();
List<StoredProcedure> updateProcedures = new List<StoredProcedure>();
List<Generator> createGenerators = new List<Generator>();
List<string> constraintDrops = new List<string>();
List<string> constraintCreations = new List<string>();
List<PrimaryKey> primaryKeyDrops = new List<PrimaryKey>();
List<PrimaryKey> primaryKeyCreations = new List<PrimaryKey>();
List<ForeignKey> foreignKeyDrops = new List<ForeignKey>();
List<ForeignKey> foreignKeyCreations = new List<ForeignKey>();
List<IdentityField> createIdentities = new List<IdentityField>();
List<IdentityField> setIdentities = new List<IdentityField>();
Dictionary<string, List<Index>> dropIndexes = new Dictionary<string, List<Index>>();
Dictionary<string, List<Index>> createIndexes = new Dictionary<string, List<Index>>();
List<View> createViews = new List<View>();
List<View> dropViews = new List<View>();
_ExtractPrimaryKeyCreationsDrops(tables, out primaryKeyDrops, out primaryKeyCreations);
_CompareViews(views, alteredTables, out createViews, out dropViews);
_CompareStoredProcedures(procedures, alteredTables,dropViews, out createProcedures, out updateProcedures,out dropProcedures);
_CompareTriggers(triggers,alteredTables,dropViews,dropProcedures, out dropTriggers, out createTriggers);
_CompareGenerators(generators, out createGenerators);
_ExtractConstraintDropsCreates(tables, conn, out constraintDrops, out constraintCreations);
_ExtractForeignKeyCreatesDrops(tables, out foreignKeyDrops, out foreignKeyCreations);
_CompareIdentities(identities, out createIdentities, out setIdentities);
_ExtractIndexCreationsDrops(tables, out dropIndexes, out createIndexes);
List<string> tableCreations = new List<string>();
List<string> tableAlterations = new List<string>();
List<string> computedFieldDeletions = new List<string>();
List<string> computedFieldAdditions = new List<string>();
foreach (ExtractedTableMap map in tables)
{
bool foundTable = false;
for(int x=0;x<_tables.Count;x++){
if (map.TableName == _tables[x].TableName)
{
foundTable = true;
foreach (ExtractedFieldMap efm in map.Fields)
{
bool foundField = false;
foreach (ExtractedFieldMap ee in _tables[x].Fields)
{
if (efm.FieldName == ee.FieldName)
{
foundField = true;
if (efm.ComputedCode != null)
{
if ((efm.FullFieldType != ee.FullFieldType) || !(conn is MsSqlConnection ? Utility.StringsEqualIgnoreWhitespaceBracketsCase(efm.ComputedCode, ee.ComputedCode) : Utility.StringsEqualIgnoreWhitespace(efm.ComputedCode, ee.ComputedCode)))
{
computedFieldDeletions.Add(conn.queryBuilder.DropColumn(map.TableName, efm.FieldName));
computedFieldAdditions.Add(conn.queryBuilder.CreateColumn(map.TableName, efm));
}
}
else
{
if ((efm.FullFieldType!=ee.FullFieldType) &&
!((efm.Type == "BLOB") && (ee.Type == "BLOB")))
{
if (efm.PrimaryKey && ee.PrimaryKey)
{
primaryKeyDrops.Add(new PrimaryKey(map));
primaryKeyCreations.Add(new PrimaryKey(map));
}
else
{
foreach (ForeignRelationMap frms in _tables[x].ForeignFields)
{
if (frms.InternalField == efm.FieldName)
{
foreignKeyDrops.Add(new ForeignKey(_tables[x], frms.ExternalTable, frms.ID));
foreignKeyCreations.Add(new ForeignKey(_tables[x], frms.ExternalTable, frms.ID));
break;
}
}
}
foreach (ExtractedFieldMap cefm in _tables[x].GetComputedFieldsForField(efm.FieldName))
computedFieldDeletions.Add(conn.queryBuilder.DropColumn(map.TableName, cefm.FieldName));
tableAlterations.Add(conn.queryBuilder.AlterFieldType(map.TableName, efm, ee));
foreach (ExtractedFieldMap cefm in map.GetComputedFieldsForField(efm.FieldName))
computedFieldAdditions.Add(conn.queryBuilder.CreateColumn(map.TableName, cefm));
}
if (efm.Nullable != ee.Nullable)
{
foreach (ExtractedFieldMap cefm in _tables[x].GetComputedFieldsForField(efm.FieldName))
computedFieldDeletions.Add(conn.queryBuilder.DropColumn(map.TableName, cefm.FieldName));
foreach (ExtractedFieldMap cefm in map.GetComputedFieldsForField(efm.FieldName))
computedFieldAdditions.Add(conn.queryBuilder.CreateColumn(map.TableName, cefm));
if (efm.PrimaryKey && ee.PrimaryKey)
{
primaryKeyDrops.Add(new PrimaryKey(map));
primaryKeyCreations.Add(new PrimaryKey(map));
}
else
{
foreach (ForeignRelationMap frms in _tables[x].ForeignFields)
{
if (frms.InternalField == efm.FieldName)
{
foreignKeyDrops.Add(new ForeignKey(_tables[x], frms.ExternalTable, frms.ID));
foreignKeyCreations.Add(new ForeignKey(_tables[x], frms.ExternalTable, frms.ID));
break;
}
}
}
if (!efm.Nullable)
constraintCreations.Add(conn.queryBuilder.CreateNullConstraint(map.TableName, efm));
else
constraintDrops.Add(conn.queryBuilder.DropNullConstraint(map.TableName, efm));
}
}
break;
}
}
if (!foundField)
tableAlterations.Add(conn.queryBuilder.CreateColumn(map.TableName, efm));
}
foreach (ExtractedFieldMap efm in _tables[x].Fields)
{
bool foundField = false;
foreach (ExtractedFieldMap ee in map.Fields)
{
if (efm.FieldName == ee.FieldName)
{
foundField = true;
break;
}
}
if (!foundField)
{
if (efm.PrimaryKey)
{
primaryKeyDrops.Add(new PrimaryKey(map));
primaryKeyCreations.Add(new PrimaryKey(map));
}
else
{
foreach (ForeignRelationMap frms in _tables[x].ForeignFields)
{
if (frms.InternalField == efm.FieldName)
{
foreignKeyDrops.Add(new ForeignKey(_tables[x], frms.ExternalTable, frms.ID));
break;
}
}
}
tableAlterations.Add(conn.queryBuilder.DropColumn(map.TableName, efm.FieldName));
}
}
}
}
if (!foundTable)
{
ret.Add(map.TableName);
tableCreations.Add(conn.queryBuilder.CreateTable(map));
}
}
foreach (PrimaryKey pk in primaryKeyDrops)
{
foreach (Trigger t in _triggers)
{
if (t.Conditions.Contains("FOR " + pk.Name + " "))
dropTriggers.Add(t);
}
foreach (Trigger t in triggers)
{
if (t.Conditions.Contains("FOR " + pk.Name + " "))
createTriggers.Add(t);
}
}
_CleanUpForeignKeys(ref foreignKeyDrops);
_CleanUpForeignKeys(ref foreignKeyCreations);
List<string> alterations = new List<string>();
foreach (Trigger trig in dropTriggers)
alterations.Add(conn.queryBuilder.DropTrigger(trig.Name));
alterations.Add(_COMMIT_STRING);
foreach (StoredProcedure sp in dropProcedures)
alterations.Add(conn.queryBuilder.DropProcedure(sp.ProcedureName));
alterations.Add(_COMMIT_STRING);
foreach (View vw in dropViews)
alterations.Add(conn.queryBuilder.DropView(vw.Name));
alterations.Add(_COMMIT_STRING);
//add drops to alterations
alterations.AddRange(constraintDrops);
alterations.Add(_COMMIT_STRING);
foreach (string str in dropIndexes.Keys)
{
foreach (Index ind in dropIndexes[str])
alterations.Add(conn.queryBuilder.DropTableIndex(str, ind.Name));
}
alterations.Add(_COMMIT_STRING);
foreach (ForeignKey fk in foreignKeyDrops)
alterations.Add(conn.queryBuilder.DropForeignKey(fk.InternalTable, fk.ExternalTable, fk.ExternalFields[0], fk.InternalFields[0]));
alterations.Add(_COMMIT_STRING);
foreach (PrimaryKey pk in primaryKeyDrops)
{
foreach (string field in pk.Fields)
alterations.Add(conn.queryBuilder.DropPrimaryKey(pk));
}
alterations.Add(_COMMIT_STRING);
alterations.AddRange(computedFieldDeletions);
alterations.Add(_COMMIT_STRING);
alterations.AddRange(tableAlterations);
alterations.Add(_COMMIT_STRING);
alterations.AddRange(tableCreations);
alterations.Add(_COMMIT_STRING);
//add creations to alterations
alterations.AddRange(constraintCreations);
alterations.Add(_COMMIT_STRING);
alterations.AddRange(computedFieldAdditions);
alterations.Add(_COMMIT_STRING);
foreach (View vw in createViews)
alterations.Add(conn.queryBuilder.CreateView(vw));
alterations.Add(_COMMIT_STRING);
foreach (PrimaryKey pk in primaryKeyCreations)
alterations.Add(conn.queryBuilder.CreatePrimaryKey(pk));
alterations.Add(_COMMIT_STRING);
foreach (ForeignKey fk in foreignKeyCreations)
alterations.Add(conn.queryBuilder.CreateForeignKey(fk));
alterations.Add(_COMMIT_STRING);
foreach (string str in createIndexes.Keys)
{
foreach (Index ind in createIndexes[str])
alterations.Add(conn.queryBuilder.CreateTableIndex(str, ind.Fields, ind.Name, ind.Unique, ind.Ascending));
}
alterations.Add(_COMMIT_STRING);
foreach (StoredProcedure proc in updateProcedures)
alterations.Add(conn.queryBuilder.UpdateProcedure(proc));
alterations.Add(_COMMIT_STRING);
foreach (StoredProcedure proc in createProcedures)
alterations.Add(conn.queryBuilder.CreateProcedure(proc));
alterations.Add(_COMMIT_STRING);
foreach (Generator gen in createGenerators)
{
alterations.Add(conn.queryBuilder.CreateGenerator(gen.Name));
alterations.Add(conn.queryBuilder.SetGeneratorValue(gen.Name, gen.Value));
}
alterations.Add(_COMMIT_STRING);
foreach (Trigger trig in createTriggers)
{
alterations.Add(conn.queryBuilder.CreateTrigger(trig));
}
alterations.Add(_COMMIT_STRING);
foreach (IdentityField idf in createIdentities)
alterations.Add(conn.queryBuilder.CreateIdentityField(idf));
alterations.Add(_COMMIT_STRING);
foreach (IdentityField idf in setIdentities)
alterations.Add(conn.queryBuilder.SetIdentityFieldValue(idf));
alterations.Add(_COMMIT_STRING);
for (int x = 0; x < alterations.Count; x++)
{
if (alterations[x].Contains(";ALTER")&&!alterations[x].StartsWith("CREATE TRIGGER")
&& !alterations[x].StartsWith("ALTER TRIGGER"))
{
string tmp = alterations[x];
alterations.RemoveAt(x);
alterations.Insert(x, tmp.Substring(0, tmp.IndexOf(";ALTER") + 1));
alterations.Insert(x + 1, tmp.Substring(tmp.IndexOf(";ALTER") + 1));
}
else if (alterations[x].Contains(";\nALTER") && !alterations[x].StartsWith("CREATE TRIGGER")
&& !alterations[x].StartsWith("ALTER TRIGGER"))
{
string tmp = alterations[x];
alterations.RemoveAt(x);
alterations.Insert(x, tmp.Substring(0, tmp.IndexOf(";\nALTER") + 1));
alterations.Insert(x + 1, tmp.Substring(tmp.IndexOf(";\nALTER") + 1));
}
if (alterations[x].StartsWith("ALTER") && !alterations[x].TrimEnd(new char[] { '\n', ' ', '\t' }).EndsWith(";"))
{
alterations[x] = alterations[x] + ";";
}
}
Utility.RemoveDuplicateStrings(ref alterations, new string[] { _COMMIT_STRING });
for (int x = 0; x < alterations.Count; x++)
{
if (x + 1 < alterations.Count)
{
if (alterations[x + 1].Trim() == alterations[x].Trim() && alterations[x].Trim() == "COMMIT;")
{
alterations.RemoveAt(x);
x--;
}
}
}
if (!Utility.OnlyContains(alterations,new string[]{_COMMIT_STRING}))
{
if (alterations[0].Trim() == _COMMIT_STRING)
alterations.RemoveAt(0);
try
{
if (_pool.DebugMode)
{
foreach (string str in alterations)
{
if (!str.EndsWith(";"))
Logger.LogLine(str + ";");
else
Logger.LogLine(str);
}
}
else
{
foreach (string str in alterations)
{
if (str.Length > 0)
{
if (str == _COMMIT_STRING)
conn.Commit();
else if (str.EndsWith(_COMMIT_STRING))
{
conn.ExecuteNonQuery(str.Substring(0, str.Length - 8));
conn.Commit();
}
else
conn.ExecuteNonQuery(str);
}
}
}
}
catch (Exception e)
{
Logger.LogLine(e.Message);
Logger.LogLine(e.StackTrace);
throw e;
}
}
conn.Commit();
conn.Reset();
_pool.Translator.ApplyAllDescriptions(tables, triggers, generators, identities, views, procedures,conn);
conn.Commit();
return ret;
}
private void Begin()
{
Connection.ExecuteNonQuery("BEGIN TRANSACTION;", null);
}
public void ApplyAllDescriptions(List<ExtractedTableMap> tables, List<Trigger> triggers, List<Generator> generators, List<IdentityField> identities, List<View> views, List<StoredProcedure> procedures, Connection conn)
{
Type t;
PropertyInfo pi;
for(int x=0;x<_createDescriptions.Count;x++)
{
string str = _createDescriptions[x];
bool remove = false;
switch (str.Split(':')[0])
{
case "ENUM":
case "TBL":
case "ITMD":
foreach (ExtractedTableMap etm in tables)
{
if (etm.TableName == _nameTranslations[str])
{
conn.ExecuteNonQuery(conn.queryBuilder.SetTableDescription(etm.TableName, str));
remove = true;
break;
}
}
break;
case "FLD":
foreach (ExtractedTableMap etm in tables)
{
t = _pool.Mapping[etm.TableName];
if (t != null)
{
if (str.StartsWith(string.Format(_FIELD_DESCRIPTION, t.FullName, "")))
{
foreach (ExtractedFieldMap efm in etm.Fields)
{
if (_nameTranslations[str] == efm.FieldName)
{
conn.ExecuteNonQuery(conn.queryBuilder.SetFieldDescription(etm.TableName, efm.FieldName, str));
remove = true;
break;
}
}
if (remove)
break;
}
}
}
break;
case "ITMD_FLD":
foreach (ExtractedTableMap etm in tables)
{
t = _pool.Mapping.GetTypeForIntermediateTable(etm.TableName, out pi);
if (t != null)
{
if (str.StartsWith(string.Format(_INTERMEDIATE_FIELD_DESCRIPTION, new object[] { t.FullName, pi.Name, "",""}).Trim('.')))
{
foreach (ExtractedFieldMap efm in etm.Fields)
{
if (_nameTranslations[str] == efm.FieldName)
{
conn.ExecuteNonQuery(conn.queryBuilder.SetFieldDescription(etm.TableName, efm.FieldName, str));
remove = true;
break;
}
}
if (remove)
break;
}
}
}
break;
case "GEN":
foreach (Generator gen in generators)
{
if (gen.Name == _nameTranslations[str])
{
conn.ExecuteNonQuery(conn.queryBuilder.SetGeneratorDescription(gen.Name, str));
remove = true;
break;
}
}
break;
case "TRIG":
foreach (Trigger trig in triggers)
{
if (trig.Name == _nameTranslations[str])
{
conn.ExecuteNonQuery(conn.queryBuilder.SetTriggerDescription(trig.Name, str));
remove = true;
break;
}
}
break;
case "VIEW":
foreach (View vw in views)
{
if (vw.Name == _nameTranslations[str])
{
conn.ExecuteNonQuery(conn.queryBuilder.SetViewDescription(vw.Name, str));
remove = true;
break;
}
}
break;
case "IND":
foreach (ExtractedTableMap etm in tables)
{
foreach (Index ind in etm.Indices)
{
if (_nameTranslations[str] == ind.Name)
{
conn.ExecuteNonQuery(conn.queryBuilder.SetIndexDescription(ind.Name, str));
remove = true;
break;
}
}
if (remove)
break;
}
break;
}
if (remove)
{
_createDescriptions.RemoveAt(x);
x--;
}
}
}
internal void InsertToDB(Type t, int id, string value, Connection c)
{
t = (t.IsGenericType ? t.GetGenericArguments()[0] : t);
c.ExecuteNonQuery("INSERT INTO " + _enumTableMaps[t] + " VALUES(" + c.CreateParameterName("id") + "," + c.CreateParameterName("value") + ");",
new System.Data.IDbDataParameter[]{
c.Pool.CreateParameter(c.CreateParameterName("id"),id),
c.Pool.CreateParameter(c.CreateParameterName("value"),value)
});
}
protected internal override bool CreateDatabase()
{
bool result = true;
string createDatabase = "";
//se for setup, criar a base de dados no pgsql
if(CurrentConfig.TipoInstalacao == Enuns.TipoInstalacao.ServidorPostgreSQL)
{
Connection connection = new Connection(
CurrentConfig.ServerConfig.DatabaseType,
"",
CurrentConfig.ServerConfig.Server,
CurrentConfig.ServerConfig.Port,
CurrentConfig.ServerConfig.UserId,
CurrentConfig.ServerConfig.Password
);
connection.Open();
Databases dbs = Databases.GetDatabases(connection);
string m = "Já existe uma base de dados com este nome no servidor.\r\n\r\n";
m += "Tem certeza que deseja excluir esta base de dados e continuar com a instalação?\r\n\r\n\t\t";
m += "ESTA AÇÃO NÃO PODERÁ SER DESFEITA. CERTIFIQUE-SE QUE TENHA UMA CÓPIA SE PRECISAR RETORNAR OS DADOS.";
if(dbs.Contains(CurrentConfig.ServerConfig.Database) &&
MessageBox.AskYesNo(m) == System.Windows.Forms.DialogResult.No)
throw new Exception("A base de dados \"" + CurrentConfig.ServerConfig.Database + "\" não pode ser usada para esta instalação, pois já está sendo usada por outro processo.");
try
{
createDatabase = String.Format(@"SELECT pg_terminate_backend(pid)
FROM pg_stat_activity
WHERE pg_stat_activity.datname = '{0}'", CurrentConfig.ServerConfig.Database);
connection.ExecuteNonQuery(createDatabase);
}
catch
{
createDatabase = String.Format(@"SELECT pg_terminate_backend(procpid)
FROM pg_stat_activity
WHERE pg_stat_activity.datname = '{0}'", CurrentConfig.ServerConfig.Database);
connection.ExecuteNonQuery(createDatabase);
}
createDatabase = String.Format(@"DROP DATABASE IF EXISTS {0};", CurrentConfig.ServerConfig.Database);
connection.ExecuteNonQuery(createDatabase);
createDatabase = String.Format(@"CREATE DATABASE {0}
WITH
ENCODING = 'LATIN1'
TABLESPACE = pg_default
LC_COLLATE = 'C'
LC_CTYPE = 'C'
TEMPLATE = template0
CONNECTION LIMIT = -1;",
CurrentConfig.ServerConfig.Database);
connection.ExecuteNonQuery(createDatabase);
}
return result;
}
internal void InsertEnumIntoTable(Type t, Connection conn)
{
t = (t.IsGenericType ? t.GetGenericArguments()[0] : t);
foreach (string str in Enum.GetNames(t))
{
conn.ExecuteNonQuery(string.Format("INSERT INTO {0}({1}) VALUES({2});",
_enumTableMaps[t],
_pool.Translator.GetEnumValueFieldName(t, conn),
conn.CreateParameterName("value")),
new System.Data.IDbDataParameter[]{conn.CreateParameter(conn.CreateParameterName("value"),str)});
}
conn.Commit();
LoadEnumsFromTable(t, conn);
}
public void Commit()
{
Connection.ExecuteNonQuery("COMMIT TRANSACTION;", null);
Connection = null;
}
public void Insert(Credencial credencial)
{
string query = $"INSERT INTO credencial VALUES ({credencial.IdPersona}, '{credencial.Password}')";
_connection.ExecuteNonQuery(query);
}
public void Rollback()
{
Connection.ExecuteNonQuery("ROLLBACK TRANSACTION;", null);
Connection = null;
}
private void btOK_Click(object sender, System.EventArgs e)
{
string newName = txtName.Text.Trim();
newName = System.Text.RegularExpressions.Regex.Replace(newName, "~[a-zA-Z~_]", "");
if (newName.Length == 0)
{
MessageBox.Show(this, Resource1.fieldNameMissing, this.Text, System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Exclamation);
}
else
{
try
{
string sep1 = _connection.NameDelimiterBegin;
string sep2 = _connection.NameDelimiterEnd;
StringBuilder sSQL = new StringBuilder("ALTER TABLE ");
sSQL.Append(sep1);
sSQL.Append(lblTable.Text);
sSQL.Append(sep2);
if (bNew)
{
sSQL.Append(" ADD ");
sSQL.Append(sep1);
sSQL.Append(newName);
sSQL.Append(sep2);
sSQL.Append(" ");
}
else
{
if (_connection.IsOdbc)
{
if (field.Name != newName)
{
sSQL.Append(" CHANGE COLUMN ");
sSQL.Append(sep1);
sSQL.Append(field.Name);
sSQL.Append(sep2);
sSQL.Append(" ");
sSQL.Append(sep1);
sSQL.Append(newName);
sSQL.Append(sep2);
sSQL.Append(" ");
}
else
{
sSQL.Append(" MODIFY COLUMN ");
sSQL.Append(sep1);
sSQL.Append(field.Name);
sSQL.Append(sep2);
sSQL.Append(" ");
}
}
else
{
sSQL.Append(" ALTER COLUMN ");
sSQL.Append(sep1);
sSQL.Append(field.Name);
sSQL.Append(sep2);
sSQL.Append(" ");
}
}
switch (cbxType.SelectedIndex)
{
case DbTypeComboBox.FLD_String:
try
{
field.DataSize = Convert.ToInt32(txtSize.Text);
txtSize.Text = field.DataSize.ToString();
}
catch
{
}
if (field.DataSize <= 0)
{
field.DataSize = 255;
}
field.OleDbType = System.Data.OleDb.OleDbType.VarWChar;
if (_connection.IsOdbc)
{
sSQL.Append(" VARCHAR(");
sSQL.Append(field.DataSize.ToString());
sSQL.Append(") CHARACTER SET utf8 COLLATE utf8_bin NULL;");
}
else
{
sSQL.Append(" NVARCHAR(");
sSQL.Append(field.DataSize.ToString());
sSQL.Append(") NULL ");
}
break;
case DbTypeComboBox.FLD_Integer:
field.OleDbType = System.Data.OleDb.OleDbType.Integer;
field.DataSize = 4;
sSQL.Append(" INT NULL ");
break;
case DbTypeComboBox.FLD_Long_integer:
field.OleDbType = System.Data.OleDb.OleDbType.BigInt;
field.DataSize = 8;
if (_connection.IsOdbc)
{
sSQL.Append(" BIGINT NULL; ");
}
else
{
sSQL.Append(" LONG NULL ");
}
break;
case DbTypeComboBox.FLD_Decimal:
field.OleDbType = System.Data.OleDb.OleDbType.Double;
field.DataSize = 8;
sSQL.Append(" DOUBLE NULL ");
break;
case DbTypeComboBox.FLD_Currency:
field.OleDbType = System.Data.OleDb.OleDbType.Currency;
field.DataSize = 8;
if (_connection.IsOdbc)
{
sSQL.Append(" DECIMAL NULL; ");
}
else
{
sSQL.Append(" CURRENCY NULL ");
}
break;
case DbTypeComboBox.FLD_Date:
field.OleDbType = System.Data.OleDb.OleDbType.Date;
field.DataSize = 8;
sSQL.Append(" DATETIME NULL ");
break;
case DbTypeComboBox.FLD_Date_time:
field.OleDbType = System.Data.OleDb.OleDbType.DBTimeStamp;
field.DataSize = 8;
sSQL.Append(" DATETIME NULL ");
break;
case DbTypeComboBox.FLD_Bool:
field.OleDbType = System.Data.OleDb.OleDbType.Boolean;
field.DataSize = 1;
if (_connection.IsOdbc)
{
sSQL.Append(" BOOLEAN NULL; ");
}
else
{
if (_connection.IsMySql)
{
sSQL.Append(" BIT(1) NULL ");
}
else
{
sSQL.Append(" YESNO NULL ");
}
}
break;
case DbTypeComboBox.FLD_Text:
field.OleDbType = System.Data.OleDb.OleDbType.LongVarWChar;
field.DataSize = -1;
sSQL.Append(" TEXT NULL ");
break;
case DbTypeComboBox.FLD_Binary:
field.OleDbType = System.Data.OleDb.OleDbType.LongVarBinary;
field.DataSize = -1;
if (_connection.IsOdbc)
{
sSQL.Append(" SQL_LONGVARBINARY NULL; ");
}
else
{
sSQL.Append(" BIGBINARY ");
}
break;
}
_connection.ExecuteNonQuery(sSQL.ToString());
//
field.Name = newName;
this.DialogResult = System.Windows.Forms.DialogResult.OK;
}
catch (Exception er)
{
MessageBox.Show(this, er.Message, this.Text, System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Exclamation);
}
}
}
public override Lfx.Types.OperationResult Guardar()
{
qGen.IStatement Comando;
if (this.Existe == false)
{
Comando = new qGen.Insert("chequeras");
Comando.ColumnValues.AddWithValue("fecha", new qGen.SqlExpression("NOW()"));
}
else
{
Comando = new qGen.Update("chequeras");
Comando.WhereClause = new qGen.Where("id_chequera", m_ItemId);
}
if (this.Banco == null)
{
Comando.ColumnValues.AddWithValue("id_banco", null);
}
else
{
Comando.ColumnValues.AddWithValue("id_banco", this.Banco.Id);
}
Comando.ColumnValues.AddWithValue("prefijo", this.Prefijo);
Comando.ColumnValues.AddWithValue("desde", this.Desde);
Comando.ColumnValues.AddWithValue("hasta", this.Hasta);
Comando.ColumnValues.AddWithValue("cheques_total", this.Hasta - this.Desde);
if (this.Caja == null)
{
Comando.ColumnValues.AddWithValue("id_caja", null);
}
else
{
Comando.ColumnValues.AddWithValue("id_caja", this.Caja.Id);
}
if (this.Sucursal == null)
{
Comando.ColumnValues.AddWithValue("id_sucursal", null);
}
else
{
Comando.ColumnValues.AddWithValue("id_sucursal", this.Sucursal.Id);
}
Comando.ColumnValues.AddWithValue("titular", this.Titular);
Comando.ColumnValues.AddWithValue("estado", this.Estado);
Connection.ExecuteNonQuery(Comando);
this.ActualizarId();
if (this.Desde > 0 && this.Hasta > 0 && this.Hasta > this.Desde)
{
qGen.Update Actua = new qGen.Update("bancos_cheques");
Actua.ColumnValues.AddWithValue("id_chequera", this.Id);
Actua.WhereClause = new qGen.Where();
Actua.WhereClause.AddWithValue("emitido", 1);
Actua.WhereClause.AddWithValue("id_banco", this.Banco.Id);
Actua.WhereClause.AddWithValue("numero", this.Desde, this.Hasta);
Connection.ExecuteNonQuery(Actua);
Actua = new qGen.Update("bancos_cheques");
Actua.ColumnValues.Add(new Lazaro.Orm.Data.ColumnValue("id_chequera", Lazaro.Orm.ColumnTypes.Integer, null));
Actua.WhereClause = new qGen.Where();
Actua.WhereClause.AddWithValue("emitido", 1);
Actua.WhereClause.AddWithValue("id_banco", this.Banco.Id);
Actua.WhereClause.AddWithValue("id_chequera", this.Id);
qGen.Where Numeros = new qGen.Where(qGen.AndOr.Or);
Numeros.AddWithValue("numero", qGen.ComparisonOperators.LessThan, this.Desde);
Numeros.AddWithValue("numero", qGen.ComparisonOperators.GreaterThan, this.Hasta);
Actua.WhereClause.AddWithValue(Numeros);
Connection.ExecuteNonQuery(Actua);
}
return(base.Guardar());
}
private void _CreateTablesForType(Type type, Connection conn)
{
List<Type> types = new List<Type>();
types.Add(type);
if (new List<Type>(type.GetInterfaces()).Contains(typeof(IClassView)))
{
ClassViewAttribute cva = conn.Pool[type];
foreach (Type t in cva.Query.RequiredTypes)
{
if (!types.Contains(t))
types.Add(t);
types = _RecurLoadTypesForTable(_pool.Mapping[t], types);
}
}
else
types = _RecurLoadTypesForTable(_pool.Mapping[type], types);
for (int x = 1; x < types.Count; x++)
{
if (_createdTypes.Contains(types[x]))
{
types.RemoveAt(x);
x--;
}
}
List<ExtractedTableMap> tables;
List<Trigger> triggers;
List<Generator> generators;
List<IdentityField> identities;
List<View> views;
List<StoredProcedure> procedures;
ExtractExpectedStructure(ref types, out tables, out triggers, out generators, out identities, out views, out procedures, conn);
List<string> createdTables = _UpdateStructure(tables, triggers, generators, identities, views, procedures,conn);
foreach (Type t in types)
{
if (Utility.IsEnum(t))
{
if (createdTables.Contains(_pool.Enums[t]))
_pool.Enums.InsertEnumIntoTable(t, conn);
else
_pool.Enums.LoadEnumsFromTable(t, conn);
}
}
_createdTypes.AddRange(types);
_UpdateAddiontalData(triggers, generators, identities, views, procedures);
if (!_pool.DebugMode && (_translations.Count > 0))
{
foreach (Type t in types)
{
if (_translations.ContainsKey(t))
{
foreach (EnumTranslationPair etp in _translations[t])
{
conn.ExecuteNonQuery(String.Format(
"UPDATE {0} SET {1} = '{3}' WHERE {1} = '{2}'",
new object[]{
_pool.Enums[t],
_pool.Translator.GetEnumValueFieldName(t,conn),
etp.OriginalName,
etp.NewName}
));
conn.Close();
}
}
Dictionary<string, int> enumValuesMap = new Dictionary<string, int>();
Dictionary<int, string> enumReverseValuesMap = new Dictionary<int, string>();
List<string> enumNames = new List<string>(Enum.GetNames(t));
List<int> deletes = new List<int>();
conn.ExecuteQuery(String.Format("SELECT ID,{1} FROM {0}",
_pool.Enums[t],
_pool.Translator.GetEnumValueFieldName(t, conn)));
while (conn.Read())
{
if (enumNames.Contains(conn[1].ToString()))
{
enumValuesMap.Add(conn[1].ToString(), (int)conn[0]);
enumReverseValuesMap.Add((int)conn[0], conn[1].ToString());
enumNames.Remove(conn[1].ToString());
}
else
deletes.Add((int)conn[0]);
}
conn.Close();
if (deletes.Count > 0)
{
foreach (int i in deletes)
{
conn.ExecuteNonQuery(String.Format("DELETE FROM {0} WHERE ID = {1}",
_pool.Enums[t],
i));
conn.Close();
}
}
if (enumNames.Count > 0)
{
foreach (string str in enumNames)
{
conn.ExecuteNonQuery(String.Format("INSERT INTO {0}({1}) VALUES('{2}')",
_pool.Enums[t],
_pool.Translator.GetEnumValueFieldName(t, conn),
str));
conn.Close();
conn.ExecuteQuery(String.Format("SELECT ID FROM {0} WHERE {1}='{2}'",
_pool.Enums[t],
_pool.Translator.GetEnumValueFieldName(t, conn),
str));
conn.Read();
enumValuesMap.Add(str, (int)conn[0]);
enumReverseValuesMap.Add((int)conn[0], str);
conn.Close();
}
}
conn.Commit();
_pool.Enums.AssignMapValues(t, enumValuesMap, enumReverseValuesMap);
}
}
}
/// <summary>
/// Deletes a table from the database.
/// </summary>
/// <param name="tableName">Name of the table to be deleted.</param>
public void DeleteTable(string tableName)
{
Connection.ExecuteNonQuery($"DROP TABLE {tableName}");
}
public void insert()
{
Connection.ExecuteNonQuery("sp_addDiadanh @tendd , @matinh", new object[] { tendd, matinh });
}
protected internal virtual void InstallEnd(Connection connection)
{
try
{
//abrir o arquivo de endereços
FileInfo dbEnderecoFile = new FileInfo(CurrentConfig.CurrentDirectory + @"\database\Endereco.sql");
double progressValue = 0;
double progress = 0;
#if DEBUG
//Desativar o log para evitar erros de outOfMemory em modo debug
Debug.Deactivate();
#endif
using(StreamReader reader = new StreamReader(dbEnderecoFile.FullName))
{
string line = "";
while((line = reader.ReadLine()) != null)
{
connection.ExecuteNonQuery(line);
progress = ((progressValue += line.Length) / dbEnderecoFile.Length * 100);
ProgressInvoke((int)progress);
Application.DoEvents();
if(CurrentConfig.CancelInstallation) throw new Exception("A instalação foi cancelada.");
}
}
}
finally
{
#if DEBUG
Debug.Activate();
#endif
}
}
public void delete()
{
Connection.ExecuteNonQuery("sp_delDiadanh @madd", new object[] { madd });
}
public override Lfx.Types.OperationResult Ok()
{
int PV = EntradaPV.ValueInt;
int Desde = EntradaDesde.ValueInt;
int Hasta = EntradaHasta.ValueInt;
int Cantidad = Hasta - Desde + 1;
Lui.Forms.YesNoDialog Pregunta = new Lui.Forms.YesNoDialog("Una vez anulados, los comprobantes deberán ser archivados en todas sus copias y no podrán ser rehabilitados ni reutilizados.", "¿Está seguro de que desea anular " + Cantidad.ToString() + " comprobantes?");
Pregunta.DialogButtons = Lui.Forms.DialogButtons.YesNo;
if (Pregunta.ShowDialog() == DialogResult.OK)
{
bool AnularPagos = EntradaAnularPagos.ValueInt != 0;
int m_Id = 0;
string IncluyeTipos = "";
switch (EntradaTipo.TextKey)
{
case "A":
IncluyeTipos = "'FA', 'NCA', 'NDA'";
break;
case "B":
IncluyeTipos = "'FB', 'NCB', 'NDB'";
break;
case "C":
IncluyeTipos = "'FC', 'NCC', 'NDC'";
break;
case "E":
IncluyeTipos = "'FE', 'NCE', 'NDE'";
break;
case "M":
IncluyeTipos = "'FM', 'NCM', 'NDM'";
break;
case "T":
IncluyeTipos = "'T'";
break;
default:
IncluyeTipos = "'" + EntradaTipo.TextKey + "'";
break;
}
Lfx.Types.OperationProgress Progreso = new Lfx.Types.OperationProgress("Anulando comprobantes", "Se están anulando los comprobantes seleccionados.");
Progreso.Cancelable = true;
Progreso.Max = Cantidad;
Progreso.Begin();
IDbTransaction Trans = this.Connection.BeginTransaction(IsolationLevel.Serializable);
for (int Numero = Desde; Numero <= Hasta; Numero++)
{
int IdFactura = Connection.FieldInt("SELECT id_comprob FROM comprob WHERE impresa=1 AND tipo_fac IN (" + IncluyeTipos + ") AND pv=" + PV.ToString() + " AND numero=" + Numero.ToString() + " ORDER BY anulada");
if (IdFactura == 0)
{
// Es una factura que todava no existe
// Tengo que crear la factura y anularla
qGen.Insert InsertarComprob = new qGen.Insert("comprob");
InsertarComprob.ColumnValues.AddWithValue("tipo_fac", "F" + EntradaTipo.TextKey);
InsertarComprob.ColumnValues.AddWithValue("id_formapago", 3);
InsertarComprob.ColumnValues.AddWithValue("id_sucursal", Lfx.Workspace.Master.CurrentConfig.Empresa.SucursalActual);
InsertarComprob.ColumnValues.AddWithValue("pv", Lfx.Types.Parsing.ParseInt(EntradaPV.Text));
InsertarComprob.ColumnValues.AddWithValue("fecha", new qGen.SqlExpression("NOW()"));
InsertarComprob.ColumnValues.AddWithValue("id_vendedor", Lbl.Sys.Config.Actual.UsuarioConectado.Id);
InsertarComprob.ColumnValues.AddWithValue("id_cliente", Lbl.Sys.Config.Actual.UsuarioConectado.Id);
InsertarComprob.ColumnValues.AddWithValue("obs", "Comprobante anulado antes de ser impreso.");
InsertarComprob.ColumnValues.AddWithValue("impresa", 1);
InsertarComprob.ColumnValues.AddWithValue("anulada", 1);
Connection.ExecuteNonQuery(InsertarComprob);
m_Id = Connection.FieldInt("SELECT LAST_INSERT_ID()");
Lbl.Comprobantes.ComprobanteConArticulos NuevoComprob = new Lbl.Comprobantes.ComprobanteConArticulos(this.Connection, m_Id);
new Lbl.Comprobantes.Numerador(NuevoComprob).Numerar(true);
}
else
{
Lbl.Comprobantes.ComprobanteConArticulos Fac = new Lbl.Comprobantes.ComprobanteConArticulos(Connection, IdFactura);
if (Fac.Anulado == false)
{
Fac.Anular(AnularPagos);
}
}
Progreso.Advance(1);
if (Progreso.Cancelar)
{
break;
}
}
Progreso.End();
if (Progreso.Cancelar)
{
Trans.Rollback();
Lfx.Workspace.Master.RunTime.Toast("La operación fue cancelada.", "Aviso");
}
else
{
Trans.Commit();
ProximosNumeros.Clear();
if (this.DeCompra)
{
Lui.Forms.MessageBox.Show("Se anularon los comprobantes seleccionados. Si fueron anulados por error de carga, ahora puede cargarlos nuevamente.", "Aviso");
}
else
{
Lui.Forms.MessageBox.Show("Se anularon los comprobantes seleccionados. Recuerde archivar ambas copias.", "Aviso");
}
}
EntradaDesde.ValueInt = 0;
EntradaHasta.ValueInt = 0;
EntradaDesde.Focus();
return(base.Ok());
}
else
{
return(new Lfx.Types.FailureOperationResult("La operación fue cancelada."));
}
}
private Dictionary<string, int> _SyncMissingValues(Dictionary<string, int> vals, Type t, Connection conn)
{
t = (t.IsGenericType ? t.GetGenericArguments()[0] : t);
string[] keys = new string[vals.Count];
vals.Keys.CopyTo(keys, 0);
foreach (string str in Enum.GetNames(t))
{
if (!vals.ContainsKey(str))
{
conn.ExecuteNonQuery(string.Format("INSERT INTO {0}({1}) VALUES({2});",new object[]{
_enumTableMaps[t],
_pool.Translator.GetEnumValueFieldName(t, conn),
conn.CreateParameterName("value")}),
new System.Data.IDbDataParameter[]{
conn.Pool.CreateParameter(conn.CreateParameterName("id"),null,Org.Reddragonit.Dbpro.Structure.Attributes.FieldType.INTEGER,4),
conn.CreateParameter(conn.CreateParameterName("value"),str)
});
conn.ExecuteQuery("SELECT ID FROM " + _enumTableMaps[t] + " WHERE " + _pool.Translator.GetEnumValueFieldName(t, conn) + " = " + conn.CreateParameterName("value"),
new IDbDataParameter[]{
conn.CreateParameter(conn.CreateParameterName("value"),str)
});
conn.Read();
vals.Add(str, conn.GetInt32(0));
conn.Close();
}
}
return vals;
}
/// <summary>
/// Deletes the table.
/// </summary>
public override void Delete()
{
var query = new Query($"DROP TABLE IF EXISTS {Metadata.Table}", Type);
Connection.ExecuteNonQuery(query);
}
/// <summary>
/// Persists an object to the database.
/// </summary>
/// <param name="dataObject">the object to save to the database</param>
protected override bool SaveObjectImpl(DataObject dataObject)
{
try
{
string tableName = dataObject.TableName;
var sb = new StringBuilder("UPDATE `" + tableName + "` SET ");
BindingInfo[] bindingInfo = GetBindingInfo(dataObject.GetType());
bool hasRelations = false;
bool first = true;
string dateFormat = Connection.GetDBDateFormat();
string primaryKeyColumn = string.Empty;
object primaryKeyValue = null;
for (int i = 0; i < bindingInfo.Length; i++)
{
BindingInfo bind = bindingInfo[i];
if (bind.ReadOnly)
{
continue;
}
if (!hasRelations)
{
hasRelations = bind.HasRelation;
}
if (!bind.HasRelation)
{
object val = null;
if (bind.Member is PropertyInfo)
{
val = ((PropertyInfo)bind.Member).GetValue(dataObject, null);
}
else if (bind.Member is FieldInfo)
{
val = ((FieldInfo)bind.Member).GetValue(dataObject);
}
else
{
continue;
}
if (!first)
{
sb.Append(", ");
}
else
{
first = false;
}
if (val is bool)
{
val = ((bool)val) ? (byte)1 : (byte)0;
}
else if (val is DateTime)
{
val = ((DateTime)val).ToString(dateFormat);
}
else if (val is float)
{
val = ((float)val).ToString(Nfi);
}
else if (val is double)
{
val = ((double)val).ToString(Nfi);
}
else if (val is string)
{
val = Escape(val.ToString());
}
sb.Append("`" + bind.Member.Name + "` = ");
sb.Append('\'');
sb.Append(val);
sb.Append('\'');
if (bind.UsePrimaryKey)
{
primaryKeyColumn = bind.Member.Name;
primaryKeyValue = val;
}
}
}
if (primaryKeyColumn != string.Empty)
{
sb.Append(" WHERE `" + primaryKeyColumn + "` = '" + primaryKeyValue + "'");
}
else
{
sb.Append(" WHERE `" + tableName + "_ID` = '" + Escape(dataObject.ObjectId) + "'");
}
string sql = sb.ToString();
if (Log.IsDebugEnabled)
{
Log.Debug(sql);
}
int res = Connection.ExecuteNonQuery(sql);
if (res == 0)
{
if (Log.IsErrorEnabled)
{
Log.Error("Error modifying object " + dataObject.TableName + " ID=" + dataObject.ObjectId + " --- keyvalue changed? " + sql + " " + Environment.StackTrace);
}
return(false);
}
if (hasRelations)
{
SaveObjectRelations(dataObject);
}
dataObject.Dirty = false;
dataObject.IsPersisted = true;
return(true);
}
catch (Exception e)
{
if (Log.IsErrorEnabled)
{
Log.Error("Error while saving data object: " + dataObject.ToString(), e);
}
}
return(false);
}
public void update()
{
Connection.ExecuteNonQuery("sp_updateDiadanh @madd , @tendd , @matinh", new object[] { madd, tendd, matinh });
}
/// <summary>
/// Deletes an object from the database.
/// </summary>
/// <param name="dataObject">the object to delete from the database</param>
protected override bool DeleteObjectImpl(DataObject dataObject)
{
try
{
BindingInfo[] bindingInfo = GetBindingInfo(dataObject.GetType());
string primaryKeyColumn = string.Empty;
object primaryKeyValue = null;
for (int i = 0; i < bindingInfo.Length; i++)
{
BindingInfo bind = bindingInfo[i];
object val;
if (bind.Member is PropertyInfo)
{
val = ((PropertyInfo)bind.Member).GetValue(dataObject, null);
}
else if (bind.Member is FieldInfo)
{
val = ((FieldInfo)bind.Member).GetValue(dataObject);
}
else
{
continue;
}
if (bind.UsePrimaryKey)
{
primaryKeyColumn = bind.Member.Name;
primaryKeyValue = val;
}
}
string sql;
if (primaryKeyColumn != string.Empty)
{
sql = "DELETE FROM `" + dataObject.TableName + "` WHERE `" + primaryKeyColumn + "` = '" + Escape(primaryKeyValue.ToString()) + "'";
}
else
{
sql = "DELETE FROM `" + dataObject.TableName + "` WHERE `" + dataObject.TableName + "_ID` = '" + Escape(dataObject.ObjectId) + "'";
}
if (Log.IsDebugEnabled)
{
Log.Debug(sql);
}
int res = Connection.ExecuteNonQuery(sql);
if (res == 0)
{
if (Log.IsErrorEnabled)
{
Log.Error("Deleting " + dataObject.ToString() + " object failed!" + " " + Environment.StackTrace);
}
}
dataObject.IsPersisted = false;
DeleteFromCache(dataObject.TableName, dataObject);
DeleteObjectRelations(dataObject);
dataObject.IsDeleted = true;
return(true);
}
catch (Exception e)
{
throw new DatabaseException("Deleting DataObject " + dataObject.ToString() + " failed !", e);
}
}
public override Lfx.Types.OperationResult Guardar()
{
qGen.IStatement Comando;
if (this.Existe == false)
{
Comando = new qGen.Insert(this.TablaDatos);
Comando.ColumnValues.AddWithValue("fecha_ingreso", new qGen.SqlExpression("NOW()"));
Comando.ColumnValues.AddWithValue("id_sucursal", Lfx.Workspace.Master.CurrentConfig.Empresa.SucursalActual);
}
else
{
Comando = new qGen.Update(this.TablaDatos);
Comando.WhereClause = new qGen.Where(this.CampoId, this.Id);
}
Comando.ColumnValues.AddWithValue("id_persona", this.Cliente.Id);
if (this.Tipo == null)
{
Comando.ColumnValues.AddWithValue("id_tipo_ticket", null);
}
else
{
Comando.ColumnValues.AddWithValue("id_tipo_ticket", this.Tipo.Id);
}
if (this.Encargado == null)
{
Comando.ColumnValues.AddWithValue("id_tecnico_recibe", null);
}
else
{
Comando.ColumnValues.AddWithValue("id_tecnico_recibe", this.Encargado.Id);
}
Comando.ColumnValues.AddWithValue("prioridad", this.Prioridad);
Comando.ColumnValues.AddWithValue("nombre", this.Nombre);
Comando.ColumnValues.AddWithValue("descripcion", this.GetFieldValue <string>("descripcion"));
Comando.ColumnValues.AddWithValue("estado", this.Estado);
Comando.ColumnValues.AddWithValue("articulos_descuento", this.DescuentoArticulos);
Comando.ColumnValues.AddWithValue("entrega_estimada", this.FechaEstimada);
Comando.ColumnValues.AddWithValue("entrega_limite", this.FechaLimite);
Comando.ColumnValues.AddWithValue("presupuesto", this.Importe);
if (this.Presupuesto == null)
{
Comando.ColumnValues.AddWithValue("id_presupuesto", null);
}
else
{
Comando.ColumnValues.AddWithValue("id_presupuesto", this.Presupuesto.Id);
}
if (this.Factura == null)
{
Comando.ColumnValues.AddWithValue("id_comprob", null);
}
else
{
Comando.ColumnValues.AddWithValue("id_comprob", this.Factura.Id);
}
Comando.ColumnValues.AddWithValue("obs", this.Obs);
this.AgregarTags(Comando);
this.Connection.ExecuteNonQuery(Comando);
this.ActualizarId();
if (this.RegistroOriginal != null && this.RegistroOriginal["estado"] != this.Registro["estado"])
{
this.AgregarComentario("Actualización de Estado: " + Lbl.Tareas.EstadoTarea.TodosPorNumero[this.Estado].ToString());
}
if (this.Articulos != null && this.Articulos.HayCambios)
{
qGen.Delete EliminarArticulos = new qGen.Delete("tickets_articulos");
EliminarArticulos.WhereClause = new qGen.Where("id_ticket", this.Id);
this.Connection.ExecuteNonQuery(EliminarArticulos);
int i = 1;
foreach (Lbl.Comprobantes.DetalleArticulo Det in this.Articulos)
{
qGen.Insert InsertarArticulo = new qGen.Insert("tickets_articulos");
InsertarArticulo.ColumnValues.AddWithValue("id_ticket", this.Id);
if (Det.Articulo == null)
{
InsertarArticulo.ColumnValues.AddWithValue("id_articulo", null);
InsertarArticulo.ColumnValues.AddWithValue("nombre", Det.Nombre);
}
else
{
InsertarArticulo.ColumnValues.AddWithValue("id_articulo", Det.Articulo.Id);
InsertarArticulo.ColumnValues.AddWithValue("nombre", Det.Articulo.Nombre);
}
InsertarArticulo.ColumnValues.AddWithValue("orden", i++);
InsertarArticulo.ColumnValues.AddWithValue("cantidad", Det.Cantidad);
InsertarArticulo.ColumnValues.AddWithValue("precio", Det.ImporteUnitario);
InsertarArticulo.ColumnValues.AddWithValue("descuento", Det.Descuento);
Connection.ExecuteNonQuery(InsertarArticulo);
}
}
return(base.Guardar());
}
/// <summary>
/// Adds a new object to the database.
/// </summary>
/// <param name="dataObject">the object to add to the database</param>
/// <returns>true if the object was added successfully; false otherwise</returns>
protected override bool AddObjectImpl(DataObject dataObject)
{
try
{
string tableName = dataObject.TableName;
var columns = new StringBuilder();
var values = new StringBuilder();
MemberInfo[] objMembers = dataObject.GetType().GetMembers();
bool hasRelations = false;
bool usePrimary = false;
object primaryKey = null;
string primaryColumnName = "";
bool firstColumn = true;
string dateFormat = Connection.GetDBDateFormat();
for (int i = 0; i < objMembers.Length; i++)
{
bool isPrimary = false;
if (!hasRelations)
{
object[] relAttrib = GetRelationAttributes(objMembers[i]);
hasRelations = relAttrib.Length > 0;
}
object[] keyAttrib = objMembers[i].GetCustomAttributes(typeof(PrimaryKey), true);
object[] attrib = objMembers[i].GetCustomAttributes(typeof(DataElement), true);
// if a primary key field is using auto increment then use it as the key instead of the tablename_id column
if (keyAttrib.Length > 0 && (keyAttrib[0] as PrimaryKey).AutoIncrement)
{
usePrimary = true;
primaryColumnName = objMembers[i].Name;
isPrimary = true;
}
if (attrib.Length > 0 || keyAttrib.Length > 0)
{
object val = null;
if (objMembers[i] is PropertyInfo)
{
val = ((PropertyInfo)objMembers[i]).GetValue(dataObject, null);
}
else if (objMembers[i] is FieldInfo)
{
val = ((FieldInfo)objMembers[i]).GetValue(dataObject);
}
if (firstColumn == false)
{
columns.Append(", ");
values.Append(", ");
}
columns.Append("`" + objMembers[i].Name + "`");
firstColumn = false;
if (val is bool)
{
val = ((bool)val) ? (byte)1 : (byte)0;
}
else if (val is DateTime)
{
val = ((DateTime)val).ToString(dateFormat);
}
else if (val is float)
{
val = ((float)val).ToString(Nfi);
}
else if (val is double)
{
val = ((double)val).ToString(Nfi);
}
else if (val is string)
{
val = Escape(val.ToString());
}
values.Append('\'');
values.Append(val);
values.Append('\'');
if (isPrimary)
{
if (val is int)
{
primaryKey = Convert.ToInt32(val);
}
else if (val is long)
{
primaryKey = Convert.ToInt64(val);
}
else
{
if (Log.IsErrorEnabled)
{
Log.Error("Error adding object into " + dataObject.TableName + ". PrimaryKey with AutoIncrement must be of type int or long.");
}
return(false);
}
}
}
}
if (usePrimary == false)
{
if (dataObject.ObjectId == null)
{
dataObject.ObjectId = IDGenerator.GenerateID();
}
// Add the silly Tablename_ID column
columns.Insert(0, "`" + tableName + "_ID`, ");
values.Insert(0, "'" + Escape(dataObject.ObjectId) + "', ");
}
string sql = "INSERT INTO `" + tableName + "` (" + columns + ") VALUES (" + values + ")";
if (Log.IsDebugEnabled)
{
Log.Debug(sql);
}
if (usePrimary)
{
object objID = Connection.ExecuteScalar(sql + "; SELECT LAST_INSERT_ID();");
object newID;
bool newIDzero = false;
bool error = false;
if (primaryKey is int)
{
newID = Convert.ToInt32(objID);
newIDzero = (int)newID == 0;
error = newIDzero && (int)primaryKey == 0;
}
else
{
newID = Convert.ToInt64(objID);
newIDzero = (long)newID == 0;
error = newIDzero && (long)primaryKey == 0;
}
if (primaryKey == null || error)
{
if (Log.IsErrorEnabled)
{
Log.Error("Error adding object into " + dataObject.TableName + " ID=" + objID + ", UsePrimary, Query = " + sql);
}
return(false);
}
else
{
if (newIDzero)
{
newID = Convert.ToInt64(primaryKey);
}
for (int i = 0; i < objMembers.Length; i++)
{
if (objMembers[i].Name == primaryColumnName)
{
if (objMembers[i] is PropertyInfo)
{
if (primaryKey is long)
{
((PropertyInfo)objMembers[i]).SetValue(dataObject, (long)newID, null);
}
else
{
((PropertyInfo)objMembers[i]).SetValue(dataObject, (int)newID, null);
}
}
else if (objMembers[i] is FieldInfo)
{
if (primaryKey is long)
{
((FieldInfo)objMembers[i]).SetValue(dataObject, (long)newID);
}
else
{
((FieldInfo)objMembers[i]).SetValue(dataObject, (int)newID);
}
}
break;
}
}
}
}
else
{
int res = Connection.ExecuteNonQuery(sql);
if (res == 0)
{
if (Log.IsErrorEnabled)
{
Log.Error("Error adding object into " + dataObject.TableName + " ID=" + dataObject.ObjectId + "Query = " + sql);
}
return(false);
}
}
if (hasRelations)
{
SaveObjectRelations(dataObject);
}
dataObject.Dirty = false;
dataObject.IsPersisted = true;
dataObject.IsDeleted = false;
return(true);
}
catch (Exception e)
{
if (Log.IsErrorEnabled)
{
Log.Error("Error while adding data object: " + dataObject.ToString(), e);
}
}
return(false);
}
