private Task CreateConnections(IConnectionFactory factory)
{
try
{
ReadConnection = factory.CreateConnection();
WriteConnection = factory.CreateConnection();
}
catch (Exception e)
{
return(Task.FromException(e));
}
PublishChannel = WriteConnection.CreateModel();
PublishChannel.ExchangeDeclare(Group, "direct");
var rpcModel = GetOrCreateChannel("RPC");
RPCQueueName = rpcModel.QueueDeclare().QueueName;
rpcModel.QueueBind(RPCQueueName, Group, RPCQueueName);
RPCConsumer = new EventingBasicConsumer(rpcModel);
rpcModel.BasicConsume(RPCQueueName, AutoAck, RPCConsumer);
return(Task.CompletedTask);
}
public async Task ImportExcel(Queue <DriverVM> listModel)
{
try
{
if (listModel != null && listModel.Count > 0)
{
//Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
//MySqlConnection con = new MySqlConnection("server=192.168.1.208;userid=root;pwd=lyh888150;database=ccp(latest);sslmode=none;");
foreach (var item in listModel)
{
string sql = $"select * from aspnetusers where PhoneNumber={item.PhoneNumber}";
var user = new Aspnetusers();
using (ReadConnection)
{
user = await ReadConnection.QueryFirstOrDefaultAsync <Aspnetusers>(sql);
}
if (user != null)
{
if (user.UserCategory != UserCategory.JFEmployees)
{
user.UserCategory = UserCategory.JFEmployees;
using (WriteConnection)
{
await WriteConnection.UpdateAsync(user);
}
}
}
else
{
var newuser = new Aspnetusers()
{
PhoneNumber = item.PhoneNumber,
UserName = item.PhoneNumber,
CertificatePhotoCertificationState = CertificationStatus.Uncommitted,
DrivingLicenseKeyCertificationState = CertificationStatus.Uncommitted,
IdentityCardCertificationState = CertificationStatus.Uncommitted,
LockoutEnabled = true,
RealNameStatus = CertificationStatus.Uncommitted,
CertificationStatus = CertificationStatus.Uncommitted,
TrailerLicenseCertificationStatus = CertificationStatus.Uncommitted,
VehiclePhotoCertificationStatus = CertificationStatus.Uncommitted,
RoleType = ApplicationRoleType.Driver,
RoadTransportStatus = CertificationStatus.Uncommitted,
Date = DateTime.Now,
UserCategory = UserCategory.JFEmployees
};
using (WriteConnection)
{
await WriteConnection.InsertAsync(newuser);;
}
}
}
}
}
catch (Exception ex)
{
throw ex;
}
}
public void Disconnect()
{
ReadConnection.Dispose();
if (!SingleConnection)
{
WriteConnection.Dispose();
}
}
public override async Task <TPrimaryKey> InsertAndGetIdAsync(TEntity entity)
{
using (WriteConnection)
{
await WriteConnection.InsertAsync(entity);
return(entity.Id);
}
}
public void Connect(string username, string password)
{
ReadConnection.Connect(username, password);
if (!SingleConnection)
{
WriteConnection.Connect(username, password);
}
}
public void Part(string channel)
{
ReadConnection.WriteLine("PART " + channel);
if (!SingleConnection)
{
WriteConnection.WriteLine("PART " + channel);
}
}
public void Reconnect()
{
ReadConnection.Reconnect();
if (!SingleConnection)
{
WriteConnection.Reconnect();
}
}
public void Join(string channel)
{
ReadConnection.WriteLine("JOIN " + channel);
if (!SingleConnection)
{
WriteConnection.WriteLine("JOIN " + channel);
}
}
public async Task <UserDO> GetById(int id)
{
using (WriteConnection)
{
var result = await WriteConnection.GetAsync <UserDO>(id);
return(result);
}
}
public override async Task <TEntity> InsertAsync(TEntity entity)
{
using (WriteConnection)
{
await WriteConnection.InsertAsync(entity);
return(entity);
}
}
public NotGate(SimulationEngine engine, int bitWidth)
: base(engine)
{
this.DataBitWidth = bitWidth;
this.In = new ReadConnection(bitWidth);
this.In.DataValueChanged += this.OnInputDataValueChanged;
this.Out = new WriteConnection(bitWidth);
}
public void Initialize(IUserManager userManager, SemaphoreSlim dbLock, SQLiteDatabaseConnection dbConnection)
{
WriteLock.Dispose();
WriteLock = dbLock;
WriteConnection?.Dispose();
WriteConnection = dbConnection;
using (var connection = GetConnection())
{
var userDatasTableExists = TableExists(connection, "UserDatas");
var userDataTableExists = TableExists(connection, "userdata");
var users = userDatasTableExists ? null : userManager.Users;
connection.RunInTransaction(
db =>
{
db.ExecuteAll(string.Join(';', new[]
{
"create table if not exists UserDatas (key nvarchar not null, userId INT not null, rating float null, played bit not null, playCount int not null, isFavorite bit not null, playbackPositionTicks bigint not null, lastPlayedDate datetime null, AudioStreamIndex INT, SubtitleStreamIndex INT)",
"drop index if exists idx_userdata",
"drop index if exists idx_userdata1",
"drop index if exists idx_userdata2",
"drop index if exists userdataindex1",
"drop index if exists userdataindex",
"drop index if exists userdataindex3",
"drop index if exists userdataindex4",
"create unique index if not exists UserDatasIndex1 on UserDatas (key, userId)",
"create index if not exists UserDatasIndex2 on UserDatas (key, userId, played)",
"create index if not exists UserDatasIndex3 on UserDatas (key, userId, playbackPositionTicks)",
"create index if not exists UserDatasIndex4 on UserDatas (key, userId, isFavorite)"
}));
if (userDataTableExists)
{
var existingColumnNames = GetColumnNames(db, "userdata");
AddColumn(db, "userdata", "InternalUserId", "int", existingColumnNames);
AddColumn(db, "userdata", "AudioStreamIndex", "int", existingColumnNames);
AddColumn(db, "userdata", "SubtitleStreamIndex", "int", existingColumnNames);
if (!userDatasTableExists)
{
ImportUserIds(db, users);
db.ExecuteAll("INSERT INTO UserDatas (key, userId, rating, played, playCount, isFavorite, playbackPositionTicks, lastPlayedDate, AudioStreamIndex, SubtitleStreamIndex) SELECT key, InternalUserId, rating, played, playCount, isFavorite, playbackPositionTicks, lastPlayedDate, AudioStreamIndex, SubtitleStreamIndex from userdata where InternalUserId not null");
}
}
},
TransactionMode);
}
}
public ControlledBuffer(SimulationEngine engine, int bitWidth)
: base(engine)
{
this.DataBitWidth = bitWidth;
this.In = new ReadConnection(bitWidth);
this.In.DataValueChanged += this.OnInputDataValueChanged;
this.Enabled = new ReadConnection(1);
this.Enabled.DataValueChanged += this.OnInputDataValueChanged;
this.Out = new WriteConnection(bitWidth);
}
public void Dispose()
{
if (IsUseRead)
{
ReadConnection.Dispose();
}
if (IsUseWrite)
{
WriteConnection.Dispose();
}
IsUseWrite = false;
IsUseRead = false;
}
/// <summary>
/// Disconnect disconnects the Client from the Amqp Server.
/// </summary>
/// <param name="code">The status code of the disconnect.</param>
/// <param name="text">The status text of the disconnect.</param>
public void Disconnect(ushort code, string text)
{
lock (PublishChannel)
{
PublishChannel.Close(code, text);
}
foreach (var value in SubscribeChannels.Values)
{
value.Close();
}
WriteConnection.Close(code, text);
ReadConnection.Close(code, text);
}
public async Task <ReturnValue> CreateAsync(UserInfo user)
{
using (WriteConnection)
{
var result = await WriteConnection.InsertAsync(user);
if (result >= 0)
{
return(await Task.FromResult(new ReturnValue { IsSuccess = true }));
}
else
{
throw new Exception(ExceptionCode.EC103);
}
}
}
public override async Task <TEntity> UpdateAsync(TEntity entity)
{
using (WriteConnection)
{
var count = await WriteConnection.UpdateAsync(entity);
if (count > 0)
{
return(entity);
}
else
{
return(null);
}
}
}
protected LogicGate(SimulationEngine engine, int numberOfInputs, int bitWidth)
: base(engine)
{
this.NumberOfInputs = numberOfInputs;
this.DataBitWidth = bitWidth;
this.In = new ReadConnection[this.NumberOfInputs];
this.InvertInput = new bool[this.NumberOfInputs];
for (var i = 0; i < this.NumberOfInputs; i++)
{
this.In[i] = new ReadConnection(this.DataBitWidth);
this.In[i].DataValueChanged += this.OnInputDataValueChanged;
this.InvertInput[i] = false;
}
this.Out = new WriteConnection(this.DataBitWidth);
}
public bool Say(string message, string channel, bool isMod)
{
if (lastMessagesMod.Count < (isMod ? 99 : 19))
{
if (message.StartsWith(".color"))
{
WriteConnection.WriteLine("PRIVMSG #" + channel + " :" + message);
return(true);
}
}
lock (lastMessagesLock)
{
while (lastMessagesMod.Count > 0 && lastMessagesMod.Peek() < DateTime.Now)
{
lastMessagesMod.Dequeue();
}
while (lastMessagesPleb.Count > 0 && lastMessagesPleb.Peek() < DateTime.Now)
{
lastMessagesPleb.Dequeue();
}
if (lastMessagesMod.Count < (isMod ? 99 : 19))
{
WriteConnection.WriteLine("PRIVMSG #" + channel + " :" + message);
lastMessagesMod.Enqueue(DateTime.Now + TimeSpan.FromSeconds(32));
lastMessagesPleb.Enqueue(DateTime.Now + TimeSpan.FromSeconds(32));
}
else
{
return(false);
}
}
return(true);
}
public void WriteLine(string value)
{
WriteConnection.WriteLine(value);
}
public Task <T> ExecuteScalarAsync <T>(CommandDefinition command)
{
return(WriteConnection.ExecuteScalarAsync <T>(command));
}
public Task <T> ExecuteScalarAsync <T>(string sql, object param = null, IDbTransaction transaction = null, int?commandTimeout = default(int?), CommandType?commandType = default(CommandType?))
{
return(WriteConnection.ExecuteScalarAsync <T>(sql, param, transaction, commandTimeout, commandType));
}
public IDbTransaction BeginTransaction()
{
return(WriteConnection.BeginTransaction());
}
public IDbTransaction BeginTransaction(IsolationLevel il)
{
return(WriteConnection.BeginTransaction(il));
}
public int Execute(CommandDefinition command)
{
return(WriteConnection.Execute(command));
}
public Task <int> ExecuteAsync(CommandDefinition command)
{
return(WriteConnection.ExecuteAsync(command));
}
public IDataReader ExecuteReader(CommandDefinition command, CommandBehavior commandBehavior)
{
return(WriteConnection.ExecuteReader(command, commandBehavior));
}
public IDataReader ExecuteReader(string sql, object param = null, IDbTransaction transaction = null, int?commandTimeout = default(int?), CommandType?commandType = default(CommandType?))
{
return(WriteConnection.ExecuteReader(sql, param, transaction, commandTimeout, commandType));
}
public InputPin(SimulationEngine engine, int dataBitWidth)
: base(engine)
{
this.DataBitWidth = dataBitWidth;
this.Out = new WriteConnection(this.DataBitWidth);
}
public T ExecuteScalar <T>(CommandDefinition command)
{
return(WriteConnection.ExecuteScalar <T>(command));
}
