public override int GetHashCode() { int hash = 1; if (MsgType.Length != 0) { hash ^= MsgType.GetHashCode(); } if (AccountStatusRequestId.Length != 0) { hash ^= AccountStatusRequestId.GetHashCode(); } if (MarginReqmtRptType.Length != 0) { hash ^= MarginReqmtRptType.GetHashCode(); } if (Account != 0UL) { hash ^= Account.GetHashCode(); } hash ^= marginAmounts_.GetHashCode(); if (RejectReason.Length != 0) { hash ^= RejectReason.GetHashCode(); } if (Text.Length != 0) { hash ^= Text.GetHashCode(); } if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } return(hash); }
/// <summary> /// Rejects this change. /// </summary> /// <param name="reason">The reason of the reject.</param> public void Reject(RejectReason reason) { /* * Quando viene fatta una "reject" ogni singola * entity altro non fa che creare una nuova "change" * e piazzarla nel ForwardStack in questo modo siamo * in grado di fare "Redo". Alla luce di una AtomicChange * è evidente che questo meccanismo ci sbomba un po' * tutto... dimostrando che dovrebbeessere il sistema di * change tracking a fare la cosa. In realtà non è possibile * perchè il sistema non sa quale sia il valore attuale * che dovrebbe essere cachato nel ForwardStack. * * Quello che dovremmo fare quindi è creare qui una * nuova AtomicOperation in cui fare la reject e poi * infilare quella nel ForwardStack. L'inghippo è che non * abbiamo una reference al motore di Change Tracking... * * in questo momento abbiamo uno special case sul servizio * in fase di reject che fa esattamente questo. */ var reversed = this.changes.ToArray().Reverse(); foreach (var c in reversed) { c.Item1.Reject(reason); } this.OnRejected(new RejectedEventArgs(reason)); }
public IPromise Reject(RejectReason reason) { RejectReason = reason; Reject(); return(this); }
/// <summary> /// The Reject element will reject an incoming call. /// </summary> /// <param name="reason">The reason to list as why the call was rejected.</param> /// <returns></returns> public static Reject Create(RejectReason? reason) { var reject = new Reject(); reject.Reason = reason == null ? null : reason.ToString(); return reject; }
public int UpdateRow(DbTransaction pTran, RejectReason RejectReason, bool CreateTransaction) { int intRow = 0; DbTransaction objTran = pTran; Exception exception = null; try { if (pTran == null && CreateTransaction == true) { objTran = RejectReasonData.CreateTransaction(); } intRow = RejectReasonData.UpdateRow(objTran, RejectReason); if (pTran == null && objTran != null && CreateTransaction == true) { RejectReasonData.CommitTransaction(objTran, true); objTran = null; } } catch (Exception EX) { exception = EX; if (pTran == null && objTran != null && CreateTransaction == true) { RejectReasonData.RollbackTransaction(objTran, true); objTran = null; } } finally { } return(intRow); }
private bool Rejected(IPacket msg, RejectReason reason) { Socket.SendAsync(msg); server.PluginHost.OnJoinRejected(this, reason); Disconnect(); return(false); }
public RejectPDU(byte[] buffer, int offset) : base(buffer, offset) { Reason = (RejectReason)OpCodeSpecificHeader[1]; StatSN = BigEndianConverter.ToUInt32(OpCodeSpecific, 4); ExpCmdSN = BigEndianConverter.ToUInt32(OpCodeSpecific, 8); MaxCmdSN = BigEndianConverter.ToUInt32(OpCodeSpecific, 12); DataSN_R2TSN = BigEndianConverter.ToUInt32(OpCodeSpecific, 16); }
/// <summary> /// Adds a Reject Element to the Response /// </summary> /// <param name="reason">The reason for rejection.</param> public TwiMLBuilder Reject(RejectReason reason = RejectReason.rejected) { return(AddVerb(Verb.Reject, string.Empty, new { reason = reason })); }
private void Peer_OnConnectionFailed(IConnection conn, RejectReason reason) { if (logger.LogEnabled()) { logger.Log($"Failed to connect to {conn.EndPoint} with reason {reason}"); } Player?.MarkAsDisconnected(); _disconnected?.Invoke(reason.ToClientStoppedReason()); Cleanup(); }
private static RejectReasonDTO mapRejectReason(RejectReason rejectReason) { RejectReasonDTO _RejectReasonMap = new RejectReasonDTO(); _RejectReasonMap = fillRejectReasonDTObyRejectReasonID(rejectReason.Id); return(_RejectReasonMap); }
public int DeleteRow(DbTransaction pTran, RejectReason RejectReason) { int intRows = 0; DbParameter[] Parameters = new DbParameter[1]; Parameters[0] = _getIdParameter(RejectReason.Id, ParameterDirection.Input); intRows = ExecuteNonQuery(pTran, "[Lookups].[DeleteRejectReason]", Parameters); return(intRows); }
/// <summary> /// Rejects this change. /// </summary> public void Reject(RejectReason reason) { reason.EnsureIsDefined(); Ensure.That(reason) .Named("reason") .If(v => v == RejectReason.None) .Then((v, n) => { throw new ArgumentException("Unsupported RejectReason value.", n); }); this.OnReject(reason); this.OnRejected(new RejectedEventArgs(reason)); }
public void RejectTest() { var document = CreateDocument() .Bind(doc => AddFile(doc, "123")) .Bind(doc => doc.SendForApproval()) .Bind(doc => RejectReason.Create("Rejected") .Bind(doc.Reject)); document.Match( Succ: doc => Assert.Equal(DocumentStatus.Rejected, doc.Status), Fail: errors => Assert.True(false, "Should never get here")); }
internal void FailedToConnect(Connection connection, RejectReason reason) { if (_logger.Enabled(LogType.Warning)) { _logger.Log(LogType.Warning, $"Connection Failed to connect: {reason}"); } RemoveConnection(connection); // tell high level OnConnectionFailed?.Invoke(connection, reason); }
public RejectReasonList SelectRows(DbTransaction pTran, System.Int32?Id, System.String name, System.String nameAr) { RejectReasonList RejectReasonList = new RejectReasonList(); Exception exception = null; DbParameter[] Parameters = new DbParameter[3]; Parameters[0] = _getIdParameter(Id, ParameterDirection.Input); Parameters[1] = _getnameParameter(name, ParameterDirection.Input); Parameters[2] = _getnameArParameter(nameAr, ParameterDirection.Input); DbDataReader Dr = ExecuteReader(pTran, "[Lookups].[SelectRejectReason]", Parameters); try { if (Dr != null) { while (Dr.Read()) { RejectReason RejectReason = new RejectReason(); if (Dr["Id"] != DBNull.Value) { RejectReason.Id = (System.Int32)Dr["Id"]; } if (Dr["name"] != DBNull.Value) { RejectReason.name = (System.String)Dr["name"]; } if (Dr["nameAr"] != DBNull.Value) { RejectReason.nameAr = (System.String)Dr["nameAr"]; } RejectReasonList.FillRow(RejectReason); RejectReason = null; } } } catch (Exception Ex) { exception = Ex; } finally { if (Dr != null) { if (Dr.IsClosed == false) { Dr.Close(); } Dr = null; } } return(RejectReasonList); }
internal void FailedToConnect(Connection connection, RejectReason reason) { if (logger.IsLogTypeAllowed(LogType.Log)) { logger.Log($"Connection Failed to connect: {reason}"); } RemoveConnection(connection); // tell high level OnConnectionFailed?.Invoke(connection, reason); }
private static ActionResult GetNoPermisionJsonResult(RejectReason reason, string logoutUrl) { object Reject = new RejectResult(reason, logoutUrl); return(new JsonDataContractResult { Data = Reject, ContentType = "", ContentEncoding = Encoding.UTF8, JsonRequestBehavior = JsonRequestBehavior.AllowGet }); }
public int UpdateRow(DbTransaction pTran, RejectReason RejectReason) { int intRows = 0; DbParameter[] Parameters = new DbParameter[3]; Parameters[0] = _getIdParameter(RejectReason.Id, ParameterDirection.Input); Parameters[1] = _getnameParameter(RejectReason.name, ParameterDirection.Input); Parameters[2] = _getnameArParameter(RejectReason.nameAr, ParameterDirection.Input); intRows = ExecuteNonQuery(pTran, "[Lookups].[UpdateRejectReason]", Parameters); return(intRows); }
public static void RejectRequest(ExceptionContext filterContext, RejectReason reason, SessionData sessionData) { string logoutUrl = "/LoginService/Logout"; if (filterContext.HttpContext.Request.IsAjaxRequest()) { filterContext.Result = GetNoPermisionJsonResult(reason, logoutUrl); } else { filterContext.Result = GetNoPermisionRedirectResult(reason, HomePageUrl); } }
public static ClientStoppedReason ToClientStoppedReason(this RejectReason reason) { switch (reason) { default: case RejectReason.None: return(ClientStoppedReason.None); case RejectReason.Timeout: return(ClientStoppedReason.ConnectingTimeout); case RejectReason.ServerFull: return(ClientStoppedReason.ServerFull); case RejectReason.ClosedByPeer: return(ClientStoppedReason.ConnectingCancel); } }
public void OnJoinRejected(IClient client, RejectReason reason) { foreach (var plugin in this) { try { if (plugin.Enabled) { plugin.Plugin.OnJoinRejected(client, reason); } } catch (Exception ex) { OnError(plugin, nameof(OnJoinRejected), ex); } } }
public void RejectEmptyReasonErrorTest() { var document = CreateDocument() .Bind(doc => AddFile(doc, "123")) .Bind(doc => RejectReason.Create(string.Empty) .Bind(doc.Reject)); document.Match( Succ: _ => Assert.True(false, "Should never get here"), Fail: errors => { Assert.True(errors.Count == 1); Assert.True(errors.Head.Equals(new EmptyValueError("Reject reason"))); }); }
private static RejectReasonDTO fillRejectReasonDTObyRejectReasonID(int?RejectReasonID) { RejectReasonDTO _RejectReasonDTO = default(RejectReasonDTO); RejectReason _RejectReason = _RejectReasonList.FirstOrDefault(i => i.Id == RejectReasonID.Value); if (_RejectReason != default(RejectReason)) { _RejectReasonDTO = new RejectReasonDTO(); _RejectReasonDTO.Id = _RejectReason.Id; _RejectReasonDTO.name = _RejectReason.name; _RejectReasonDTO.nameAr = _RejectReason.nameAr; } return(_RejectReasonDTO); }
public void Parse(byte[] headerData, int headerOffset) { Header = new BasicHeaderSegment(); Header.ReadFrom(headerData, headerOffset); if (Header.OpCode != OpCode.Reject) { throw new InvalidProtocolException("Invalid opcode in response, expected " + OpCode.Reject + " was " + Header.OpCode); } Reason = (RejectReason)headerData[headerOffset + 2]; StatusSequenceNumber = Utilities.ToUInt32BigEndian(headerData, headerOffset + 24); ExpectedCommandSequenceNumber = Utilities.ToUInt32BigEndian(headerData, headerOffset + 28); MaxCommandSequenceNumber = Utilities.ToUInt32BigEndian(headerData, headerOffset + 32); DataSequenceNumber = Utilities.ToUInt32BigEndian(headerData, headerOffset + 36); }
public void RejectInvalidDocumentStatusErrorTest() { var document = CreateDocument() .Bind(doc => AddFile(doc, "123")) .Bind(doc => RejectReason.Create("Rejected") .Bind(doc.Reject)); document.Match( Succ: _ => Assert.True(false, "Should never get here"), Fail: errors => { Assert.True(errors.Count == 1); Assert.True(errors.Head.Equals(new InvalidStatusError(DocumentStatus.WaitingForApproval, DocumentStatus.Draft))); }); }
public int InsertRow(DbTransaction pTran, RejectReason RejectReason) { int intRows = 0; DbParameter[] Parameters = new DbParameter[3]; Parameters[0] = _getIdParameter(RejectReason.Id, ParameterDirection.Output); Parameters[1] = _getnameParameter(RejectReason.name, ParameterDirection.Input); Parameters[2] = _getnameArParameter(RejectReason.nameAr, ParameterDirection.Input); intRows = ExecuteNonQuery(pTran, "[Lookups].[InsertRejectReason]", Parameters); if (Parameters[0].Value != DBNull.Value) { RejectReason.Id = (System.Int32)Parameters[0].Value; } return(intRows); }
public void OnJoinRejected(IClient client, RejectReason reason) { ((AresServer)server).Stats.Rejected++; lock (plugins) { foreach (var plugin in plugins) { try { if (plugin.Enabled) { plugin.Plugin.OnJoinRejected(client, reason); } } catch (Exception ex) { OnError(plugin, "OnJoinRejected", ex); } } } }
public void OnJoinRejected(IClient client, RejectReason reason) { lock (scripts) { foreach (var s in scripts) { int index = s.Room.Users.Items.FindIndex((x) => ((User)x).Client == client); if (index < 0) { continue; } try { s.Engine.CallGlobalFunction("onJoinRejected", s.Room.Users[index], (int)reason); } catch (JavaScriptException jex) { OnError(jex); } finally { s.ResetCounters(); } } } }
public static bool MapRejectReasonAsInput(RejectReasonDTO rejectReasonDTO) { bool result = default(bool); _RejectReason = new RejectReason(); if (rejectReasonDTO != null) { // RejectReason Data part _RejectReason.Id = rejectReasonDTO.Id; _RejectReason.name = rejectReasonDTO.name; _RejectReason.nameAr = rejectReasonDTO.nameAr; result = true; } return(result); }
/// <summary> /// Initializes a new instance of the <see cref="RejectedEventArgs"/> class. /// </summary> /// <param name="reason">The reason.</param> public RejectedEventArgs( RejectReason reason ) { this.Reason = reason; }
/// <summary> /// Constructs a new reject exception instance /// </summary> /// <param name="reason">The reject reason</param> public RejectException(RejectReason reason) { this.Reason = reason; }
public RejectMessage(string rejectedCommand, RejectReason reason, string reasonText) { this.rejectedCommand = rejectedCommand; this.reason = reason; this.reasonText = reasonText; }
/// <summary> /// Called in order to perform the undo operation. /// </summary> /// <param name="reason">The reason of the undo.</param> /// If the RejectReason is Revert the Bookmark cannot be null.</param> protected virtual void OnUndo( RejectReason reason /*, IBookmark bmk */ ) { lock ( SyncRoot ) { var last = this.backwardChangesStack.Last(); /* * Questo special case mi fa veramente cagare... * dovremmo poter passare alla change il servizio * di change tracking e lasciare che sia lei a * decidere cosa fare... */ if ( last is AtomicChange ) { using ( var tmp = this.BeginAtomicOperation( AddChangeBehavior.UndoRequest ) ) { last.Reject( reason ); /* * Qui dovrebbe anche cercare di deregistrare * le eventuali entità "transient" presenti * nella atomic change * * Dovremmo valutare se ha senso che le transient * entities vengano registrate nella AtomicChange o no * a quanto pare non c'è nessuna logica legata al HasTransientEntities * che abbia qualcosa a che spartire con le Atomic Operation. Dobbiamo * testare un po' di scenari limite. */ tmp.Complete(); } } else { last.Reject( reason ); last.GetChangedEntities().ForEach( entity => tryUnregisterTransient( entity, null ) ); } } }
/// <summary> /// Called in order to perform the redo operation. /// </summary> /// <param name="reason">The reason of the redo request.</param> protected virtual void OnRedo( RejectReason reason ) { lock ( SyncRoot ) { var last = this.forwardChangesStack.Last(); /* * Questo special case mi fa veramente cagare... * dovremmo poter passare alla change il servizio * di change tracking e lasciare che sia lei a * decidere cosa fare... */ if ( last is AtomicChange ) { using ( var tmp = this.BeginAtomicOperation( AddChangeBehavior.RedoRequest ) ) { last.Reject( reason ); tmp.Complete(); } } else { last.Reject( reason ); } } }
public int DeleteRow(RejectReason RejectReason) { DbTransaction Tran = null; return(DeleteRow(Tran, RejectReason)); }
public int UpdateRow(RejectReason RejectReason) { DbTransaction Tran = null; return(UpdateRow(Tran, RejectReason)); }
/// <summary> /// Notifies the handle that the transaction /// has been rejected /// </summary> /// <param name="reason">The reject reason</param> public override void FeedReject(RejectReason reason) { _source.SetException(new RejectException(reason)); }
/// <summary> /// Adds a Reject Element to the Response /// </summary> /// <param name="reason">The reason for rejection.</param> public TwiMLBuilder Reject(RejectReason reason = RejectReason.rejected) { return AddVerb(Verb.Reject, string.Empty, new { reason = reason }); }
public XDocument RejectTranslationJob(string id, RejectReason reason, string comments, string captcha, bool requeue) { try { string url = baseUrl + "translate/job/" + id + "/"; var data = new Dictionary<string, object>(); data.Add("reason", reason.ToString().ToLower()); data.Add("comment", comments); data.Add("captcha", captcha); data.Add("follow_up", requeue ? "requeue" : "cancel"); return api.Call(url, HttpMethod.Put, data, requiresAuthentication: true); } catch (MyGengoException x) { throw x; } catch (Exception x) { throw new MyGengoException(x.Message, x); } }
/// <summary> /// The Reject element will reject an incoming call. /// </summary> /// <param name="reason">The reason to list as why the call was rejected.</param> /// <returns></returns> public Response Reject(RejectReason reason) { Elements.Add(Element.Reject.Create(reason)); return this; }
/// <summary> /// Handles the change rejected event. /// </summary> /// <param name="change">The change that raises the rejected event.</param> /// <param name="reason">The reason of the event raise.</param> protected virtual void OnChangeRejected( IChange change, RejectReason reason ) { this.OnUnwire( change ); switch ( reason ) { case RejectReason.Undo: case RejectReason.RejectChanges: case RejectReason.Revert: lock ( SyncRoot ) { this.backwardChangesStack.Remove( change ); } break; case RejectReason.Redo: lock ( SyncRoot ) { this.forwardChangesStack.Remove( change ); } break; case RejectReason.None: throw new ArgumentOutOfRangeException(); default: throw new EnumValueOutOfRangeException(); } }
/// <summary> /// Notifies the handle that the transaction /// has been rejected /// </summary> /// <param name="reason">The reject reason</param> public abstract void FeedReject(RejectReason reason);