/// <summary>
/// 删除
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task Delete(Guid id)
{
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, false, false, _dbConnectionFactory.CreateAllForWhitelistPolicy(), async (conn, transaction) =>
{
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
using (SqlCommand command = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
Transaction = sqlTran,
CommandText = @"DELETE FROM [dbo].[ClientWhiteList]
WHERE id=@id"
})
{
var parameter = new SqlParameter("@id", SqlDbType.UniqueIdentifier)
{
Value = id
};
command.Parameters.Add(parameter);
command.Prepare();
await command.ExecuteNonQueryAsync();
}
});
}
public async Task Delete(Guid id)
{
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, false, false, _messageQueueConnectionFactory.CreateAllForMessageQueueMain(), async (conn, transaction) =>
{
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
await using (SqlCommand commond = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
Transaction = sqlTran,
CommandText = @"delete from SMessageTypeListener where [id]=@id"
})
{
var parameter = new SqlParameter("@id", SqlDbType.UniqueIdentifier)
{
Value = id
};
commond.Parameters.Add(parameter);
await commond.PrepareAsync();
await commond.ExecuteNonQueryAsync();
}
});
}
/// <summary>
/// 删除
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task Delete(Guid id)
{
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, false, false, _dbConnectionFactory.CreateAllForSystemToken(), async (conn, transaction) =>
{
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
await using (SqlCommand command = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
Transaction = sqlTran,
})
{
SqlParameter parameter;
command.CommandText = @"delete [dbo].[AuthorizationEndpoint] where id = @id";
parameter = new SqlParameter("@id", SqlDbType.UniqueIdentifier)
{
Value = id
};
command.Parameters.Add(parameter);
await command.PrepareAsync();
await command.ExecuteNonQueryAsync();
}
});
}
public async Task Update(ServiceDescription description)
{
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, false, false, _dbConnectionMainFactory.CreateAllForMain(), async (conn, transaction) =>
{
var current = DateTime.UtcNow;
description.ModifyTime = current;
using (var dbContext = EntityDBContextFactory.Create(conn))
{
dbContext.Database.UseTransaction(transaction);
dbContext.ServiceDescriptions.Attach(description);
var entry = dbContext.Entry(description);
if (description.Attributes.ContainsKey("Name"))
{
entry.Property((r) => r.Name).IsModified = true;
}
if (description.Attributes.ContainsKey("Address"))
{
entry.Property((r) => r.Address).IsModified = true;
}
if (description.Attributes.ContainsKey("AuthInfoType"))
{
entry.Property((r) => r.AuthInfoType).IsModified = true;
}
entry.Property((r) => r.ModifyTime).IsModified = true;
await dbContext.SaveChangesAsync();
}
});
}
public async Task Delete(string userKey, Guid id)
{
var storeInfo = await GetDBAllStoreInfo(userKey, _thirdPartySystemTokenRecordHashGroupName);
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, false, false, storeInfo[0], async (conn, transaction) =>
{
//新增
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
await using (SqlCommand command = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
Transaction = sqlTran,
})
{
SqlParameter parameter;
command.CommandText = string.Format(@"delete from {0} where [id]=@id", storeInfo[1]);
parameter = new SqlParameter("@id", SqlDbType.UniqueIdentifier)
{
Value = id
};
command.Parameters.Add(parameter);
await command.PrepareAsync();
await command.ExecuteNonQueryAsync();
}
});
}
public async Task Delete(Guid infoID)
{
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, false, false, _dbConnectionFactory.CreateAllForStorge(), async (conn, transaction) =>
{
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
await using (SqlCommand command = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
Transaction = sqlTran,
})
{
SqlParameter parameter;
command.CommandText = @"delete from MultipartStorgeInfo where [id]=@id";
parameter = new SqlParameter("@id", SqlDbType.UniqueIdentifier)
{
Value = infoID
};
command.Parameters.Add(parameter);
await command.PrepareAsync();
await command.ExecuteNonQueryAsync();
}
});
}
public async Task Delete(Guid id)
{
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, false, false, _jwtConnectionFactory.CreateAllForJwt(), async (conn, transaction) =>
{
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
using (SqlCommand commond = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
Transaction = sqlTran
})
{
commond.CommandText = @"delete from JwtEndpoint where [id]=@id";
SqlParameter parameter;
parameter = new SqlParameter("@id", SqlDbType.UniqueIdentifier)
{
Value = id
};
commond.Parameters.Add(parameter);
commond.Prepare();
await commond.ExecuteNonQueryAsync();
}
});
}
/// <summary>
/// 删除动作与组的关联关系
/// </summary>
/// <param name="actionId"></param>
/// <param name="queueId"></param>
/// <returns></returns>
public async Task DeleteActionGroupRelation(Guid actionId, Guid queueId)
{
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, false, false, _dbConnectionFactory.CreateAllForSchedule(), async (conn, transaction) =>
{
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
using (SqlCommand command = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
Transaction = sqlTran,
CommandText = @"UPDATE [dbo].[ScheduleAction]
SET [groupid]=null,[modifytime] = GETUTCDATE()
WHERE id=@id AND groupid =@groupid"
})
{
var parameter = new SqlParameter("@id", SqlDbType.UniqueIdentifier)
{
Value = actionId
};
command.Parameters.Add(parameter);
parameter = new SqlParameter("@groupid", SqlDbType.UniqueIdentifier)
{
Value = queueId
};
command.Parameters.Add(parameter);
command.Prepare();
await command.ExecuteNonQueryAsync();
}
});
}
public async Task AddGroupRelation(Guid actionId, Guid groupId)
{
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, false, false, _businessSecurityRuleConnectionFactory.CreateAllForBusinessSecurityRule(), async (conn, transaction) =>
{
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
using (SqlCommand commond = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
Transaction = sqlTran,
CommandText = @"insert into BusinessActionGroupRelation WITH (SNAPSHOT)([groupid],[actionid])
values(@groupid,@actionid)"
})
{
SqlParameter parameter;
parameter = new SqlParameter("@groupid", SqlDbType.UniqueIdentifier)
{
Value = groupId
};
commond.Parameters.Add(parameter);
parameter = new SqlParameter("@actionid", SqlDbType.UniqueIdentifier)
{
Value = actionId
};
commond.Parameters.Add(parameter);
commond.Prepare();
int reply = 3;
while (true)
{
try
{
await commond.ExecuteNonQueryAsync();
break;
}
catch (SqlException ex)
{
if (reply > 0 && (ex.Number == 41302 || ex.Number == 41305 || ex.Number == 41325 || ex.Number == 41301 || ex.Number == 1205))
{
reply--;
System.Threading.Thread.Sleep(1);
}
else
{
throw;
}
}
}
}
});
}
public async Task UpdateLastExecuteTime(SQueue queue, Guid id)
{
//根据存储类型和服务器名称获取连接字符串
var strConn = _messageQueueConnectionFactory.CreateAllForMessageQueue(queue.StoreType, queue.ServerName);
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, false, false, strConn, async (conn, transaction) =>
{
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
await using (SqlCommand commond = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
Transaction = sqlTran,
CommandText = string.Format(@"update {0} set [lastexecutetime]=getutcdate() where [id]=@id", queue.Name)
})
{
SqlParameter parameter;
parameter = new SqlParameter("@id", SqlDbType.UniqueIdentifier)
{
Value = id
};
commond.Parameters.Add(parameter);
await commond.PrepareAsync();
await commond.ExecuteNonQueryAsync();
}
});
}
public async Task Lock(string lockName, Func <Task> callBack, int timeout = -1)
{
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, false, false, _dbConnectionFactory.CreateAllForWorkflow(), async (conn, transaction) =>
{
await SqlServerApplicationLockHelper.Execute((SqlConnection)conn, (SqlTransaction)transaction, lockName, callBack, timeout);
});
}
public async Task Delete(Guid recordId)
{
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, false, false, _fileManagementConnectionFactory.CreateAllForUploadFileHandle(), async (conn, transaction) =>
{
//新增
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
await using (SqlCommand command = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
Transaction = sqlTran,
})
{
SqlParameter parameter;
command.CommandText = @" delete [UploadFileHandleRecord] where id = @id ";
parameter = new SqlParameter("@id", SqlDbType.UniqueIdentifier)
{
Value = recordId
};
command.Parameters.Add(parameter);
await command.PrepareAsync();
await command.ExecuteNonQueryAsync();
}
});
}
public async Task Update(Guid groupId, HashRealNode node)
{
//获取读写连接字符串
var strConn = _hashConnectionFactory.CreateAllForHash();
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, false, false, strConn, async (conn, transaction) =>
{
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
using (SqlCommand command = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
Transaction = sqlTran,
})
{
SqlParameter parameter;
command.CommandText = @"
update [HASHREALNODE]
set nodekey = @nodekey
,name = @name
,modifytime = GETUTCDATE()
where id = @id and groupid = @groupId";
parameter = new SqlParameter("@id", SqlDbType.UniqueIdentifier)
{
Value = node.ID
};
command.Parameters.Add(parameter);
parameter = new SqlParameter("@groupid", SqlDbType.UniqueIdentifier)
{
Value = node.GroupId
};
command.Parameters.Add(parameter);
parameter = new SqlParameter("@name", SqlDbType.VarChar, 100)
{
Value = node.Name
};
command.Parameters.Add(parameter);
parameter = new SqlParameter("@nodekey", SqlDbType.VarChar, 4000)
{
Value = node.NodeKey
};
command.Parameters.Add(parameter);
command.Prepare();
await command.ExecuteNonQueryAsync();
}
});
}
public async Task Delete(Guid id)
{
//获取读写连接字符串
var strConn = _contextConnectionFactory.CreateAllForContext();
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, false, false, strConn, async (conn, transaction) =>
{
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
await using (SqlCommand commond = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
Transaction = sqlTran,
CommandText = @"delete from HttpClaimGenerator where [id]=@id"
})
{
SqlParameter parameter;
parameter = new SqlParameter("@id", SqlDbType.UniqueIdentifier)
{
Value = id
};
commond.Parameters.Add(parameter);
await commond.PrepareAsync();
await commond.ExecuteNonQueryAsync();
}
});
}
public async Task <DTOperationData> QueryByID(string storeGroupName, string hashInfo, Guid id)
{
string strConn = _transactionConnectionFactory.CreateAllForDTOperationData();
var(connNames, tableName) = await getStoreInfo(storeGroupName, hashInfo);
if (connNames != null)
{
strConn = _transactionConnectionFactory.CreateAllForDTOperationData(connNames);
}
else
{
tableName = "DTOperationData";
}
DTOperationData data = null;
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, true, false, strConn, async (conn, transaction) =>
{
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
await using (SqlCommand commond = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
Transaction = sqlTran,
CommandText = string.Format(@"select {0} from {1} where [id]=@id", StoreHelper.GetDTOperationDataSelectFields(string.Empty), tableName)
})
{
var parameter = new SqlParameter("@id", SqlDbType.UniqueIdentifier)
{
Value = id
};
commond.Parameters.Add(parameter);
await commond.PrepareAsync();
SqlDataReader reader = null;
await using (reader = await commond.ExecuteReaderAsync())
{
if (await reader.ReadAsync())
{
data = new DTOperationData();
StoreHelper.SetDTOperationDataSelectFields(data, reader, string.Empty);
}
await reader.CloseAsync();
}
}
});
return(data);
}
public async Task <SQueue> QueryByCode(string groupName, bool isDead, int code)
{
SQueue queue = null;
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, true, false, _messageQueueConnectionFactory.CreateReadForMessageQueueMain(), async (conn, transaction) =>
{
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
await using (SqlCommand commond = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
Transaction = sqlTran,
CommandText = string.Format(@"select {0} from SQueue where [groupname]=@groupname and [code]=@code and [isdead]=@isdead", StoreHelper.GetSQueueSelectFields(string.Empty))
})
{
var parameter = new SqlParameter("@groupname", SqlDbType.VarChar, 150)
{
Value = groupName
};
commond.Parameters.Add(parameter);
parameter = new SqlParameter("@code", SqlDbType.Int)
{
Value = code
};
commond.Parameters.Add(parameter);
parameter = new SqlParameter("@isdead", SqlDbType.Bit)
{
Value = isDead
};
commond.Parameters.Add(parameter);
await commond.PrepareAsync();
SqlDataReader reader = null;
await using (reader = await commond.ExecuteReaderAsync())
{
if (await reader.ReadAsync())
{
queue = new SQueue();
StoreHelper.SetSQueueSelectFields(queue, reader, string.Empty);
}
await reader.CloseAsync();
}
}
});
return(queue);
}
public async Task <DTOperationRecord> QueryByUniqueName(string storeGroupName, string hashInfo, string uniqueName)
{
string strConn = _transactionConnectionFactory.CreateAllForDTOperationRecord();
var(connNames, tableName) = await getStoreInfo(storeGroupName, hashInfo);
if (connNames != null)
{
strConn = _transactionConnectionFactory.CreateAllForDTOperationRecord(connNames);
}
else
{
tableName = "DTOperationRecord";
}
DTOperationRecord record = null;
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, true, false, strConn, async (conn, transaction) =>
{
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
await using (SqlCommand commond = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
Transaction = sqlTran,
CommandText = string.Format(@"select {0} from {1} where [uniquename]=@uniquename", StoreHelper.GetDTOperationRecordSelectFields(string.Empty), tableName)
})
{
var parameter = new SqlParameter("@uniquename", SqlDbType.VarChar, 150)
{
Value = uniqueName
};
commond.Parameters.Add(parameter);
await commond.PrepareAsync();
SqlDataReader reader = null;
await using (reader = await commond.ExecuteReaderAsync())
{
if (await reader.ReadAsync())
{
record = new DTOperationRecord();
StoreHelper.SetDTOperationRecordSelectFields(record, reader, string.Empty);
}
await reader.CloseAsync();
}
}
});
return(record);
}
public async Task Update(SerialNumberGeneratorConfiguration configuration)
{
//获取读写连接字符串
var strConn = _serialNumberConnectionFactory.CreateAllForSerialNumber();
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, false, false, strConn, async (conn, transaction) =>
{
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
await using (SqlCommand commond = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
Transaction = sqlTran,
CommandText = @" update [dbo].[SerialNumberGeneratorConfiguration]
set [name]=@name
,[prefixtemplate]=@prefixtemplate
,[seriallength]=@seriallength
,[modifytime]=getutcdate()
where [id]=@id"
})
{
var parameter = new SqlParameter("@id", SqlDbType.UniqueIdentifier)
{
Value = configuration.ID
};
commond.Parameters.Add(parameter);
parameter = new SqlParameter("@name", SqlDbType.NVarChar, 100)
{
Value = configuration.Name
};
commond.Parameters.Add(parameter);
parameter = new SqlParameter("@prefixtemplate", SqlDbType.NVarChar, 1000)
{
Value = configuration.PrefixTemplate
};
commond.Parameters.Add(parameter);
parameter = new SqlParameter("@seriallength", SqlDbType.Int)
{
Value = configuration.SerialLength
};
commond.Parameters.Add(parameter);
await commond.PrepareAsync();
await commond.ExecuteNonQueryAsync();
}
});
}
public async Task Update(HashGroup group)
{
//获取读写连接字符串
var strConn = _hashConnectionFactory.CreateAllForHash();
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, false, false, strConn, async (conn, transaction) =>
{
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
using (SqlCommand commond = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
Transaction = sqlTran,
CommandText = @"update [dbo].[HashGroup]
set
[name]=@name
,[count]=@count
,[strategyid]=@strategyid
,[modifytime]=getutcdate()
where [id]=@id"
})
{
var parameter = new SqlParameter("@id", SqlDbType.UniqueIdentifier)
{
Value = group.ID
};
commond.Parameters.Add(parameter);
parameter = new SqlParameter("@name", SqlDbType.NVarChar, 100)
{
Value = group.Name
};
commond.Parameters.Add(parameter);
parameter = new SqlParameter("@count", SqlDbType.BigInt)
{
Value = group.Count
};
commond.Parameters.Add(parameter);
parameter = new SqlParameter("@strategyid", SqlDbType.UniqueIdentifier)
{
Value = group.StrategyID
};
commond.Parameters.Add(parameter);
commond.Prepare();
await commond.ExecuteNonQueryAsync();
}
});
}
public async Task Update(ThirdPartySystemTokenRecord record)
{
var storeInfo = await GetDBAllStoreInfo(record.UserKey, _thirdPartySystemTokenRecordHashGroupName);
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, false, false, storeInfo[0], async (conn, transaction) =>
{
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
await using (SqlCommand command = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
Transaction = sqlTran,
})
{
SqlParameter parameter;
command.CommandText = string.Format(@"
update {0}
set [token]=@token,
[timeout]=@timeout,
[lastrefeshtime]=@lastrefeshtime,
[modifytime]=getutcdate()
where [id] = @id", storeInfo[1]);
parameter = new SqlParameter("@id", SqlDbType.UniqueIdentifier)
{
Value = record.ID
};
command.Parameters.Add(parameter);
parameter = new SqlParameter("@token", SqlDbType.NVarChar, record.Token.Length)
{
Value = record.Token
};
command.Parameters.Add(parameter);
parameter = new SqlParameter("@timeout", SqlDbType.Int)
{
Value = record.Timeout
};
command.Parameters.Add(parameter);
parameter = new SqlParameter("@lastrefeshtime", SqlDbType.DateTime)
{
Value = record.LastRefeshTime
};
command.Parameters.Add(parameter);
await command.PrepareAsync();
await command.ExecuteNonQueryAsync();
}
});
}
public async Task <SMessageHistory> QueryById(Guid id)
{
var storeInfo = await StoreInfoHelper.GetHashStoreInfo(_storeInfoResolveService, _hashGroupRepository, _messageHistoryHashGroupName, id.ToString());
if (!storeInfo.TableNames.TryGetValue(HashEntityNames.SMessageHistory, out string tableName))
{
var fragment = new TextFragment()
{
Code = TextCodes.NotFoundKeyInHashNodeKeyInfo,
DefaultFormatting = "哈希组{0}中的哈希节点关键信息中找不到键值{1}",
ReplaceParameters = new List <object>()
{
_messageHistoryHashGroupName, HashEntityNames.SMessageHistory
}
};
throw new UtilityException((int)Errors.NotFoundKeyInHashNodeKeyInfo, fragment);
}
SMessageHistory smssageHistory = null;
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, false, false, _messageQueueConnectionFactory.CreateReadForSMessageHistory(storeInfo.DBConnectionNames), async (conn, transaction) =>
{
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
await using (SqlCommand command = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
CommandText = string.Format(@"SELECT {0} FROM {1} WHERE id=@id", StoreHelper.GetSMessageHistorySelectFields(string.Empty), tableName),
Transaction = sqlTran,
})
{
var parameter = new SqlParameter("@id", SqlDbType.UniqueIdentifier)
{
Value = id
};
command.Parameters.Add(parameter);
command.Prepare();
SqlDataReader reader = null;
await using (reader = await command.ExecuteReaderAsync())
{
if (await reader.ReadAsync())
{
smssageHistory = new SMessageHistory();
StoreHelper.SetSMessageHistorySelectFields(smssageHistory, reader, string.Empty);
}
await reader.CloseAsync();
}
}
});
return(smssageHistory);
}
public async Task <OptionSetValueItem> QueryByValue(Guid optionSetValueId, string stringValue)
{
OptionSetValueItem item = null;
//获取只读连接字符串
var strConn = _entityMetadataConnectionFactory.CreateReadForEntityMetadata();
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, true, false, strConn, async (conn, transaction) =>
{
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
await using (SqlCommand commond = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
Transaction = sqlTran,
CommandText = string.Format(@"select {0},{1} from OptionSetValueItem as item join OptionSetValueMetadata as metadata on item.optionsetvalueid=metadata.id where metadata.id=@optionsetvalueid and item.[stringvalue]=@stringvalue", StoreHelper.GetOptionSetValueItemSelectFields("item"), StoreHelper.GetOptionSetValueMetadataSelectFields("metadata"))
})
{
var parameter = new SqlParameter("@optionsetvalueid", SqlDbType.UniqueIdentifier)
{
Value = optionSetValueId
};
commond.Parameters.Add(parameter);
parameter = new SqlParameter("@stringvalue", SqlDbType.NVarChar, 100)
{
Value = stringValue
};
commond.Parameters.Add(parameter);
commond.Prepare();
SqlDataReader reader = null;
await using (reader = await commond.ExecuteReaderAsync())
{
if (await reader.ReadAsync())
{
item = new OptionSetValueItem();
StoreHelper.SetOptionSetValueItemSelectFields(item, reader, "item");
item.OptionSetValue = new OptionSetValueMetadata();
StoreHelper.SetOptionSetValueMetadataSelectFields(item.OptionSetValue, reader, "metadata");
}
await reader.CloseAsync();
}
}
});
return(item);
}
/// <summary>
/// 删除用户动作
/// </summary>
/// <param name="resourceType"></param>
/// <param name="resourceKey"></param>
/// <param name="stepId">关联的步骤ID</param>
/// <param name="actionId">工作流用户动作ID</param>
/// <returns></returns>
public async Task Delete(string resourceType, string resourceKey, Guid stepId, Guid actionId)
{
var dbInfo = await StoreInfoHelper.GetHashStoreInfo(_storeInfoResolveService, _hashGroupRepository, _hashGroupName, resourceType, resourceKey);
if (!dbInfo.TableNames.TryGetValue(HashEntityNames.WorkflowStepUserAction, out string tableNameStepUserAction))
{
var fragment = new TextFragment()
{
Code = TextCodes.NotFoundKeyInHashNodeKeyInfo,
DefaultFormatting = "哈希组{0}中的哈希节点关键信息中找不到键值{1}",
ReplaceParameters = new List <object>()
{
_hashGroupName
, HashEntityNames.WorkflowStepUserAction
}
};
throw new UtilityException((int)Errors.NotFoundKeyInHashNodeKeyInfo, fragment);
}
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, false, false, dbInfo.DBConnectionNames.ReadAndWrite, async (conn, transaction) =>
{
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
await using (SqlCommand command = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
Transaction = sqlTran,
CommandText = string.Format(@"DELETE FROM {0} WHERE id=@id AND stepid=@stepid", tableNameStepUserAction)
})
{
SqlParameter parameter;
parameter = new SqlParameter("@id", SqlDbType.UniqueIdentifier)
{
Value = actionId
};
command.Parameters.Add(parameter);
parameter = new SqlParameter("@stepid", SqlDbType.UniqueIdentifier)
{
Value = stepId
};
command.Parameters.Add(parameter);
await command.PrepareAsync();
await command.ExecuteNonQueryAsync();
}
});
}
public async Task UpdateStatus(Guid recordId, int status, string result, string error)
{
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, false, false, _fileManagementConnectionFactory.CreateAllForUploadFileHandle(), async (conn, transaction) =>
{
//新增
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
await using (SqlCommand command = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
Transaction = sqlTran,
})
{
SqlParameter parameter;
command.CommandText = @" update [UploadFileHandleRecord]
set status = @status
,error = @error
,resultinfo = @result
,modifytime = GETUTCDATE()
where id = @id ";
parameter = new SqlParameter("@id", SqlDbType.UniqueIdentifier)
{
Value = recordId
};
command.Parameters.Add(parameter);
parameter = new SqlParameter("@status", SqlDbType.Int)
{
Value = status
};
command.Parameters.Add(parameter);
parameter = new SqlParameter("@error", SqlDbType.NVarChar, -1)
{
Value = string.IsNullOrEmpty(error) ? "" : error
};
command.Parameters.Add(parameter);
parameter = new SqlParameter("@result", SqlDbType.NVarChar, 2000)
{
Value = (object)result ?? DBNull.Value
};
command.Parameters.Add(parameter);
await command.PrepareAsync();
await command.ExecuteNonQueryAsync();
}
});
}
public async Task <StoreGroupMember> QueryByName(Guid groupID, string memberName)
{
StoreGroupMember member = null;
//获取只读连接字符串
var strConn = _storgeConnectionFactory.CreateReadForStorge();
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, true, false, strConn, async (conn, transaction) =>
{
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
await using (SqlCommand commond = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
Transaction = sqlTran,
CommandText = string.Format(@"select {0},{1} from StoreGroupMember as m join StoreGroup as g on m.groupid=g.id where g.[id]=@groupid and m.[name]=@name", StoreHelper.GetStoreGroupMemberSelectFields("m"), StoreHelper.GetStoreGroupSelectFields("g"))
})
{
var parameter = new SqlParameter("@groupid", SqlDbType.UniqueIdentifier)
{
Value = groupID
};
commond.Parameters.Add(parameter);
parameter = new SqlParameter("@name", SqlDbType.VarChar, 150)
{
Value = memberName
};
commond.Parameters.Add(parameter);
commond.Prepare();
SqlDataReader reader = null;
await using (reader = await commond.ExecuteReaderAsync())
{
if (await reader.ReadAsync())
{
member = new StoreGroupMember();
StoreHelper.SetStoreGroupMemberSelectFields(member, reader, "m");
member.Group = new StoreGroup();
StoreHelper.SetStoreGroupSelectFields(member.Group, reader, "g");
}
await reader.CloseAsync();
}
}
});
return(member);
}
public async Task <UserRoleRelation> QueryByRole(Guid roleId, Guid id)
{
UserRoleRelation relation = null;
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, true, false, _privilegeManagementConnectionFactory.CreateReadForPrivilegeManagement(), async (conn, transaction) =>
{
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
using (SqlCommand commond = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
Transaction = sqlTran,
CommandText = string.Format(@"select {0},{1},{2} from [UserRoleRelation] as urr join [role] as r
on urr.[roleid]=r.[id] join [PrivilegeSystem] as s
on urr.[systemid]=s.[id] where urr.[id]=@id and urr.[roleid]", StoreHelper.GetUserRoleRelationSelectFields("urr"), StoreHelper.GetRoleSelectFields("r"), StoreHelper.GetPrivilegeSystemSelectFields("s"))
})
{
var parameter = new SqlParameter("@id", SqlDbType.UniqueIdentifier)
{
Value = id
};
commond.Parameters.Add(parameter);
parameter = new SqlParameter("@roleid", SqlDbType.UniqueIdentifier)
{
Value = roleId
};
commond.Parameters.Add(parameter);
commond.Prepare();
SqlDataReader reader = null;
using (reader = await commond.ExecuteReaderAsync())
{
if (await reader.ReadAsync())
{
relation = new UserRoleRelation();
StoreHelper.SetUserRoleRelationSelectFields(relation, reader, "urr");
relation.Role = new Role();
StoreHelper.SetRoleSelectFields(relation.Role, reader, "r");
relation.System = new PrivilegeSystem();
StoreHelper.SetPrivilegeSystemSelectFields(relation.System, reader, "s");
}
reader.Close();
}
}
});
return(relation);
}
/// <summary>
/// 根据关联的系统登录终结点查询指定名称的关联验证终结点
/// </summary>
/// <param name="systemLoginEndpointId"></param>
/// <param name="authorizationName"></param>
/// <returns></returns>
public async Task <AuthorizationEndpoint> QueryBySystemLoginEndpointRelation(Guid systemLoginEndpointId, string authorizationName)
{
AuthorizationEndpoint result = null;
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, false, false, _dbConnectionFactory.CreateReadForSystemToken(), async (conn, transaction) =>
{
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
await using (SqlCommand command = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
Transaction = sqlTran,
})
{
SqlParameter parameter;
command.CommandText = string.Format(@" SELECT
{0}
FROM [DBO].[AUTHORIZATIONENDPOINT] A JOIN DBO.SYSTEMLOGINENDPOINTAUTHORIZATIONENDPOINTRELATION R
ON(A.ID = R.AUTHORIZATIONENDPOINTID AND R.SYSTEMLOGINENDPOINTID = @systemLoginEndpointId
AND A.Name = @name
);", StoreHelper.GetAuthorizationEndpointStoreSelectFields("A"));
parameter = new SqlParameter("@systemLoginEndpointId", SqlDbType.UniqueIdentifier)
{
Value = systemLoginEndpointId
};
command.Parameters.Add(parameter);
parameter = new SqlParameter("@name", SqlDbType.NVarChar, 500)
{
Value = authorizationName
};
command.Parameters.Add(parameter);
await command.PrepareAsync();
SqlDataReader reader = null;
await using (reader = await command.ExecuteReaderAsync())
{
if (await reader.ReadAsync())
{
result = new AuthorizationEndpoint();
StoreHelper.SetAuthorizationEndpointSelectFields(result, reader, "A");
}
await reader.CloseAsync();
}
}
});
return(result);
}
public async Task <CommonSignConfigurationNode> QueryByConfigurationName(Guid configurationId, string name)
{
CommonSignConfigurationNode result = null;
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, true, false, _dbConnectionFactory.CreateReadForWorkflow(), async (conn, transaction) =>
{
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
await using (var command = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
Transaction = sqlTran,
CommandText = string.Format(@"SELECT {0},{1}
FROM [CommonSignConfigurationNode] AS cnode
INNER JOIN [CommonSignConfiguration] AS config
ON cnode.[configurationid] = config.[id]
WHERE cnode.[configurationid] = @configurationid
AND cnode.[name] = @name
ORDER BY cnode.sequence DESC; ",
StoreHelper.GetCommonSignConfigurationNodeSelectFields("cnode"),
StoreHelper.GetCommonSignConfigurationSelectFields("config"))
})
{
var parameter = new SqlParameter("@configurationid", SqlDbType.UniqueIdentifier)
{
Value = configurationId
};
command.Parameters.Add(parameter);
parameter = new SqlParameter("@name", SqlDbType.NVarChar, 500)
{
Value = name
};
command.Parameters.Add(parameter);
await command.PrepareAsync();
SqlDataReader reader = null;
await using (reader = await command.ExecuteReaderAsync())
{
if (await reader.ReadAsync())
{
result = new CommonSignConfigurationNode();
StoreHelper.SetCommonSignConfigurationNodeSelectFields(result, reader, "cnode");
result.Configuration = new CommonSignConfiguration();
StoreHelper.SetCommonSignConfigurationSelectFields(result.Configuration, reader, "config");
}
await reader.CloseAsync();
}
}
});
return(result);
}
public async Task <Whitelist> QueryBySystemOperationRelation(Guid systemOperationId, string systemName, int status)
{
Whitelist result = null;
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, true, false, _dbConnectionFactory.CreateReadForWhitelistPolicy(), async (conn, transaction) =>
{
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
using (SqlCommand commond = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
CommandText = string.Format(@"select {0} from WhiteList as w join SystemOperationWhiteListRelation as r on w.id=r.whitelistid where r.systemoperationid=@systemoperationid and w.systemname=@whitelistsystemname and w.status=@status", StoreHelper.GetWhitelistSelectFields("w")),
Transaction = sqlTran
})
{
var parameter = new SqlParameter("@systemoperationid", SqlDbType.UniqueIdentifier)
{
Value = systemOperationId
};
commond.Parameters.Add(parameter);
parameter = new SqlParameter("@whitelistsystemname", SqlDbType.NVarChar, 500)
{
Value = systemName
};
commond.Parameters.Add(parameter);
parameter = new SqlParameter("@status", SqlDbType.Int)
{
Value = status
};
commond.Parameters.Add(parameter);
commond.Prepare();
SqlDataReader reader = null;
using (reader = await commond.ExecuteReaderAsync())
{
if (await reader.ReadAsync())
{
result = new Whitelist();
StoreHelper.SetWhitelistSelectFields(result, reader, "w");
}
}
}
});
return(result);
}
public async Task <SMessage> QueryByOriginalID(SQueue queue, Guid originalMessageID, Guid listenerID)
{
SMessage message = null;
//根据存储类型和服务器名称获取连接字符串
var strConn = _messageQueueConnectionFactory.CreateReadForMessageQueue(queue.StoreType, queue.ServerName);
await DBTransactionHelper.SqlTransactionWorkAsync(DBTypes.SqlServer, true, false, strConn, async (conn, transaction) =>
{
SqlTransaction sqlTran = null;
if (transaction != null)
{
sqlTran = (SqlTransaction)transaction;
}
await using (SqlCommand commond = new SqlCommand()
{
Connection = (SqlConnection)conn,
CommandType = CommandType.Text,
Transaction = sqlTran,
CommandText = string.Format(@"select top 1 {0} from {1} where [originalmessageid]=@originalmessageid and [listenerid]=@listenerid ", StoreHelper.GetSMessageSelectFields(string.Empty), queue.Name)
})
{
var parameter = new SqlParameter("@originalmessageid", SqlDbType.UniqueIdentifier)
{
Value = originalMessageID
};
commond.Parameters.Add(parameter);
parameter = new SqlParameter("@listenerid", SqlDbType.UniqueIdentifier)
{
Value = listenerID
};
commond.Parameters.Add(parameter);
await commond.PrepareAsync();
SqlDataReader reader = null;
await using (reader = await commond.ExecuteReaderAsync())
{
if (await reader.ReadAsync())
{
message = new SMessage();
StoreHelper.SetSMessageSelectFields(message, reader, string.Empty);
message.Extensions[_queueName] = queue;
}
await reader.CloseAsync();
}
}
});
return(message);
}
