/// <summary>
/// 删除T_PM_SeedUsers数据
/// </summary>
/// <param name="requestObject"></param>
/// <returns></returns>
public async Task <ResponseObject <bool> > DeleteAsync(RequestDelete <DeleteModel> requestObject)
{
try
{
//执行结果
var result = false;
//没有删除数据，返回错误信息
if (requestObject.PostData == null && requestObject.PostDataList == null)
{
return(ResponseUtil <bool> .FailResult(false, "PostData、PostDataList不能都为null"));
}
//批量删除的优先级高于单记录删除
if (requestObject.PostDataList != null && requestObject.PostDataList.Count > 0)
{
//批量删除
var ids = requestObject.PostDataList.Select(p => p.ID);
result = await _db.Instance.Deleteable <TPMSeedUsersDbModel>().In(ids).ExecuteCommandAsync() > 0;
}
else
{
//单记录删除
result = await _db.Instance.Deleteable <TPMSeedUsersDbModel>().In(requestObject.PostData.ID).ExecuteCommandAsync() > 0;
}
//返回执行结果
return(result ? ResponseUtil <bool> .SuccessResult(true) : ResponseUtil <bool> .FailResult(false, "删除数据失败!"));
}
catch (Exception ex)
{
//返回异常结果
return(ResponseUtil <bool> .FailResult(false, ex.Message));
}
}
private static void TestDelete(
Action <string> log,
int numberOfThreads,
RingMasterBackendCore backendCore,
ClientSession clientSession)
{
var sw = new Stopwatch();
var data = new byte[PayloadLength];
var countPerThread = TotalNodeCount / numberOfThreads;
var threads = Enumerable.Range(0, numberOfThreads)
.Select(n => new Thread(() =>
{
for (int i = 0; i < countPerThread; i++)
{
var delReq = new RequestDelete($"/test/{n}/{i}", null, -1, null, true);
backendCore.ProcessMessage(delReq, clientSession, null);
}
}))
.ToArray();
int gen0 = GC.CollectionCount(0), gen1 = GC.CollectionCount(1), gen2 = GC.CollectionCount(2);
sw.Start();
Parallel.ForEach(threads, t => t.Start());
Parallel.ForEach(threads, t => t.Join());
sw.Stop();
var rate = 10 * countPerThread * numberOfThreads / sw.Elapsed.TotalSeconds;
log($"Delete nodes: {sw.Elapsed} QPS={rate:G3}");
log($" Gen0={GC.CollectionCount(0) - gen0} Gen1={GC.CollectionCount(1) - gen1} Gen2={GC.CollectionCount(2) - gen2}\n");
}
////////////////////// Invocacaoes ao core ///////////////////////////
private static MetaserverResponse Delete(MetaRequest request)
{
RequestDelete deleteRequest = (RequestDelete)request;
MetaserverResponse response;
//Invocar o servidor
try
{
Boolean success = core.Delete(deleteRequest.FileName, request.ClientId);
if (success)
{
response = new MetaserverResponse(ResponseStatus.Success, request, ThisMetaserverId);
}
else
{
response = new MetaserverResponse(ResponseStatus.Exception, request, ThisMetaserverId);
response.Exception = new PadiException(PadiExceptiontType.DeleteFile, "File not deleted");
}
}
catch (Exception ex)
{
response = new MetaserverResponse(ResponseStatus.Exception, request, ThisMetaserverId);
response.Exception = new PadiException(PadiExceptiontType.DeleteFile, ex.Message);
}
return(response);
}
/// <summary>
/// 删除配色项目，单个节点
/// </summary>
/// <param name="requestDelete"></param>
/// <returns></returns>
public async Task <ResponseObject <bool> > DeleteAsync(RequestDelete <DeleteModel> requestDelete)
{
try
{
//如果没有新增数据，返回错误信息
if (requestDelete.PostData == null)
{
return(ResponseUtil <bool> .FailResult(false, "PostData至少包含一条数据"));
}
#region 先注释
////删除包型的配色项目 则删除
//var thisModel = _db.Instance.Queryable<TMMColorItemDbModel>().Where(p => p.ID == requestDelete.PostData.ID).First();
//if (thisModel != null)
//{
// //含有这个包型 和 配色项目的BOM
// List<int> ColorSolutionIds = _db.Instance.Queryable<TMMBOMMainDbModel, TMMBOMDetailDbModel>((t, t1) => new object[] { JoinType.Inner, t.ID == t1.MainId })
// .Where((t, t1) => t.PackageId == thisModel.PackageId && t1.ItemId == thisModel.ItemId).Select((t, t1) => t.ID).Distinct().ToList();
// if (ColorSolutionIds.Count() > 0)
// {
// bool isExis = _db.Instance.Queryable<TMMProductionOrderDetailDbModel, TMMProductionOrderMainDbModel>((t, t1) => new object[] {
// JoinType.Inner,t.MainId==t1.ID}).Any((t, t1) => t1.DeleteFlag == false &&
// SqlFunc.IsNull(t1.MRPStatus, false) == false &&
// ColorSolutionIds.Contains(t.ColorSolutionId.Value)
// ); // 是否存在没有算料的生成单
// if (isExis)
// {
// throw new Exception("存在使用此配色项目的生产单，还没有进行算料，请将生产单算料，或者删除生产");
// }
// }
// //删除此包型所有的配色项目
// var deleteColorSolution= _db.Instance.Deleteable<TMMColorSolutionDetailDbModel>().Where(p => p.ItemId == thisModel.ItemId &&
// SqlFunc.Subqueryable<TMMColorSolutionMainDbModel>().Where(p1 => p1.ID == p.MainId && p1.PackageId == thisModel.PackageId).Any());
// //删除BOM
// _db.Instance.Deleteable<TMMBOMDetailDbModel>().Where(p => p.ItemId == thisModel.ItemId && SqlFunc.Subqueryable<TMMBOMMainDbModel>().
// Where(p1 => p1.ID == p.MainId && p1.PackageId == thisModel.PackageId).Any());
//}
#endregion
var result = await _db.Instance.Deleteable <TMMColorItemDbModel>()
.Where(p => p.ID == requestDelete.PostData.ID)
.ExecuteCommandAsync() > 0;
//返回执行结果
return(result ? ResponseUtil <bool> .SuccessResult(true) : ResponseUtil <bool> .FailResult(false, "删除数据失败!"));
}
catch (Exception ex)
{
//返回异常结果
return(ResponseUtil <bool> .FailResult(false, ex.Message));
}
}
public TResult Delete <TResult>(
SecurityToken mySecurity,
Int64 myTransactionToken,
RequestDelete myRequestDelete,
Converter.DeleteResultConverter <TResult> myOutputconverter)
{
var executedRequest = _requestManager.SynchronExecution(new PipelineableDeleteRequest(myRequestDelete,
mySecurity,
myTransactionToken));
return(((PipelineableDeleteRequest)executedRequest).GenerateRequestResult(myOutputconverter));
}
/// <summary>
/// 删除T_PSM_PurchaseOrderMain数据
/// </summary>
/// <param name="requestObject">Delete请求参数</param>
/// <param name="currentUser"></param>
/// <returns>返回响应结果对象，包括响应代码，删除操作结果</returns>
public async Task <ResponseObject <bool> > DeleteAsync(RequestDelete <DeleteModel> requestObject, CurrentUser currentUser)
{
var currDb = _db.Instance;//事务需要使用同一个 SqlSugarClient对象实例
try
{
if (requestObject.PostData == null && requestObject.PostDataList == null)
{
return(ResponseUtil <bool> .FailResult(false, "PostData、PostDataList不能都为null"));
}
//开启事务
currDb.BeginTran();
//删除标识
var mainFlag = true;
var detailFlag = true;
if (requestObject.PostDataList != null && requestObject.PostDataList.Count > 0)
{
//批量删除
var mainIds = requestObject.PostDataList.Select(p => p.ID).ToList();
mainFlag = await _db.Instance.Updateable <TPSMPurchaseOrderMainDbModel>()
.SetColumns(p => p.DeleteFlag == true)
.Where(p => mainIds.Contains(p.ID))
.ExecuteCommandAsync() > 0;
DeleteTransNum(mainIds.ToArray(), currentUser);
}
else
{
//单条删除
mainFlag = await _db.Instance.Updateable <TPSMPurchaseOrderMainDbModel>()
.SetColumns(p => p.DeleteFlag == true)
.Where(p => p.ID == requestObject.PostData.ID)
.ExecuteCommandAsync() > 0;
DeleteTransNum(new int[] { requestObject.PostData.ID }, currentUser);
}
//提交事务
currDb.CommitTran();
//返回执行结果
return(mainFlag && detailFlag
? ResponseUtil <bool> .SuccessResult(true)
: ResponseUtil <bool> .FailResult(false, "删除数据失败!"));
}
catch (Exception ex)
{
//回滚事务
currDb.RollbackTran();
//返回异常结果
return(ResponseUtil <bool> .FailResult(false, ex.Message));
}
}
public static OutputValues RequestDeleteContact(string contactId)
{
Pointel.Logger.Core.ILog logger = Pointel.Logger.Core.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "AID");
OutputValues output = OutputValues.GetInstance();
RequestDelete reqDeleteContact = new RequestDelete();
try
{
reqDeleteContact.ContactId = contactId;
if (Settings.UCSProtocol != null && Settings.UCSProtocol.State == ChannelState.Opened)
{
logger.Info("------------RequestDeleteContact-------------");
logger.Info("ContactId : " + contactId);
logger.Info("---------------------------------------------------");
IMessage message = Settings.UCSProtocol.Request(reqDeleteContact);
if (message != null)
{
logger.Trace(message.ToString());
output.IContactMessage = message;
output.MessageCode = "200";
output.Message = "Contact Deleted Successfully";
}
else
{
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = "Can't Delete Contact Successfully";
}
}
else
{
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = "Universal Contact Server protocol is Null or Closed";
logger.Warn("RequestDeleteContact() : Contact Server protocol is Null..");
}
}
catch (Exception generalException)
{
logger.Error("Error occurred while Delete Contact " + generalException.ToString());
output.MessageCode = "2001";
output.Message = generalException.Message;
}
return(output);
}
/// <summary>
/// Serialize <see cref="RequestDelete"/>.
/// </summary>
/// <param name="request">Request to serialize</param>
private void SerializeRequestDelete(RequestDelete request)
{
this.binaryWriter.Write(request.Version);
if (this.versionToUse >= SerializationFormatVersions.Version18)
{
this.binaryWriter.Write((ushort)request.DeleteMode);
}
else
{
if ((request.DeleteMode & ~DeleteMode.CascadeDelete) != DeleteMode.None)
{
throw new NotSupportedException("Marshaller protocol version " + this.versionToUse + " doesn't support DeleteMode other than CascadeDelete");
}
this.binaryWriter.Write(request.IsCascade);
}
}
public String Delete(String filename)
{
log.Debug(DateTime.Now.Ticks + " Delete: " + filename);
Console.WriteLine("#Delete: " + filename);
RequestDelete deleteRequest = new RequestDelete(filename);
log.Debug(DateTime.Now.Ticks + " [M] Send Delete: " + filename);
MetaserverResponse response = MetaserverClient.SendRequestToMetaserver(deleteRequest);
if (response.Status != ResponseStatus.Success)
{
Console.WriteLine("#DELETE Error closing on server " + filename);
log.Debug(DateTime.Now.Ticks + " Delete done: " + filename);
return("#DELETE Error deleting on server " + filename);
}
Console.WriteLine("#DELETE: Success: " + filename);
log.Debug(DateTime.Now.Ticks + " Delete done: " + filename);
return("#DELETE: Success: " + filename);
}
public Message CreateDeleteRequest(RmReference objectId)
{
if (objectId == null)
{
throw new ArgumentNullException("objectId");
}
RequestDelete deleteRequest = new RequestDelete();
deleteRequest.ResourceReferenceProperty = objectId.Value;
Message msgRequest = null;
lock (deleteRequest)
{
msgRequest = Message.CreateMessage(MessageVersion.Default, Constants.WsTransfer.DeleteAction, deleteRequest, new ClientSerializer(typeof(RequestDelete)));
ClientHelper.AddRmHeaders(deleteRequest, msgRequest);
}
return(msgRequest);
}
/// <summary>
/// 删除T_MM_Formula数据
/// </summary>
/// <param name="requestObject"></param>
/// <returns></returns>
public async Task <ResponseObject <bool> > DeleteAsync(RequestDelete <DeleteModel> requestObject)
{
try
{
//执行结果
var result = false;
//没有删除数据，返回错误信息
if (requestObject.PostData == null && requestObject.PostDataList == null)
{
return(ResponseUtil <bool> .FailResult(false, "PostData、PostDataList不能都为null"));
}
//批量删除的优先级高于单记录删除
if (requestObject.PostDataList != null && requestObject.PostDataList.Count > 0)
{
//批量删除
var ids = requestObject.PostDataList.Select(p => p.ID);
result = await _db.Instance.Updateable <TMMFormulaDbModel>()
.SetColumns(p => p.DeleteFlag == true)
.Where(p => ids.Contains(p.ID))
.ExecuteCommandAsync() > 0;
}
else
{
//单记录删除
result = await _db.Instance.Updateable <TMMFormulaDbModel>()
.SetColumns(p => p.DeleteFlag == true)
.Where(p => p.ID == requestObject.PostData.ID)
.ExecuteCommandAsync() > 0;
}
//返回执行结果
return(result ? ResponseUtil <bool> .SuccessResult(true) : ResponseUtil <bool> .FailResult(false, "删除数据失败，数据可能已删除!"));
}
catch (Exception ex)
{
//返回异常结果
return(ResponseUtil <bool> .FailResult(false, ex.Message));
}
}
/// <summary>
/// 删除T_BM_Package数据
/// </summary>
/// <param name="requestObject"></param>
/// <returns></returns>
public async Task <ResponseObject <bool> > DeleteAsync(RequestDelete <DeleteModel> requestObject, CurrentUser currentUser)
{
try
{
//执行结果
var result = false;
//没有删除数据，返回错误信息
if (requestObject.PostData == null && requestObject.PostDataList == null)
{
return(ResponseUtil <bool> .FailResult(false, "PostData、PostDataList不能都为null"));
}
//批量删除的优先级高于单记录删除
if (requestObject.PostDataList != null && requestObject.PostDataList.Count > 0)
{
//批量删除
var mainIds = requestObject.PostDataList.Select(p => p.ID).ToList();
await _db.Instance.Updateable <TBMPackageDbModel>()
.SetColumns(p => p.DeleteFlag == true)
.Where(p => mainIds.Contains(p.ID) && p.CompanyId == currentUser.CompanyID)
.ExecuteCommandAsync();
}
else
{
//单条删除
await _db.Instance.Updateable <TBMPackageDbModel>()
.SetColumns(p => p.DeleteFlag == true)
.Where(p => p.ID == requestObject.PostData.ID && p.CompanyId == currentUser.CompanyID)
.ExecuteCommandAsync();
}
//返回执行结果
return(ResponseUtil <bool> .SuccessResult(true));
}
catch (Exception ex)
{
//返回异常结果
return(ResponseUtil <bool> .FailResult(false, ex.Message));
}
}
public static RequestDelete MakeRequestDelete(ServiceVertexType myVertexType, IEnumerable <Int64> myVertexIDs = null, ServiceDeletePayload myDeletePayload = null)
{
RequestGetVertices PreRequest = null;
if (myVertexIDs != null)
{
PreRequest = new RequestGetVertices(myVertexType.Name, myVertexIDs);
}
else
{
PreRequest = new RequestGetVertices(myVertexType.Name);
}
RequestDelete Request = new RequestDelete(PreRequest);
if (myDeletePayload != null)
{
foreach (var toDel in myDeletePayload.ToBeDeletedAttributes)
{
Request.AddAttribute(toDel);
}
}
return(Request);
}
/// <summary>
/// 删除配色项目，所有节点
/// </summary>
/// <param name="requestDelete"></param>
/// <returns></returns>
public async Task <ResponseObject <bool> > DeleteAllAsync(RequestDelete <DeleteModel> requestDelete, CurrentUser currentUser)
{
try
{
//如果没有新增数据，返回错误信息
if (requestDelete.PostData == null)
{
return(ResponseUtil <bool> .FailResult(false, "PostData至少包含一条数据"));
}
var toDelteModel = _db.Instance.Queryable <TMMColorItemDbModel> ()
.Where(p => p.PackageId == requestDelete.PostData.ID).Select(p => p).ToList();
var dic = _db.Instance.Queryable <TBMDictionaryDbModel, TBMDictionaryTypeDbModel>((t, t1) => new object[] {
JoinType.Inner, t.TypeId == t1.ID
}).Where((t, t1) => t1.TypeName == "配色方案" && t1.CompanyId == currentUser.CompanyID).ToList();
var packageList = _db.Instance.Queryable <TBMPackageDbModel>().Where(p => p.CompanyId == currentUser.CompanyID).ToList();
foreach (var itemDel in toDelteModel)
{
if (_db.Instance.Queryable <TMMBOMMainDbModel, TMMBOMDetailDbModel>((t, t1) => new object[] { JoinType.Inner, t.ID == t1.MainId })
.Any((t, t1) => t.PackageId == itemDel.PackageId && t1.ItemId == itemDel.ItemId)) //此包型的BOM是否包含被删除的配色项目
{
string itemName = dic.Where(p => p.ID == itemDel.ItemId).FirstOrDefault()?.DicValue;
string packageName = packageList.Where(p => p.ID == itemDel.PackageId).FirstOrDefault()?.DicValue;
bool isExis = _db.Instance.Queryable <TMMProductionOrderDetailDbModel, TMMProductionOrderMainDbModel>((t, t1) => new object[] {
JoinType.Inner, t.MainId == t1.ID
}).Any((t, t1) => t1.DeleteFlag == false &&
SqlFunc.IsNull(t1.MRPStatus, false) == false && t1.AuditStatus == 2 &&
t.PackageId == itemDel.PackageId
); // 是否存在没有算料的生产单
if (isExis)
{
throw new Exception($"已审核通过的生产单，正在使用包型'{packageName}'Bom的配色项目{itemName},请将生产单算料，或者删除包型Bom的配色项目'{itemName}'");
}
//删除此包型所有的配色项目
var deleteColorSolution = _db.Instance.Deleteable <TMMColorSolutionDetailDbModel>().Where(p => p.ItemId == itemDel.ItemId &&
SqlFunc.Subqueryable <TMMColorSolutionMainDbModel>().Where(p1 => p1.ID == p.MainId && p1.PackageId == itemDel.PackageId).Any());
//删除BOM
_db.Instance.Deleteable <TMMBOMDetailDbModel>().Where(p => p.ItemId == itemDel.ItemId && SqlFunc.Subqueryable <TMMBOMMainDbModel>().
Where(p1 => p1.ID == p.MainId && p1.PackageId == itemDel.PackageId).Any());
}
}
var result = await _db.Instance.Deleteable <TMMColorItemDbModel>()
.Where(p => p.PackageId == requestDelete.PostData.ID)
.ExecuteCommandAsync() > 0;
//返回执行结果
return(result ? ResponseUtil <bool> .SuccessResult(true) : ResponseUtil <bool> .FailResult(false, "新增数据失败!"));
}
catch (Exception ex)
{
//返回异常结果
return(ResponseUtil <bool> .FailResult(false, ex.Message));
}
}
/// <summary>
/// Deserialize <see cref="IZooKeeperRequest"/>
/// </summary>
/// <param name="xid">the callid</param>
/// <param name="type">type of the call</param>
/// <param name="sessionState">The PerSession State</param>
/// <param name="ringMasterRequest">The ring master request.</param>
/// <exception cref="System.ArgumentException">unknown type + type</exception>
/// <returns>The Zookeeper Request</returns>
private IZooKeeperRequest DeserializeZooKeeperRequest(int xid, ZooKeeperRequestType type, ZkprPerSessionState sessionState, out IRingMasterRequest ringMasterRequest)
{
ringMasterRequest = null;
switch (type)
{
case ZooKeeperRequestType.Notification: // "0" for Createing a session
ringMasterRequest = null;
return(this.DeserializeNotification(xid));
case ZooKeeperRequestType.CreateSession:
ZkprProtocolMessages.CreateSession cs = this.DeserializeCreateSession();
ringMasterRequest = new RequestInit((ulong)cs.SessionId, cs.IsNullPassword ? string.Empty : cs.Password);
sessionState.ConnectRecieved = true;
return(cs);
case ZooKeeperRequestType.Exists:
ZkprProtocolMessages.Exists ex = this.DeserializeExists(xid);
ringMasterRequest = new RequestExists(ex.Path, ex.Watch == false ? null : new Watcher((ulong)xid, WatcherKind.OneUse));
return(ex);
case ZooKeeperRequestType.GetChildren:
ZkprProtocolMessages.GetChildren gc = this.DeserializeGetChildren(xid);
ringMasterRequest = new RequestGetChildren(gc.Path, gc.Watch == false ? null : new Watcher((ulong)xid, WatcherKind.OneUse), null);
return(gc);
case ZooKeeperRequestType.GetChildren2:
ZkprProtocolMessages.GetChildren2 gc2 = this.DeserializeGetChildren2(xid);
ringMasterRequest = new RequestGetChildren(gc2.Path, gc2.Watch == false ? null : new Watcher((ulong)xid, WatcherKind.OneUse), null);
return(gc2);
case ZooKeeperRequestType.GetData:
ZkprProtocolMessages.GetData gd = this.DeserializeGetData(xid);
ringMasterRequest = new RequestGetData(gd.Path, RequestGetData.GetDataOptions.None, gd.Watch == false ? null : new Watcher((ulong)xid, WatcherKind.OneUse));
return(gd);
case ZooKeeperRequestType.Create:
ZkprProtocolMessages.Create cr = this.DeserializeCreate(xid);
IReadOnlyList <Acl> acls = this.TranslateZkprAclListToRMAclList(cr.Acls);
CreateMode cm = this.TranslateZkprCreatFlagsToRmCreateMode(cr.Flags);
ringMasterRequest = new RequestCreate(cr.Path, cr.Data, acls, cm);
return(cr);
case ZooKeeperRequestType.Create2:
ZkprProtocolMessages.Create2 cr2 = this.DeserializeCreate2(xid);
IReadOnlyList <Acl> acls2 = this.TranslateZkprAclListToRMAclList(cr2.Acls);
CreateMode cm2 = this.TranslateZkprCreatFlagsToRmCreateMode(cr2.Flags);
ringMasterRequest = new RequestCreate(cr2.Path, cr2.Data, acls2, cm2);
return(cr2);
case ZooKeeperRequestType.SetData:
ZkprProtocolMessages.SetData sd = this.DeserializeSetData(xid);
ringMasterRequest = new RequestSetData(sd.Path, sd.Data, sd.Version);
return(sd);
case ZooKeeperRequestType.Delete:
ZkprProtocolMessages.Delete dl = this.DeserializeDelete(xid);
ringMasterRequest = new RequestDelete(dl.Path, dl.Version, false);
return(dl);
case ZooKeeperRequestType.Ping:
ringMasterRequest = null;
return(this.DeserializePing(xid));
case ZooKeeperRequestType.CloseSession:
ringMasterRequest = null;
sessionState.ConnectRecieved = false; // Renegotiate the CreateSession
return(this.DeserializeCloseSession(xid));
case ZooKeeperRequestType.GetACL:
ZkprProtocolMessages.GetACL ga = this.DeserializeGetACL(xid);
ringMasterRequest = new RequestGetAcl(ga.Path, null);
return(ga);
case ZooKeeperRequestType.SetACL:
ZkprProtocolMessages.SetACL sa = this.DeserializeSetACL(xid);
IReadOnlyList <Acl> sa_acls = this.TranslateZkprAclListToRMAclList(sa.Acls);
ringMasterRequest = new RequestSetAcl(sa.Path, sa_acls, sa.Version);
return(sa);
case ZooKeeperRequestType.Multi:
ZkprProtocolMessages.Multi mu = this.DeserializeMulti(xid);
IReadOnlyList <Op> rmOps = this.TranslateZkprOpsListToRmOpsList(mu.Ops);
ringMasterRequest = new RequestMulti(rmOps, false);
return(mu);
case ZooKeeperRequestType.Auth:
ZkprProtocolMessages.Auth au = this.DeserializeAuth(xid);
ringMasterRequest = new RequestSetAuth(au.RmAuthId);
return(au);
case ZooKeeperRequestType.Check:
case ZooKeeperRequestType.Sync:
case ZooKeeperRequestType.Reconfig:
case ZooKeeperRequestType.SetWatches:
case ZooKeeperRequestType.RemoveWatches:
case ZooKeeperRequestType.CreateContainer:
case ZooKeeperRequestType.DeleteContainer:
case ZooKeeperRequestType.Sasl:
case ZooKeeperRequestType.Error:
default:
break;
}
return(null);
}
/// <summary>
/// Creates a new pipelineable clear request
/// </summary>
/// <param name="myClearRequest">The clear request</param>
/// <param name="mySecurity">The security token of the request initiator</param>
/// <param name="myTransactionToken">The myOutgoingEdgeVertex transaction token</param>
public PipelineableDeleteRequest(RequestDelete myDeleteRequest, SecurityToken mySecurity,
Int64 myTransactionToken)
: base(mySecurity, myTransactionToken)
{
_request = myDeleteRequest;
}
private void CacheInvalidate(IRingMasterClientCache cache, IRingMasterRequest req)
{
if (cache == null || req == null)
{
return;
}
switch (req.RequestType)
{
case RingMasterRequestType.GetData:
case RingMasterRequestType.GetChildren:
case RingMasterRequestType.GetAcl:
case RingMasterRequestType.Exists:
return;
case RingMasterRequestType.Create:
{
cache.Invalidate(this.cachePrefix, req.Path);
cache.Invalidate(this.cachePrefix, PrefixedClientCache.GetParent(req.Path));
break;
}
case RingMasterRequestType.Delete:
{
RequestDelete delete = req as RequestDelete;
if (delete.IsCascade)
{
cache.Wipe(this.cachePrefix);
}
else
{
cache.Invalidate(this.cachePrefix, req.Path);
cache.Invalidate(this.cachePrefix, PrefixedClientCache.GetParent(req.Path));
}
break;
}
case RingMasterRequestType.Move:
{
RequestMove move = req as RequestMove;
cache.Invalidate(this.cachePrefix, move.Path);
cache.Invalidate(this.cachePrefix, PrefixedClientCache.GetParent(move.Path));
cache.Invalidate(this.cachePrefix, PrefixedClientCache.GetParent(move.PathDst));
break;
}
default:
{
cache.Invalidate(this.cachePrefix, req.Path);
AbstractRingMasterCompoundRequest list = req as AbstractRingMasterCompoundRequest;
if (list != null && list.Requests != null)
{
foreach (IRingMasterRequest child in list.Requests)
{
this.CacheInvalidate(cache, child);
}
}
break;
}
}
}
public TResult Delete <TResult>(sones.Library.Commons.Security.SecurityToken mySecurityToken, Int64 myTransactionToken, RequestDelete myRequestDelete, Converter.DeleteResultConverter <TResult> myOutputconverter)
{
return(_iGraphDB.Delete <TResult>(mySecurityToken,
myTransactionToken,
myRequestDelete,
myOutputconverter));
}
public void DoRequestDelete()
{
RequestDelete?.Invoke(this, EventArgs.Empty);
}
public TResult Delete <TResult>(sones.Library.Commons.Security.SecurityToken mySecurityToken, Int64 myTransactionToken, RequestDelete myRequestDelete, Converter.DeleteResultConverter <TResult> myOutputconverter)
{
throw new NotImplementedException();
}
public override void Delete(RequestDelete myDeleteRequest, SecurityToken mySecurityToken, Int64 myTransactionToken)
{
GetVertices(myDeleteRequest.ToBeDeletedVertices, myTransactionToken, mySecurityToken);
}
public CommandDeleteRow(string tableName, int id)
{
_request = new RequestDelete(tableName, id);
}
/// <summary> /// Deletes a set of vertices /// </summary> /// <param name="myDeleteRequest">The request that represents the delete operation</param> /// <param name="mySecurityToken">The current security token</param> /// <param name="myTransactionToken">The current transaction token</param> public abstract void Delete(RequestDelete myDeleteRequest, SecurityToken mySecurityToken, Int64 myTransactionToken);
private void OnRequestDelete(EventArgs e)
{
RequestDelete?.Invoke(this, e);
}
public async Task <ResponseObject <bool> > Delete(RequestDelete <DeleteModel> requestObject)
{
var user = TokenManager.GetCurentUserbyToken(Request.Headers);
return(await _service.DeleteAsync(requestObject, user));
}
/// <summary>
/// 删除T_WM_SalesMain数据
/// </summary>
/// <param name="requestObject">Delete请求参数</param>
/// <returns>返回响应结果对象，包括响应代码，删除操作结果</returns>
public async Task <ResponseObject <bool> > DeleteAsync(RequestDelete <DeleteModel> requestObject, CurrentUser currentUser)
{
var currDb = _db.Instance;//事务需要使用同一个 SqlSugarClient对象实例
try
{
if (requestObject.PostData == null && requestObject.PostDataList == null)
{
return(ResponseUtil <bool> .FailResult(false, "PostData、PostDataList不能都为null"));
}
//开启事务
currDb.BeginTran();
//删除标识
var mainFlag = true;
var detailFlag = true;
//var materList = BasicCacheGet.GetMaterial(currentUser);
List <int> IDS = new List <int>();
if (requestObject.PostDataList != null && requestObject.PostDataList.Count > 0)
{
IDS = requestObject.PostDataList.Select(p => p.ID).ToList();
mainFlag = await _db.Instance.Updateable <TWMSalesMainDbModel>()
.SetColumns(p => p.DeleteFlag == true)
.Where(p => IDS.Contains(p.ID))
.ExecuteCommandAsync() > 0;
}
else
{
IDS.Add(requestObject.PostData.ID);
//单条删除
mainFlag = await _db.Instance.Updateable <TWMSalesMainDbModel>()
.SetColumns(p => p.DeleteFlag == true)
.Where(p => p.ID == requestObject.PostData.ID)
.ExecuteCommandAsync() > 0;
}
//批量删除
foreach (int ids in IDS)
{
List <TSSMSalesOrderDetailDbModel> toEdit = new List <TSSMSalesOrderDetailDbModel>(); //可转销售单详细信息
var mainEntity = _db.Instance.Queryable <TWMSalesMainDbModel>().Where(P => P.ID == ids).First(); //可转销售单主表
var listItem = _db.Instance.Queryable <TSSMSalesOrderDetailDbModel>().
Where(t => t.MainId == mainEntity.SourceId).ToList(); //可转销售单详细信息
var whDetailList = currDb.Queryable <TWMSalesDetailDbModel>().Where(p => p.MainId == ids).ToList();
foreach (var item in whDetailList)
{
//var me = materList.Where(p => p.ID == item.MaterialId).FirstOrDefault();
//* decimal proNum = UnitChange.TranserUnit(me, UnitType.Warehouse, UnitType.Sales, item.ActualNum);
var m = listItem.Where(p => p.ID == item.SalesOrderDetailId).FirstOrDefault();
if (m != null)
{
//m.TransferNum = m.TransferNum + proNum;
m.TransferNum = m.TransferNum + item.SalesOrderActualNum;
toEdit.Add(m);
}
}
if (toEdit.Count() > 0)
{
_db.Instance.Updateable(toEdit).ExecuteCommand();
}
if (!_db.Instance.Queryable <TSSMSalesOrderDetailDbModel>().Any(p => p.TransferNum > 0 && p.MainId == mainEntity.SourceId))
{
_db.Instance.Updateable <TSSMSalesOrderMainDbModel>().Where(p => p.ID == mainEntity.SourceId).SetColumns(p => p.TransferStatus == false).ExecuteCommand();
}
else
{
_db.Instance.Updateable <TSSMSalesOrderMainDbModel>().Where(p => p.ID == mainEntity.SourceId).SetColumns(p => p.TransferStatus == true).ExecuteCommand();
}
}
//提交事务
currDb.CommitTran();
//返回执行结果
return(mainFlag && detailFlag ? ResponseUtil <bool> .SuccessResult(true) : ResponseUtil <bool> .FailResult(false, "删除数据失败!"));
}
catch (Exception ex)
{
//回滚事务
currDb.RollbackTran();
//返回异常结果
return(ResponseUtil <bool> .FailResult(false, ex.Message));
}
}
public async Task <ResponseObject <bool> > Delete(RequestDelete <DeleteModel> requestObject)
{
return(await _service.DeleteAsync(requestObject));
}
internal ServiceDeletePayload(RequestDelete myRequestDelete)
{
this.ToBeDeletedAttributes = (myRequestDelete.ToBeDeletedAttributes == null)
? null : myRequestDelete.ToBeDeletedAttributes.ToList();
}
/// <summary>
/// 删除T_WM_ProductionWhMain数据
/// </summary>
/// <param name="requestObject">Delete请求参数</param>
/// <returns>返回响应结果对象，包括响应代码，删除操作结果</returns>
public async Task <ResponseObject <bool> > DeleteAsync(RequestDelete <DeleteModel> requestObject, CurrentUser currentUser)
{
var currDb = _db.Instance;//事务需要使用同一个 SqlSugarClient对象实例
try
{
if (requestObject.PostData == null && requestObject.PostDataList == null)
{
return(ResponseUtil <bool> .FailResult(false, "PostData、PostDataList不能都为null"));
}
//开启事务
currDb.BeginTran();
//删除标识
var mainFlag = true;
var detailFlag = true;
var materList = BasicCacheGet.GetMaterial(currentUser);
if (requestObject.PostDataList != null && requestObject.PostDataList.Count > 0)
{
//批量删除
var mainIds = requestObject.PostDataList.Select(p => p.ID).ToList();
foreach (int ids in mainIds)
{
List <TMMWhApplyDetailDbModel> toEdit = new List <TMMWhApplyDetailDbModel>();
var mainEntity = _db.Instance.Queryable <TWMProductionMainDbModel>().Where(P => P.ID == ids).First();
var listItem = _db.Instance.Queryable <TMMWhApplyDetailDbModel>().Where(t => t.MainId == mainEntity.SourceId).ToList();
var whDetailList = currDb.Queryable <TWMProductionWhDetailDbModel>().Where(p => p.MainId == ids).ToList();
foreach (var item in whDetailList)
{
var me = materList.Where(p => p.ID == item.MaterialId).FirstOrDefault();
var m = listItem.Where(p => p.ID == item.ProOrderDetailId).FirstOrDefault();
m.TransNum = m.TransNum + item.ProActualNum;
toEdit.Add(m);
}
if (toEdit != null && toEdit.Count() > 0)
{
_db.Instance.Updateable <TMMWhApplyDetailDbModel>(toEdit).ExecuteCommand();
}
if (!_db.Instance.Queryable <TMMWhApplyDetailDbModel>().Any(p => p.TransNum > 0 && p.MainId == mainEntity.SourceId))
{
_db.Instance.Updateable <TMMWhApplyMainDbModel>().Where(p => p.ID == mainEntity.SourceId).SetColumns(p => p.TransferFlag == false).ExecuteCommand();
}
else
{
_db.Instance.Updateable <TMMWhApplyMainDbModel>().Where(p => p.ID == mainEntity.SourceId).SetColumns(p => p.TransferFlag == true).ExecuteCommand();
}
}
mainFlag = await _db.Instance.Updateable <TWMProductionWhMainDbModel>()
.SetColumns(p => p.DeleteFlag == true)
.Where(p => mainIds.Contains(p.ID))
.ExecuteCommandAsync() > 0;
}
else
{
List <TMMWhApplyDetailDbModel> toEdit = new List <TMMWhApplyDetailDbModel>();
var mainEntity = _db.Instance.Queryable <TWMProductionWhMainDbModel>().Where(P => P.ID == requestObject.PostData.ID).First();
var listItem = _db.Instance.Queryable <TMMWhApplyDetailDbModel>().Where(t => t.MainId == mainEntity.SourceId).ToList();
var whDetailList = currDb.Queryable <TWMProductionWhDetailDbModel>().Where(p => p.MainId == requestObject.PostData.ID).ToList();
foreach (var item in whDetailList)
{
var me = materList.Where(p => p.ID == item.MaterialId).FirstOrDefault();
var m = listItem.Where(p => p.ID == item.ProOrderDetailId).FirstOrDefault();
if (m != null)
{
m.TransNum = m.TransNum + item.ProActualNum;
toEdit.Add(m);
}
}
if (toEdit != null && toEdit.Count() > 0)
{
_db.Instance.Updateable <TMMWhApplyDetailDbModel>(toEdit).ExecuteCommand();
}
if (!_db.Instance.Queryable <TMMWhApplyDetailDbModel>().Any(p => p.TransNum > 0 && p.MainId == mainEntity.SourceId))
{
_db.Instance.Updateable <TMMWhApplyMainDbModel>().Where(p => p.ID == mainEntity.SourceId).SetColumns(p => p.TransferFlag == false).ExecuteCommand();
}
else
{
_db.Instance.Updateable <TMMWhApplyMainDbModel>().Where(p => p.ID == mainEntity.SourceId).SetColumns(p => p.TransferFlag == true).ExecuteCommand();
}
//单条删除
mainFlag = await _db.Instance.Updateable <TWMProductionWhMainDbModel>()
.SetColumns(p => p.DeleteFlag == true)
.Where(p => p.ID == requestObject.PostData.ID)
.ExecuteCommandAsync() > 0;
}
//提交事务
currDb.CommitTran();
//返回执行结果
return(mainFlag && detailFlag ? ResponseUtil <bool> .SuccessResult(true) : ResponseUtil <bool> .FailResult(false, "删除数据失败!"));
}
catch (Exception ex)
{
//回滚事务
currDb.RollbackTran();
//返回异常结果
return(ResponseUtil <bool> .FailResult(false, ex.Message));
}
}
private void Delete() => RequestDelete?.Invoke(this, EventArgs.Empty);
