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 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);
