public void DownloadJson(ConnectionEntity connectionEntity, string filepath)
{
if (!Directory.Exists(filepath))
{
Directory.CreateDirectory(filepath);
}
var typePart = connectionEntity.ToString().ToLower();
var uri = new Uri(_baseUri + "/" + typePart + ".json");
string fileName = filepath + "\\" + typePart + ".json";
WebClient client = new WebClient();
using (StreamReader reader = new StreamReader(new MemoryStream(client.DownloadData(uri))))
{
var content = reader.ReadToEnd();
JArray jsonArray = JArray.Parse(content);
using (StreamWriter writer = new StreamWriter(File.Create(fileName)))
{
foreach (var item in jsonArray.Children())
{
writer.WriteLine(item.ToString(Newtonsoft.Json.Formatting.None));
}
}
}
}
protected override void OnCancel()
{
Current.Name = signOld.Name1;
Current.Parent = signOld.Parent;
Current.Width = signOld.Width;
Current.Height = signOld.Height;
Current.SignInfomation = signOld.SignInfomation;
if (Current.DashboardType != DashboardType.Sign)
{
Current.SignInfomation = Current.Height.ToString() + " x " + Current.Width.ToString();
}
//Current.SignInfomation = Current.Name + " : " + Current.Height.ToString() + " x " + Current.Width.ToString() + " : " + Current.Type.ToString();
Current.Template.Sign.Height = signOld.Height;
Current.Template.Sign.Width = signOld.Width;
IsRefresh = true;
DataGate.Update();
if (connStatus != null)
{
if (connStatus.Connection != null)
{
connStatus.Connection.Cancel();
}
else if (connStatus.Login != null)
{
connStatus.Login.Cancel();
}
connStatus = null;
}
}
public async Task DeleteConnectionAsync(string teamId)
{
var table = GetTableReference();
var entity = ConnectionEntity.FromId(teamId);
var operation = TableOperation.Delete(entity);
await table.ExecuteAsync(operation);
}
public async Task SaveConnectionAsync(ConnectionModel model)
{
var table = GetTableReference();
var entity = ConnectionEntity.FromModel(model);
var operation = TableOperation.InsertOrReplace(entity);
await table.ExecuteAsync(operation);
}
public List <TableEntity> GetAllTableSchema(string ConnectionString, string ProviderName)
{
var config = new ConnectionEntity();
config.ConnectionString = ConnectionString;
config.ProviderName = ProviderName;
using (DbContext db = new DbContext(config))
{
this.OnNotify("Loading tables....");
var _tables = db.GetTables().OrderBy(P => P.Table_Name).ToList();
this.OnNotify("Loading completed....");
this.OnNotify("Loading all columns....");
var _columns = db.GetColumns(_tables.Select(p => p.Table_Name).ToArray());
this.OnNotify("Loading completed....");
foreach (var item in _tables)
{
item.Object_id = _columns.FirstOrDefault(p => p.Table == item.Table_Name).Object_id;
var columns = _columns.Where(p => p.Table == item.Table_Name);
item.Columns = new BindingList <ColumnEntity>(
columns.ToList());
}
return(_tables);
}
}
/// <summary>
/// 获取当前项目的数据库连接对象
/// </summary>
/// <returns></returns>
public static ConnectionEntity GetProjectConnection()
{
if (Connection != null && Connection.ID > 0)
{
if (!string.IsNullOrEmpty(ConnectionString))
{
Connection.ConnectionString = ConnectionString;
}
return(Connection);
}
ProjectEntity project = GetCurrentProject();
ConnectionEntity entity = new ConnectionEntity();
if (project.ConnectionID > 0)
{
CodeBuilderService service = ServiceHelper.GetCodeBuilderService();
entity = service.GetConnectionById(project.ConnectionID.ToString());
//填充当前的链接字符
if (!string.IsNullOrEmpty(ConnectionString))
{
entity.ConnectionString = ConnectionString;
}
}
return(entity);
}
private void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
{
var checks = e.Argument as List <string>;
ProjectEntity project = Global.GetCurrentProject();
ConnectionEntity connection = Global.GetProjectConnection();
DbModelReader modelReader = new DbModelReader(project, connection);
int i = 0;
foreach (string tableName in checks)
{
i++;
this.backgroundWorker.ReportProgress(i);
try
{
var table = modelReader.FillTable(tableName);
if (table != null && table.ID > 0)
{
SuccessCount++;
}
}
catch (Exception ex) {
modelReader.Error.AppendLine("读取数据表—" + tableName + "出错！" + ex.Message);
}
}
if (modelReader.Error.Length > 0)
{
Utils.ShowErrorDialog(modelReader.Error.ToString());
}
}
public async Task HandleClient(CancellationToken cancellationToken, Client client)
{
ConnectionEntity connection = await connectionService.NewConnection((IPEndPoint)client.TcpClient.Client.RemoteEndPoint);
try
{
await using INetworkStreamWrapper networkStream = new NetworkStreamWrapper(client.TcpClient.GetStream());
await streamHandler.HandleStream(cancellationToken, client, networkStream);
networkStream.Close();
}
catch (Exception exception)
{
logger.LogCritical(exception, $"{client.Protocol}");
}
finally
{
logger.LogDebug($"{client.Protocol}: disconnected {client.TcpClient.Client.RemoteEndPoint}");
client.TcpClient.Close();
await connectionService.MarkConnectionAsClosed(connection);
}
}
public void UpdateSchema(TableEntity _table, bool iswithoutdesc, bool isoriginal
, ConnectionEntity _config, Func <Delegate, object> WinUIthread)
{
using (DbContext db = new DbContext(_config))
{
this.OnNotify("Get column data....");
List <ColumnEntity> columns;
if (isoriginal)
{
columns = db.GetColumns(Object_id: new int[] { _table.Object_id });
}
else
{
columns = db.GetColumns(TableNames: new string[] { _table.Table_Name });
}
if (columns.Count > 0)
{
this.OnNotify("Begin compare data....");
var t = columns.First();
if (_table.Table_Name != t.Table)
{
_table.Table_Name = t.Table;
}
this.ModifiyTableSchema(columns, _table, WinUIthread, isoriginal, iswithoutdesc);
this.OnNotify("Complete.");
}
else
{
this.OnNotify("Not find table please try again.");
}
}
}
public void DownloadJson(ConnectionEntity connectionEntity, string filepath)
{
if (!Directory.Exists(filepath))
Directory.CreateDirectory(filepath);
var typePart = connectionEntity.ToString().ToLower();
var uri = new Uri(_baseUri + "/" + typePart + ".json");
string fileName = filepath + "\\" + typePart + ".json";
WebClient client = new WebClient();
using (StreamReader reader = new StreamReader(new MemoryStream(client.DownloadData(uri))))
{
var content = reader.ReadToEnd();
JArray jsonArray = JArray.Parse(content);
using (StreamWriter writer = new StreamWriter(File.Create(fileName)))
{
foreach (var item in jsonArray.Children())
{
writer.WriteLine(item.ToString(Newtonsoft.Json.Formatting.None));
}
}
}
}
protected override void OnClosed(EventArgs e)
{
Cursor = Cursors.Default;
ControlService.DashboardTree.DashboardTreeList.Cursor = Cursors.Default;
try
{
if (connStatus != null)
{
if (connStatus.Connection != null)
{
connStatus.Connection.Cancel();
}
else if (connStatus.Login != null)
{
connStatus.Login.Cancel();
}
connStatus = null;
}
if (ftpOpenTask != null)
{
if (!ftpOpenTask.IsCompleted && !ftpOpenTask.IsCanceled)
{
ftpOpenTask.Cancel();
Result = false;
}
if (ftpOpenTask.IsCanceled)
{
CancelConnect();
}
//ftpOpenTask.Dispose();
}
}
catch { }
}
public async Task UpdateAsync(ConnectionEntity connectionEntity)
{
using (var db = _databaseContextFactory.CreateDbContext())
{
using (var transaction = await db.Database.BeginTransactionAsync())
{
try
{
var originalEntity = await db.Connections.FirstOrDefaultAsync(
c => c.Id == connectionEntity.Id);
if (originalEntity != null)
{
originalEntity.Name = connectionEntity.Name;
originalEntity.ConnectionString = connectionEntity.ConnectionString;
db.Connections.Update(originalEntity);
await db.SaveChangesAsync();
}
transaction.Commit();
}
catch
{
transaction.Rollback();
throw;
}
}
}
}
public async Task AddAsync(ConnectionEntity connectionEntity)
{
using (var db = _databaseContextFactory.CreateDbContext())
{
using (var transaction = await db.Database.BeginTransactionAsync())
{
try
{
var order = await db.Connections
.DefaultIfEmpty()
.MaxAsync(c => c.Order);
connectionEntity.Order = order + 1;
db.Connections.Add(connectionEntity);
await db.SaveChangesAsync();
transaction.Commit();
}
catch
{
transaction.Rollback();
throw;
}
}
}
}
public static void SetCurrentProject(ProjectEntity entity)
{
Project = entity;
if (entity == null || entity.ConnectionID <= 0)
{
Connection = null;
}
}
private void selectdConnection()
{
if (this.cbtemplate.SelectedIndex > -1)
{
_currentEntity = ConfigureModel.Find(cbtemplate.SelectedValue.ToString());
tbConnectInfo.Text = _currentEntity.ConnectionString;
}
}
public async Task <ICollection <ConnectionEntity> > Get()
{
var _mongoDatabase = _mongoClient.GetDatabase("DTH");
ConnectionEntity insert = new ConnectionEntity();
var collection = _mongoDatabase.GetCollection <ConnectionEntity>("connections");
var result = collection.AsQueryable().OrderByDescending(x => x.RequestedDate).ToList();
return(result);
}
public async Task <string> Insert <T>(T obj)
{
var _mongoDatabase = _mongoClient.GetDatabase("DTH");
ConnectionEntity insert = new ConnectionEntity();
var collection = _mongoDatabase.GetCollection <ConnectionEntity>("connections");
collection.InsertOne(insert);
return("Success");
}
public async Task <ConnectionEntity> GetById(string id)
{
var _mongoDatabase = _mongoClient.GetDatabase("DTH");
ConnectionEntity insert = new ConnectionEntity();
var collection = _mongoDatabase.GetCollection <ConnectionEntity>("connections");
var result = collection.AsQueryable().Where(x => x.id == id).FirstOrDefault();
return(result);
}
public async Task <string> Update <T>(T obj)
{
var _mongoDatabase = _mongoClient.GetDatabase("DTH");
ConnectionEntity update = obj as ConnectionEntity;
var collection = _mongoDatabase.GetCollection <ConnectionEntity>("connections");
collection.ReplaceOne(x => x.id == update.id, update);
return("Success");
}
public Connection GetConnectionById(int id)
{
ConnectionEntity ce = null;
if (m_entities.TryGetValue(id, out ce))
{
return(ce.m_sender);
}
return(null);
}
public async Task MarkConnectionAsClosed(ConnectionEntity connection)
{
using IUnitOfWork unitOfWork = repository.CreateUnitOfWork();
connection.ClosedAt = DateTime.UtcNow;
unitOfWork.Update(connection);
await unitOfWork.SaveChanges();
}
/// <summary>
/// 创建数据库连接
/// </summary>
/// <param name="connectionEntity"></param>
public void AddConnection(ConnectionEntity connectionEntity)
{
connectionSettings.ConnectionStrings.Add(new ConnectionStringSettings
{
Name = connectionEntity.ConnectionName,
ConnectionString = $"server={connectionEntity.Host};User Id={connectionEntity.UserName};password={connectionEntity.Password};Database={connectionEntity.Database}",
ProviderName = connectionEntity.Provider
});
//保存配置文件
Save(CONNECTIONSTRINGS);
}
public async Task <int> UpsertServerConnectionsAsync(int count)
{
var entity = new ConnectionEntity(Connections, Environment.MachineName)
{
Count = count
};
var upsertOperation = TableOperation.InsertOrReplace(entity);
await _connectionsTable.ExecuteAsync(upsertOperation);
return(await GetConnectionCountAsync());
}
public int Add(ConnectionEntity entity)
{
StringBuilder sb = new StringBuilder();
sb.Append("insert into [Connection](ConnectionName,ConnectionType,ConnectionString) values");
sb.AppendFormat("('{0}','{1}','{2}');", entity.ConnectionName, entity.ConnectionType.ToString(),
entity.ConnectionString);
string sql = sb.ToString();
return(db.ExecuteAdd(sql));
}
/// <summary>
/// Disconnects a given client
/// </summary>
/// <param name="connectionId">The connection identifier.</param>
/// <param name="afk">if set to <c>true</c>, the reason was player afk (lack of new packeges coming).</param>
public void Disconnect(int connectionId, bool afk)
{
ConnectionEntity ce = null;
m_entities.TryGetValue(connectionId, out ce);
if (ce != null)
{
ce.m_sender.Shutdown();
m_entities.Remove(connectionId);
OnDisconnect?.Invoke(connectionId, afk);
}
}
/// <summary>
/// 检测链接
/// </summary>
public static bool CheckDbConnection()
{
if (!Global.IsConnection)
{
ConnectionEntity conn = Global.GetProjectConnection();
DbConnectionOptions entity = new DbConnectionOptions();
WSH.CodeBuilder.DispatchServers.DataBaseType dbType = conn.ConnectionType;
WSH.Common.DataBaseType databaseType = WSH.Common.DataBaseType.SqlServer;
switch (dbType)
{
case WSH.CodeBuilder.DispatchServers.DataBaseType.MySql:
databaseType = WSH.Common.DataBaseType.MySql;
entity = new DbConnectionOptions()
{
ConnectionString = conn.ConnectionString
};
break;
case WSH.CodeBuilder.DispatchServers.DataBaseType.Access:
databaseType = WSH.Common.DataBaseType.Access;
entity = new DbConnectionOptions()
{
ConnectionString = conn.ConnectionString
};
break;
case WSH.CodeBuilder.DispatchServers.DataBaseType.Oracle:
databaseType = WSH.Common.DataBaseType.Oracle;
entity = new DbConnectionOptions()
{
ConnectionString = conn.ConnectionString
};
break;
case WSH.CodeBuilder.DispatchServers.DataBaseType.SqlServer:
databaseType = WSH.Common.DataBaseType.SqlServer;
entity = new DbConnectionOptions()
{
ConnectionString = conn.ConnectionString
};
break;
}
Result result = DbConnectionManager.Connection(databaseType, entity);
if (result.IsSuccess)
{
Global.ConnectionString = result.Msg;
return(true);
}
return(false);
}
return(true);
}
public ProjectEntity Create(ConnectionEntity connection)
{
var proj = new ProjectEntity();
proj.ConnectionString = connection.ConnectionString;
proj.ProviderName = connection.ProviderName;
//proj.ConnectionName = ConnectionName;
//proj.DbName = DbName;
SchemaModel model = new Model.SchemaModel();
proj.Tables = model.GetAllTableSchema(proj.ConnectionString, proj.ProviderName);
return(proj);
}
public void insert(dynamic name, dynamic Context)
{
var table = GetConnectionTable();
table.CreateIfNotExists();
var entity = new ConnectionEntity(
name.ToLower(),
Context.ConnectionId);
var insertOperation = TableOperation.InsertOrReplace(entity);
table.Execute(insertOperation);
}
public ConnectionEntity retrieveWaitingConnectionEntity(string partitionKey, string rowKey)
{
ConnectionEntity waitingConnection = null;
TableOperation retrieveOperation = TableOperation.Retrieve <ConnectionEntity>(partitionKey, rowKey);
TableResult retrieveResult = _waitingConnectionsTable.Execute(retrieveOperation);
if (retrieveResult.Result != null)
{
waitingConnection = (ConnectionEntity)retrieveResult.Result;
}
return(waitingConnection);
}
private void checkBox1_CheckedChanged(object sender, EventArgs e)
{
this.cbtemplate.Enabled = !cbNewConn.Checked;
this.btnOpenConnDialog.Enabled = cbNewConn.Checked;
if (cbNewConn.Checked)
{
_currentEntity = null;
tbConnectInfo.Text = "";
}
else
{
selectdConnection();
}
}
public bool Update(ConnectionEntity entity)
{
StringBuilder sb = new StringBuilder();
sb.Append("update [Connection] set ");
sb.AppendFormat("ConnectionName='{0}',", entity.ConnectionName);
sb.AppendFormat("ConnectionType='{0}',", entity.ConnectionType.ToString());
sb.AppendFormat("ConnectionString='{0}',", entity.ConnectionString);
sb.AppendFormat("EditTime='{0}'", DateTimeHelper.NowDateTime);
sb.AppendFormat(" where [ID]={0}", entity.ID);
string sql = sb.ToString();
return(db.ExecuteNonQuery(sql));
}
