public static void ErrorDetected(string info = "", ReasonType reasonType = ReasonType.OtherError)
{
switch (reasonType)
{
case ReasonType.ResourceDictionaryError:
PrintAndSaveToLog($"ResourceDictionary doesn't contain required {info} resource.");
break;
case ReasonType.ICollectionError:
PrintAndSaveToLog($"ICollection error: {info}.");
break;
case ReasonType.Exception:
PrintAndSaveToLog($"Exception catched: {info}");
break;
case ReasonType.NullError:
PrintAndSaveToLog($"{info} is null.");
break;
case ReasonType.OtherError:
PrintAndSaveToLog($"Undefined error: {info}.");
break;
default:
PrintAndSaveToLog("Bad day...");
break;
}
void PrintAndSaveToLog(string data)
{
Console.WriteLine(data);
Log.Add(data);
}
}
//public override void Init(ulong characterId, int dataId)
//{
// base.Init(characterId, dataId);
//}
//输出成一个objdata用于客户端创建
public ObjData DumpObjData(ObjDropItem _this, ReasonType reason)
{
var data = ObjBase.GetImpl().DumpObjData(_this, reason);
data.Pos = Utility.MakePositionDataByPosAndDir(_this.OrginPos, _this.GetDirection());
var span = DateTime.Now - _this.mDropTime;
data.Owner = new Uint64Array();
data.Owner.Items.AddRange(_this.OwnerList);
data.ExtData.Add(60 - span.Seconds); //temp
data.TargetPos.Add(new Vector2Int32
{
x = Utility.MultiplyPrecision(_this.GetPosition().X),
y = Utility.MultiplyPrecision(_this.GetPosition().Y)
});
if (DateTime.Now.GetDiffSeconds(_this.mDropTime) > ObjDropItem.DROP_TIME)
{
data.ExtData.Add(0);
}
else
{
data.ExtData.Add(1);
}
return(data);
}
public AppendEntriesResponse(long ownTerm, bool success, ReasonType reasonType = ReasonType.None, string reason = null)
{
CurrentTerm = ownTerm;
IsSuccess = success;
Reason = reason;
ReasonType = ReasonType;
}
public WaypointEventArgs(ReasonType t, PathGroup g, RobotPath s, WayPoint pt)
{
Reason = t;
Group = g;
Path = s;
Point = pt;
}
public WaypointEventArgs(ReasonType t)
{
Reason = t;
Group = null;
Path = null;
Point = null;
}
/// <summary>
/// Method to get reasons
/// </summary>
/// <param name="reasonType">Reason type</param>
/// <returns>List of reasons</returns>
public List <Return_Reason> GetReasons(ReasonType reasonType)
{
var dateStart = DateTime.Now;
Performancelog.Debug($"Start,ReasonManager,GetReasons,{string.Empty},{DateTime.Now:hh.mm.ss.ffffff}");
var type = (char)reasonType;
var reasons = new List <Return_Reason>();
var store = CacheManager.GetStoreInfo();
var offSet = store?.OffSet ?? 0;
if (type != '\0')
{
reasons = _reasonService.GetReasons(type);
}
if (reasons == null || reasons.Count == 0)
{
reasons = new List <Return_Reason>
{
new Return_Reason
{
Description = _resourceManager.GetResString(offSet, 207), //"<No reasons defined>"
Reason = "0"
}
};
}
Performancelog.Debug($"End,ReasonManager,GetReasons,{DateTime.Now.Subtract(dateStart).TotalMilliseconds},{DateTime.Now:hh.mm.ss.ffffff}");
return(reasons);
}
public Task <List <Reason> > GetReasonsAsync(ReasonType reasonType, ImportanceType importanceType)
{
// in some cases it makes sense to async await but in cases like these the overhead of 'async'
// is not worth it and it makes more sense to just return the Task and the calling method here would probably
// already have the async await overhead and EF would handle that gracefully
return(_reasonContext.Reasons.Where(x => x.ImportanceType == importanceType && x.ReasonType == reasonType).ToListAsync());
}
/// <summary>
/// 输出成一个objdata用于客户端创建
/// </summary>
/// <returns></returns>
public ObjData DumpObjData(ObjRetinue _this, ReasonType reason)
{
var data = ObjCharacter.GetImpl().DumpObjData(_this, reason);
data.Owner = new Uint64Array();
data.Owner.Items.Add(_this.Owner.ObjId);
return(data);
}
public virtual bool LeaveScene(Scene _this, ObjBase obj, ReasonType reason = ReasonType.VisibilityChanged)
{
if (_this.mTicking)
{
_this.mNeedToRemoveObjDict.Add(obj.ObjId, obj);
obj.Active = false;
return(true);
}
var zone = obj.Zone;
if (null != zone)
{
obj.BroadcastDestroyMe(reason);
zone.RemoveObj(obj);
//Uint64Array array = new Uint64Array();
//array.Items.Add(obj.ObjId);
//SceneServer.Instance.ServerControl.DeleteObj(zone.EnumAllVisiblePlayerIdExclude(obj.ObjId), array, (uint)reason);
}
obj.SetZone(null);
if (obj.IsCharacter())
{
var character = obj as ObjCharacter;
character.ClearRetinue();
foreach (var pair in _this.mAreaDict)
{
if (pair.Value.Cantains(character))
{
pair.Value.Remove(character);
}
}
if (obj.GetObjType() == ObjType.PLAYER)
{
_this.OnPlayerLeave(obj as ObjPlayer);
}
else if (obj.GetObjType() == ObjType.NPC)
{
if (_this.SpeMonsterToWorldBossId.ContainsKey(obj))
{
Log(_this, Logger, "Special monster killed!Type = {0}", obj.TypeId);
var worldBossId = _this.SpeMonsterToWorldBossId[obj];
--_this.SpeMonsterAlwaysRecords[worldBossId];
_this.SpeMonsterToWorldBossId.Remove(obj);
}
}
}
obj.LeavelScene();
_this.RemoveObj(obj);
return(true);
}
/// <summary>
/// 输出成一个objdata用于客户端创建
/// </summary>
/// <returns></returns>
public ObjData DumpObjData(AutoPlayer _this, ReasonType reason)
{
var data = ObjCharacter.GetImpl().DumpObjData(_this, reason);
data.EquipsModel.AddRange(_this.mLogicData.EquipsModel);
//data.PkModel = (int)ePkModel.AutoPlayer;
//GetEquipsModel(data.EquipsModel);
data.Owner = new Uint64Array();
data.Owner.Items.Add(_this.mLogicData.Id);
data.Reborn = _this.mLogicData.Ladder;
return(data);
}
public ObjData DumpObjData(ObjBase _this, ReasonType reason)
{
var data = new ObjData
{
ObjId = _this.ObjId,
Type = (int)_this.GetObjType(),
DataId = _this.TypeId,
Pos = Utility.MakePositionDataByPosAndDir(_this.GetPosition(), _this.GetDirection()),
Reason = (uint)reason
};
return(data);
}
public async Task <Answer <String[][]> > GetReasons(ReasonType reasonType, CancellationToken cancellationToken = default(CancellationToken))
{
var urlParameters = new Dictionary <String, String>
{
["type"] = reasonType.ToString()
};
var answer = await _apiInstance.RequestPostAsync(this, urlParameters, cancellationToken : cancellationToken);
JsonSerializerSettings settings = new JsonSerializerSettings()
{
ContractResolver = new ApiEntities.Base.EntityContractResolver("reasons")
};
return(JsonConvert.DeserializeObject <ApiEntities.Base.Answer <String[][]> >(answer, settings));
}
private string BuildReasonFromType(ReasonType type, string reason)
{
if (string.IsNullOrEmpty(reason))
{
reason = string.Empty;
}
switch (type)
{
case ReasonType.Spam:
reason = "Spam";
break;
case ReasonType.VoteManipulation:
reason = "Vote manipulation";
break;
case ReasonType.PersonalInformation:
reason = "Personal information";
break;
case ReasonType.SexualizingMinors:
reason = "Sexualizing minors";
break;
case ReasonType.BreakingSkimur:
reason = "Breaking skimur";
break;
case ReasonType.Other:
if (string.IsNullOrEmpty(reason))
{
throw new Exception("You must provide a reason.");
}
if (reason.Length > 200)
{
throw new Exception("The reason must not be greater than 200 characters.");
}
break;
default:
throw new Exception("unknown type");
}
return(reason);
}
public void CannotHandle(Alert alert, Person responsible, ReasonType reason)
{
var nextResponsible = _scheduleManager.GetNextPersonInCharge(responsible);
if (nextResponsible == null)
{
JanelObserver.EventManager.Dispatch(new ErrorOccurred($"No one can handle alert {alert.Id}"));
return;
}
alert.Status = StatusType.Transferring;
alert.Description += $"\n\n {responsible.Name} cannot take it because {reason.ToString()}";
alert.UpdatedAt = _dateTimeManager.GetNow();
_unitOfWork.AlertRepository.Update(alert);
JanelObserver.EventManager.Dispatch(new AlertChanged(alert, StatusType.Transferring.ToString(), responsible.Name));
JanelObserver.EventManager.Dispatch(new AlertReceived(alert, nextResponsible));
}
public ActionResult ReportPost(Guid postId, ReasonType type, string reason)
{
try
{
reason = BuildReasonFromType(type, reason);
}
catch (Exception ex)
{
return(CommonJsonResult(false, ex.Message));
}
_commandBus.Send(new ReportPost
{
ReportBy = _userContext.CurrentUser.Id,
PostId = postId,
Reason = reason
});
return(CommonJsonResult(true));
}
public override bool LeaveScene(ObjBase obj, ReasonType reason = ReasonType.VisibilityChanged)
{
if (mPhaseRequirementDic.ContainsKey(EnterPhaseRequireType.AllMonsterDie) && obj.GetObjType() == ObjType.NPC &&
mPlayerDict.Count > 0)
{
var p = mPlayerDict.First().Value;
var camp = p.GetCamp();
var tbCamp = Table.GetCamp(camp);
var count = mObjDict.Values.Count(o =>
{
var npc = o as ObjNPC;
return(npc != null && tbCamp.Camp[npc.GetCamp()] == 1);
});
if (count == 1)
{
AccomplishPhaseRequire(EnterPhaseRequireType.AllMonsterDie, 0);
}
}
return(base.LeaveScene(obj, reason));
}
//角色增加广播
public virtual void BroadcastCreateMe(ObjBase _this, ReasonType reason = ReasonType.VisibilityChanged)
{
if (null == _this.Zone)
{
return;
}
var data = _this.DumpObjData(reason);
if (ObjBase.BroadcastCreateObjType == 1)
{
_this.Zone.PushCreateObj(data);
return;
}
var msg2Other = new CreateObjMsg();
msg2Other.Data.Add(data);
var list = _this.EnumAllVisiblePlayerIdExclude(_this.ObjId).ToArray();
SceneServer.Instance.ServerControl.CreateObj(list, msg2Other);
_this.NotifyCharactersToSyncMe(list);
}
//角色删除广播
public virtual void BroadcastDestroyMe(ObjBase _this, ReasonType reason = ReasonType.VisibilityChanged)
{
if (null == _this.Zone)
{
return;
}
if (ObjBase.BroadcastDeleteObjType == 1)
{
_this.Zone.PushDeleteObj(new DeleteObjMsg
{
ObjId = _this.ObjId,
reason = (int)reason
});
return;
}
var array = new Uint64Array();
array.Items.Add(_this.ObjId);
var list = _this.EnumAllVisiblePlayerIdExclude(_this.ObjId).ToArray();
_this.NotifyCharactersToStopSyncMe(list);
SceneServer.Instance.ServerControl.DeleteObj(list, array, (uint)reason);
}
/// <summary>
/// Loads client certificate check result from a dictionary object (provided by JSON)
/// </summary>
/// <param name="obj">Key/value dictionary with <c>is_valid</c> element with boolean value.</param>
/// <exception cref="eduJSON.InvalidParameterTypeException"><paramref name="obj"/> type is not <c>Dictionary<string, object></c></exception>
public void Load(object obj)
{
if (!(obj is Dictionary <string, object> obj2))
{
throw new eduJSON.InvalidParameterTypeException(nameof(obj), typeof(Dictionary <string, object>), obj.GetType());
}
// Set check result.
if (eduJSON.Parser.GetValue <bool>(obj2, "is_valid"))
{
Result = ReasonType.Valid;
}
else if (eduJSON.Parser.GetValue(obj2, "reason", out string reason))
{
// Parse reason for check failure.
switch (reason)
{
case "certificate_missing": Result = ReasonType.CertificateMissing; break;
case "user_disabled": Result = ReasonType.UserDisabled; break;
case "certificate_disabled": Result = ReasonType.CertificateDisabled; break;
case "certificate_not_yet_valid": Result = ReasonType.CertificateNotYetValid; break;
case "certificate_expired": Result = ReasonType.CertificateExpired; break;
default: Result = ReasonType.Invalid; break;
}
}
else
{
// No reason specified.
Result = ReasonType.Invalid;
}
}
public Top100Exception(ReasonType reason)
{
Reason = reason;
}
public DisconnectEventArgs(ReasonType reason)
{
this.reason = reason;
}
/// <summary>
/// TODO: Documentation SessionTerminate
/// </summary>
/// <param name="to"></param>
/// <param name="sid"></param>
/// <param name="reasonType"></param>
/// <returns></returns>
public void SessionTerminate(JID to, String sid, ReasonType? reasonType)
{
JingleIQ jingleIq = new JingleIQ(this.Stream.Document);
jingleIq.From = this.Stream.JID;
jingleIq.To = to;
jingleIq.Type = IQType.set;
jingleIq.Instruction.Action = ActionType.session_terminate;
jingleIq.Instruction.Sid = sid;
if (reasonType.HasValue)
{
JingleReason reason = new JingleReason(jingleIq.OwnerDocument);
switch (reasonType)
{
case ReasonType.alternative_session:
reason.Reason = new AlternativeSession(jingleIq.OwnerDocument);
break;
case ReasonType.busy:
reason.Reason = new Busy(jingleIq.OwnerDocument);
break;
case ReasonType.cancel:
reason.Reason = new Cancel(jingleIq.OwnerDocument);
break;
case ReasonType.connectivity_error:
reason.Reason = new ConnectivityError(jingleIq.OwnerDocument);
break;
case ReasonType.decline:
reason.Reason = new JingleDecline(jingleIq.OwnerDocument);
break;
case ReasonType.expired:
reason.Reason = new Expired(jingleIq.OwnerDocument);
break;
case ReasonType.failed_application:
reason.Reason = new FailedApplication(jingleIq.OwnerDocument);
break;
case ReasonType.failed_transport:
reason.Reason = new FailedTransport(jingleIq.OwnerDocument);
break;
case ReasonType.general_error:
reason.Reason = new GeneralError(jingleIq.OwnerDocument);
break;
case ReasonType.gone:
reason.Reason = new Gone(jingleIq.OwnerDocument);
break;
case ReasonType.incompatible_parameters:
reason.Reason = new IncompatibleParameters(jingleIq.OwnerDocument);
break;
case ReasonType.media_error:
reason.Reason = new MediaError(jingleIq.OwnerDocument);
break;
case ReasonType.security_error:
reason.Reason = new SecurityError(jingleIq.OwnerDocument);
break;
case ReasonType.success:
reason.Reason = new Success(jingleIq.OwnerDocument);
break;
case ReasonType.timeout:
reason.Reason = new Timeout(jingleIq.OwnerDocument);
break;
case ReasonType.unsupported_applications:
reason.Reason = new UnsupportedApplications(jingleIq.OwnerDocument);
break;
case ReasonType.unsupported_transports:
reason.Reason = new UnsupportedTransports(jingleIq.OwnerDocument);
break;
}
jingleIq.Instruction.Reason = reason;
}
this.Stream.Write(jingleIq);
}
//DOC: Documentation Required
/// <summary>
///
/// </summary>
/// <param name="message"></param>
/// <param name="reason"></param>
/// <param name="innerException"></param>
public ConnectorException(string message, ReasonType reason, Exception innerException) : this(message, innerException)
{
Reason = reason;
}
/// <summary>
/// TODO: Documentation TerminateSession
/// </summary>
/// <param name="to"></param>
/// <param name="sid"></param>
/// <param name="reasonType"></param>
private void TerminateSession(JID to, String sid, ReasonType? reasonType)
{
this.StartingSessionRecipient = null;
this.StartingSessionSid = null;
this.StartingSessionAction = ActionType.UNSPECIFIED;
if (to != null && !String.IsNullOrEmpty(sid))
this.jingleManager.SessionTerminate(to, sid, reasonType);
}
public override ObjData DumpObjData(ReasonType reason)
{
return(mImpl.DumpObjData(this, reason));
}
public override bool LeaveScene(ObjBase obj, ReasonType reason = ReasonType.VisibilityChanged)
{
return(mImpl.LeaveScene(this, obj, reason));
}
public bool LeaveScene(LeaverScene _this, ObjBase obj, ReasonType reason = ReasonType.VisibilityChanged)
{
obj.LeavelScene();
_this.RemoveObj(obj);
return(true);
}
public ActionResult ReportPost(Guid postId, ReasonType type, string reason)
{
try
{
reason = BuildReasonFromType(type, reason);
}
catch (Exception ex)
{
return CommonJsonResult(false, ex.Message);
}
_commandBus.Send(new ReportPost
{
ReportBy = _userContext.CurrentUser.Id,
PostId = postId,
Reason = reason
});
return CommonJsonResult(true);
}
//DOC: Documentation Required
/// <summary>
///
/// </summary>
/// <param name="message"></param>
/// <param name="reason"></param>
/// <param name="innerException"></param>
public ConnectorException(string message, ReasonType reason, Exception innerException) : this(message, innerException) { Reason = reason; }
private string BuildReasonFromType(ReasonType type, string reason)
{
if (string.IsNullOrEmpty(reason))
reason = string.Empty;
switch (type)
{
case ReasonType.Spam:
reason = "Spam";
break;
case ReasonType.VoteManipulation:
reason = "Vote manipulation";
break;
case ReasonType.PersonalInformation:
reason = "Personal information";
break;
case ReasonType.SexualizingMinors:
reason = "Sexualizing minors";
break;
case ReasonType.BreakingSkimur:
reason = "Breaking skimur";
break;
case ReasonType.Other:
if (string.IsNullOrEmpty(reason))
throw new Exception("You must provide a reason.");
if (reason.Length > 200)
throw new Exception("The reason must not be greater than 200 characters.");
break;
default:
throw new Exception("unknown type");
}
return reason;
}
/// <summary>
/// Method to get reason type name
/// </summary>
/// <param name="reasonType">Reason name</param>
/// <returns>Reason description</returns>
public string GetReasonType(ReasonType reasonType)
{
var type = (char)reasonType;
return(type != '\0' ? _reasonService.GetReasonType(type) : string.Empty);
}
public JavaNetException(ReasonType reason, string message) : base(message)
{
Reason = reason;
}
public JavaNetException(ReasonType reason)
{
Reason = reason;
}
/// <summary>
/// Creates a new disconnect UDP response class instance
/// </summary>
public DisconnectUdpResponse(ReasonType reason, IPEndPoint ipEndPoint)
{
this.reason = (int)reason;
IpEndPoint = ipEndPoint;
}
public JavaNetException(ReasonType reason, string message, Exception inner) : base(message, inner)
{
Reason = reason;
}
public DisconnectEventArgs(ReasonType reason)
{
this.reason = reason;
}
