/// <summary>
/// Method to delete a Namespace.
/// </summary>
/// <param name="ns">Namespace to delete.</param>
/// <param name="connectionString">Database Connectionstring to use for this namespace.</param>
public void DeleteNamespace(string ns)
{
DatabaseParameter[] parameters = new DatabaseParameter[1];
parameters[0] = new DatabaseParameter("namespace", ns);
_database.ExecuteNonQuery(CommandType.StoredProcedure, "DeleteNamespace", parameters);
}
public void getDatabase(int id)
{
string resp = "";
try
{
connectModel();
DatabaseParameter database = systemConfigurationModel.getDatabase(id);
database.Ip = encryptor.decryptData(database.Ip);
database.Port = (database.Port != null) ? encryptor.decryptData(database.Port) : null;
database.Instance = (database.Instance != null) ? encryptor.decryptData(database.Instance) : null;
database.Name = encryptor.decryptData(database.Name);
database.Username = encryptor.decryptData(database.Username);
database.Password = encryptor.decryptData(database.Password);
resp = serializeObject(database);
}
catch (Exception)
{
resp = "{\"type\":\"danger\", \"message\":\"Can not be loaded the database. Please try again.\"}";
}
response(resp);
}
/// <summary>
/// Delete a specified topic.
/// </summary>
/// <param name="ns">Namespace of the topic.</param>
/// <param name="topicName">Name of the topic being deleted.</param>
/// <param name="connectionString">Database Connectionstring to use for this namespace.</param>
public void DeleteTopic(string ns, string topicName)
{
DatabaseParameter[] parameters = new DatabaseParameter[2];
parameters[0] = new DatabaseParameter("namespace", ns);
parameters[1] = new DatabaseParameter("topicName", topicName);
_database.ExecuteNonQuery(CommandType.StoredProcedure, "DeleteTopic", parameters);
}
public static ParameterBase ParameterBase(DatabaseParameter parameterMetadata)
{
return(new ParameterBase()
{
Name = parameterMetadata.Name,
Type = TypeBase(parameterMetadata.Type)
});
}
public DatabaseParameterLink AppendCollection(DatabaseParameter parameter,
DatabaseParameterRelation relation = DatabaseParameterRelation.AND)
{
var link = new DatabaseParameterLinkCollection(parameter, relation);
Next = link;
return(link.Content);
}
private Objects.Database GenerateDatabase(DatabaseParameter param)
{
var db = new Objects.Database();
db.ConnectionString = param.ConnectionString;
db.InitializeDatabase();
db.DatabaseToSchema();
return(db);
}
public DatabaseParameterLinkCollection(DatabaseParameter parameter,
DatabaseParameterRelation relation = DatabaseParameterRelation.AND)
{
var link = new DatabaseParameterLink()
{
Parameter = parameter
};
Releation = relation;
Content = link;
}
private static Rubik.Database.Tools.DatabaseParameter GetParameters()
{
if (!File.Exists(_iniFilePath))
{
string answer = AskQuestion(" > Ayar Dosyası Bulunamadı ! Otomatik Oluşturulsunmu ?<E,H>");
bool correct = false;
//Gereksiz düzelt
if (answer.ToUpper() == "EVET" || answer.ToUpper() == "HAYIR" || answer.ToUpper() == "E" || answer.ToUpper() == "H")
{
correct = true;
}
else
{
correct = false;
}
while (!correct)
{
answer = AskQuestion("\r > Seçenek Tanımlanamadı Geçerli Seçenekler <E,H>");
if (answer.ToUpper() == "EVET" || answer.ToUpper() == "HAYIR" || answer.ToUpper() == "E" || answer.ToUpper() == "H")
{
correct = true;
}
else
{
correct = false;
}
}
if (correct)
{
WriteDefaultSettings();
Console.WriteLine("\r > Varsayılan ayarlar kaydedildi.Lütfen settings.ini dosyasından veritabanı ayarlarını düzenleyin");
}
return(null);
}
else
{
DatabaseParameter param = new DatabaseParameter()
{
CreateTable = Convert.ToBoolean(ini.ReadValue("ExportParameters", "CreateTable", "True")),
DropTable = Convert.ToBoolean(ini.ReadValue("ExportParameters", "DropTable", "False")),
ExportColumns = Convert.ToBoolean(ini.ReadValue("ExportParameters", "ExportColumns", "True")),
ExportData = Convert.ToBoolean(ini.ReadValue("ExportParameters", "ExportData", "False")),
ExportIndexes = Convert.ToBoolean(ini.ReadValue("ExportParameters", "ExportIndexes", "True")),
ExportKeys = Convert.ToBoolean(ini.ReadValue("ExportParameters", "ExportKeys", "True")),
AutoSave = Convert.ToBoolean(ini.ReadValue("ExportParameters", "AutoSave", "True")),
FilePath = ini.ReadValue("ExportParameters", "FilePath", ""),
ConnectionString = GetConnectionString("")
};
return(param);
}
}
public DatabaseParameterLink Append(DatabaseParameter parameter, DatabaseParameterRelation relation = DatabaseParameterRelation.AND)
{
var link = new DatabaseParameterLink()
{
Parameter = parameter,
Releation = relation
};
Next = link;
return(link);
}
private static void Execute()
{
DatabaseParameter param = GetParameters();
if (param == null)
{
return;
}
string[] multipleUser = ini.ReadValue("Database", "User").Split(',');
if (multipleUser.Count() > 1)
{
foreach (var item in multipleUser)
{
param.ConnectionString = GetConnectionString(item);
var export = new Export(param);
export.Execute();
}
}
else
{
try
{
var db = new Objects.Database();
db.ConnectionString = param.ConnectionString;
db.InitializeDatabase();
db.DatabaseToSchema();
BinaryFormatter formatter = new BinaryFormatter();
FileStream fs = new FileStream(Path.Combine(Application.StartupPath, "Schema.bdb"), FileMode.OpenOrCreate, FileAccess.ReadWrite);
formatter.Serialize(fs, db);
fs.Flush();
fs.Close();
}
catch (Exception)
{
}
}
//Rubik.Database.Tools.Export export = new Export(param);
//export.Execute();
//}
}
public bool Remove(DatabaseParameter item)
{
bool result = false;
DatabaseParameter obj;
for (int i = 0; i < _innerList.Count; i++)
{
obj = new DatabaseParameter();
obj = (DatabaseParameter)_innerList[i];
if (obj.ParameterName == item.ParameterName && obj.DataType == item.DataType)
{
_innerList.RemoveAt(i);
result = true;
break;
}
obj = null;
}
return(result);
}
internal static DatabaseParameter[] ExtractDatabaseParameter(object o)
{
if (o == null)
{
return(Array.Empty <DatabaseParameter>());
}
var properties = o.GetType().GetProperties();
var param = new DatabaseParameter[properties.Length];
for (var idx = 0; idx < properties.Length; idx++)
{
var property = properties[idx];
var name = property.Name;
var value = property.GetValue(o);
var parameter = new DatabaseParameter(name, value);
param[idx] = parameter;
}
return(param);
}
/// <inheritdoc />
public IEnumerable <T> List(T filterObject)
{
string procedureName;
if (filterObject == null)
{
filterObject = new T();
}
if (_defaultObject.Mappings.ContainsKey(Command.Select))
{
procedureName = _defaultObject.Mappings[Command.Select];
}
else
{
return(new List <T>());
}
using (var dbContext = _dbContext.Create())
{
var parametersToCreate = ReflectionHelper.GetSelectParameters <T>().ToList();
var parameters = new List <DatabaseParameter>();
foreach (var parameter in parametersToCreate)
{
var selectParamValue = parameter.GetValue(filterObject);
var selectParamAttribute = parameter.GetCustomAttributes(true).FirstOrDefault(x => x.GetType() == typeof(SelectParameterAttribute)) as SelectParameterAttribute;
if (selectParamAttribute == null || selectParamValue == null)
{
continue;
}
var dbParam = DatabaseParameter.CreateInParam(selectParamAttribute.ParamName, selectParamAttribute.Type, selectParamValue);
parameters.Add(dbParam);
}
return(dbContext.ExecuteDataTable(procedureName, parameters).ToList <T>());
}
}
/// <inheritdoc />
public bool Delete(T entity)
{
string procedureName;
if (_defaultObject.Mappings.ContainsKey(Command.Delete))
{
procedureName = _defaultObject.Mappings[Command.Delete];
}
else
{
return(false);
}
using (var dbContext = _dbContext.Create())
{
var parametersToCreate = ReflectionHelper.GetDeleteParameters <T>().ToList();
var parameters = new List <DatabaseParameter>();
foreach (var parameter in parametersToCreate)
{
var deleteParamValue = parameter.GetValue(entity);
var deleteParamAttribute = parameter.GetCustomAttributes(true).FirstOrDefault(x => x.GetType() == typeof(DeleteParameterAttribute)) as DeleteParameterAttribute;
if (deleteParamAttribute == null || deleteParamValue == null)
{
continue;
}
var dbParam = DatabaseParameter.CreateInParam(deleteParamAttribute.ParamName, deleteParamAttribute.Type, deleteParamValue);
parameters.Add(dbParam);
}
dbContext.ExecuteNonQuery(procedureName, parameters);
return(true);
}
}
/// <inheritdoc />
public void Add(T entity)
{
string procedureName;
if (_defaultObject.Mappings.ContainsKey(Command.Insert))
{
procedureName = _defaultObject.Mappings[Command.Insert];
}
else
{
return;
}
using (var dbContext = _dbContext.Create())
{
var parametersToCreate = ReflectionHelper.GetInsertParameters <T>().ToList();
var parameters = new List <DatabaseParameter>();
foreach (var parameter in parametersToCreate)
{
var insertParamValue = parameter.GetValue(entity);
var insertParamAttribute = parameter.GetCustomAttributes(true).FirstOrDefault(x => x.GetType() == typeof(InsertParameterAttribute)) as InsertParameterAttribute;
if (insertParamAttribute == null || insertParamValue == null)
{
continue;
}
var dbParam = DatabaseParameter.CreateInParam(insertParamAttribute.ParamName, insertParamAttribute.Type, insertParamValue);
parameters.Add(dbParam);
}
var id = (T1)Convert.ChangeType(dbContext.ExecuteScalar(procedureName, parameters), typeof(T1));
entity.Id = id;
}
}
public int IndexOf(DatabaseParameter item)
{
return(_innerList.IndexOf(item));
}
/// <summary>
/// Store the specified topic in the database.
/// </summary>
/// <param name="ns">Namespace of the topic.</param>
/// <param name="topicName">Name of the topic being saved.</param>
/// <param name="lastWriteTime">The write time for the topic.</param>
/// <param name="connectionString">Database Connectionstring to use for this namespace.</param>
/// <param name="body">The contents of the topic being saved.</param>
/// <param name="archive">Indicates if this is the archive record for the topic being saved.</param>
public void WriteTopic(string ns, string topicName, DateTime lastWriteTime, string body, bool archive)
{
DatabaseParameter[] parameters = new DatabaseParameter[5];
parameters[0] = new DatabaseParameter("namespace", ns);
parameters[1] = new DatabaseParameter("topicName", topicName);
parameters[2] = new DatabaseParameter("body", body);
parameters[3] = new DatabaseParameter("archive", archive);
parameters[4] = new DatabaseParameter("lastWriteTime", lastWriteTime);
_database.ExecuteNonQuery(CommandType.StoredProcedure, "WriteTopic", parameters);
}
/// <summary>
/// Check if the Topic Exists in the namespace.
/// </summary>
/// <param name="ns">Namespace of the topic.</param>
/// <param name="topicName">Name of the topic.</param>
/// <param name="connectionString">Database Connectionstring to use for this namespace.</param>
/// <returns>Boolean value that indicates if the topic exists.</returns>
public bool TopicExists(string ns, string topicName)
{
DatabaseParameter[] parameters = new DatabaseParameter[3];
parameters[0] = new DatabaseParameter("namespace", ns);
parameters[1] = new DatabaseParameter("topicName", topicName);
parameters[2] = new DatabaseParameter("topicExists", SqlDbType.Bit);
parameters[2].Direction = ParameterDirection.Output;
_database.ExecuteScalar(CommandType.StoredProcedure, "CheckTopicExists", parameters);
return BooleanConvert(parameters[2].Value.ToString());
}
/// <summary>
/// Get the time when the topic was last updated.
/// </summary>
/// <param name="ns">Namespace of the topic.</param>
/// <param name="topicName">Name of the Topic.</param>
/// <param name="connectionString">Database Connectionstring to use for this namespace.</param>
/// <returns>Last Update Time for the topic.</returns>
public DateTime GetTopicLastWriteTime(string ns, string topicName)
{
DatabaseParameter[] parameters = new DatabaseParameter[3];
parameters[0] = new DatabaseParameter("namespace", ns);
parameters[1] = new DatabaseParameter("topicName", topicName);
parameters[2] = new DatabaseParameter("topicLastWriteTime", SqlDbType.DateTime);
parameters[2].Direction = ParameterDirection.Output;
_database.ExecuteScalar(CommandType.StoredProcedure, "GetTopicLastWriteTime", parameters);
return (DateTime)parameters[2].Value;
}
/// <summary>
/// Get the contents of the topic.
/// </summary>
/// <param name="ns">Namespace of the topic.</param>
/// <param name="topicName">Name of the topic to fetch the topic body.</param>
/// <param name="connectionString">Database Connectionstring to use for this namespace.</param>
/// <returns>Returns the topic contents</returns>
public string GetTopicBody(string ns, string topicName)
{
DatabaseParameter[] parameters = new DatabaseParameter[2];
parameters[0] = new DatabaseParameter("namespace", ns);
parameters[1] = new DatabaseParameter("topicName", topicName);
return _database.ExecuteScalar(CommandType.StoredProcedure, "GetTopicBody", parameters) as string;
}
private void CopyOutputParameter(SqlParameter sqlParameter, DatabaseParameter databaseParameter)
{
if (sqlParameter.Direction != ParameterDirection.Input)
{
databaseParameter.Value = sqlParameter.Value;
}
}
public int Add(string parametername, object value, ParameterDirection parameterdirection, SqlDbType datatype)
{
DatabaseParameter item = new DatabaseParameter(parametername, value, parameterdirection, datatype);
return(_innerList.Add(item));
}
/// <summary>
/// Get all the non archive topics in the specified namespace.
/// </summary>
/// <param name="ns">Namespace of the topic.</param>
/// <param name="sort">Boolean value to indicate if the topics need to be sorted in the
/// descending order based on last write time.</param>
/// <param name="connectionString">Database Connectionstring to use for this namespace.</param>
/// <returns>Array of SqlTopicInfo containing the information for all non archive topics in the namespace.</returns>
public SqlInfoForTopic[] GetSqlTopicInfoForNonArchiveTopics(string ns, bool sort)
{
ArrayList topicInfos = new ArrayList();
DatabaseParameter[] parameters = new DatabaseParameter[1];
parameters[0] = new DatabaseParameter("namespace", ns);
string storedProcedureName = "GetSqlTopicInfoForNonArchiveTopics";
if (sort)
{
// To benefit from Sql compiled stored procedure cache using 2 different
// stored procedures instead of passing the sort value thru to Sql.
storedProcedureName = "GetSqlTopicInfoForNonArchiveTopicsSortedDescending";
}
_database.ExecuteReader(CommandType.StoredProcedure,
storedProcedureName,
delegate(IDataReader reader)
{
while (reader.Read())
{
SqlInfoForTopic topicInfo = new SqlInfoForTopic(reader.GetString(0), reader.GetDateTime(1));
topicInfos.Add(topicInfo);
}
},
parameters);
return (SqlInfoForTopic[])topicInfos.ToArray(typeof(SqlInfoForTopic));
}
public void Add(DatabaseParameter item)
{
_innerList.Add(item);
}
public DbParameter[] ConvertParameter(DatabaseParameter[] parameters)
{
int len = parameters.Length;
DbParameter[] paras = new DbParameter[len];
DbParameter p1 = null;
int i = 0;
foreach (DatabaseParameter p in parameters)
{
if (p.ProviderName == DatabaseProviders.SqlProvider)
p1 = new SqlParameter();
else// if (p.ProviderName == DatabaseProviders.OracleProvider)
p1 = new OracleParameter();
p1.DbType = p.DbType;
p1.Direction = p.Direction;
p1.ParameterName = p.ParameterName;
if (p.Size != 0)
p1.Size = p.Size;
p1.SourceColumn = p.SourceColumn;
p1.SourceColumnNullMapping = p.SourceColumnNullMapping;
p.SourceVersion = DataRowVersion.Current;
p1.SourceVersion = p.SourceVersion;
p1.Value = p.Value;
paras[i] = p1;
i++;
}
return paras;
}
private SqlParameter CreateParameter(DatabaseParameter parameter)
{
SqlParameter sqlParameter = new SqlParameter();
sqlParameter.Direction = parameter.Direction;
sqlParameter.ParameterName = "@" + parameter.Name;
sqlParameter.Value = parameter.Value;
return sqlParameter;
}
public bool Contains(DatabaseParameter item)
{
return(_innerList.Contains(item));
}
/// <summary>
/// Gets all versions for the specified topic.
/// </summary>
/// <param name="ns">Namespace of the topic.</param>
/// <param name="topicName">Name of the topic to fetch the archive topics.</param>
/// <param name="connectionString">Database Connectionstring to use for this namespace.</param>
/// <returns>Array of SqlTopicInfo for all the archive versions of the specified topic.</returns>
public SqlInfoForTopic[] GetSqlTopicInfosForTopic(string ns, string topicName)
{
ArrayList topicInfos = new ArrayList();
DatabaseParameter[] parameters = new DatabaseParameter[2];
parameters[0] = new DatabaseParameter("namespace", ns);
parameters[1] = new DatabaseParameter("topicName", topicName + "(%)"); // pattern for sql wild card search
_database.ExecuteReader(CommandType.StoredProcedure,
"GetSqlTopicArchiveInfos",
delegate (IDataReader reader)
{
while (reader.Read())
{
SqlInfoForTopic topicInfo = new SqlInfoForTopic(reader.GetString(0), reader.GetDateTime(1));
topicInfos.Add(topicInfo);
}
},
parameters);
return (SqlInfoForTopic[])topicInfos.ToArray(typeof(SqlInfoForTopic));
}
/// <summary>
/// Get the latest version for the specified topic.
/// </summary>
/// <param name="ns">Namespace of the topic.</param>
/// <param name="topicName">Name of the topic.</param>
/// <param name="connectionString">Database Connectionstring to use for this namespace.</param>
/// <returns>SqlTopicInfo containing the topic information.</returns>
public SqlInfoForTopic GetSqlTopicInfoForLatestTopicVersion(string ns, string topicName)
{
SqlInfoForTopic topicInfo = null;
DatabaseParameter[] parameters = new DatabaseParameter[2];
parameters[0] = new DatabaseParameter("namespace", ns);
parameters[1] = new DatabaseParameter("topicName", topicName + "(%)"); // pattern for sql wild card search
_database.ExecuteReader(CommandType.StoredProcedure,
"GetSqlTopicInfoForLatestVersion",
delegate(IDataReader reader)
{
while (reader.Read())
{
topicInfo = new SqlInfoForTopic(reader.GetString(0), reader.GetDateTime(1));
}
},
parameters);
return topicInfo;
}
/// <summary>
/// Gets all versions for the specified topic since the specified date and including the
/// specified date.
/// </summary>
/// <param name="ns">Namespace of the topic.</param>
/// <param name="topicName">Name of the topic to fetch the archive topics.</param>
/// <param name="stamp">Datetime indicating the lower bound for topic last write time.</param>
/// <param name="connectionString">Database Connectionstring to use for this namespace.</param>
/// <returns>Array of SqlTopicInfo for all the archive versions of the specified topic.</returns>
public SqlInfoForTopic[] GetSqlTopicInfosForTopicSince(string ns, string topicName, DateTime stamp)
{
ArrayList topicInfos = new ArrayList();
DatabaseParameter[] parameters = new DatabaseParameter[3];
parameters[0] = new DatabaseParameter("namespace", ns);
parameters[1] = new DatabaseParameter("topicName", topicName + "(%)"); // pattern for sql wild card search
// Sql allow only dates between January 1, 1753 through December 31, 9999
if (stamp.Year > 1800)
{
parameters[2] = new DatabaseParameter("stamp", stamp);
}
else
{
parameters[2] = new DatabaseParameter("stamp", new DateTime(1800, 1, 1));
}
_database.ExecuteReader(CommandType.StoredProcedure,
"GetSqlTopicArchiveInfosSince",
delegate(IDataReader reader)
{
while (reader.Read())
{
SqlInfoForTopic topicInfo = new SqlInfoForTopic(reader.GetString(0), reader.GetDateTime(1));
topicInfos.Add(topicInfo);
}
},
parameters);
return (SqlInfoForTopic[])topicInfos.ToArray(typeof(SqlInfoForTopic));
}
public DatabaseParameterLink(DatabaseParameter parameter)
{
this.Parameter = parameter;
}
protected DatabaseParameter[] ConvertParameter(DbParameter[] parameters)
{
int len = parameters.Length;
DatabaseParameter[] paras = new DatabaseParameter[len];
//DatabaseParameter p = null;
DatabaseParameter p1 = null;
int i = 0;
foreach (DbParameter p in parameters)
{
p1 = new DatabaseParameter();
if (p is SqlParameter)
p1.ProviderName = DatabaseProviders.SqlProvider;
p1.DbType = p.DbType;
p1.Direction = p.Direction;
p1.ParameterName = p.ParameterName;
p1.Size = p.Size;
p1.SourceColumn = p.SourceColumn;
p1.SourceColumnNullMapping = p.SourceColumnNullMapping;
p1.SourceVersion = p.SourceVersion;
p1.Value = p.Value;
paras[i] = p1;
i++;
Log.Dac("ConvertParameter:" + p1.ToKeyString());
}
return paras;
}
