protected void Page_Load(object sender, EventArgs e)
{
if(!Page.IsPostBack)
{
if(!String.IsNullOrEmpty(Request["userName"])
&& !String.IsNullOrEmpty(Request["Id"]))
{
string userName = Request["userName"];
string authorizationKey = Request["Id"];
CommandStatus status = new CommandStatus();
new UserService().AuthorizeUser(userName, authorizationKey, status);
if (status.IsError == false)
{
//User u = new UserService().GetByLogin(userName);
//Seppuku.Domain.Kingdom k = new KingdomService().GetByUserId(u.UserId);
//new MapService().InitializeKingdom(k.MapId, k.KingdomId);
LblResult.Text = "Twoje konto zostało aktywowane. Możesz zalogować się na stronę.";
}
else switch (status.Message)
{
case "Invalid UserName":
LblResult.Text = "Link aktywacyjny niepoprawny. Błędna nazwa użytkownika";
break;
case "Invalid Authentication Key":
LblResult.Text = "Link aktywacyjny niepoprawny. Błędny klucz aktywacyjny";
break;
case "Already Approved":
LblResult.Text = "Użytkownik został już wcześniej aktywowany. Możesz zalogować się na swoje konto";
break;
}
}
}
}
public CommandStatusResult GetCommandStatus(IImmutableSet<IProjectTree> nodes, long commandId, bool focused, string commandText, CommandStatus progressiveStatus) {
if ((VSConstants.VSStd2KCmdID)commandId == VSConstants.VSStd2KCmdID.EXCLUDEFROMPROJECT && nodes != null && nodes.Count > 0) {
return new CommandStatusResult(true, commandText, CommandStatus.NotSupported | CommandStatus.Invisible);
}
return CommandStatusResult.Unhandled;
}
public Task<CommandStatusResult> GetCommandStatusAsync(IImmutableSet<IProjectTree> nodes, long commandId, bool focused, string commandText, CommandStatus progressiveStatus) {
var workflow = _interactiveWorkflowProvider.GetOrCreate();
if (commandId == RPackageCommandId.icmdCopyRemoteItemPath && nodes.IsSingleNodePath() && workflow.RSession.IsHostRunning && workflow.RSession.IsRemote) {
return Task.FromResult(new CommandStatusResult(true, commandText, CommandStatus.Enabled | CommandStatus.Supported));
}
return Task.FromResult(CommandStatusResult.Unhandled);
}
/// <summary> Called to save a pdu into the database </summary>
/// <param name="dataTransaction"></param>
/// <param name="logKey"></param>
/// <param name="smscServiceId"></param>
/// <param name="pduDirectionType"></param>
/// <param name="commandLength"></param>
/// <param name="commandSet"></param>
/// <param name="commandStatus"></param>
/// <param name="sequenceNumber"></param>
/// <param name="details"></param>
/// <param name="pduDataBlocks"></param>
/// <returns> long </returns>
public static Guid? Insert(DataTransaction dataTransaction, string logKey, int smscServiceId, PduDirectionTypes pduDirectionType, long commandLength,
CommandSet commandSet, CommandStatus commandStatus, long sequenceNumber, List<PduPropertyDetail> details, List<byte[]> pduDataBlocks)
{
Guid? pduHeaderId = null;
// Prepare the database call
using (DbCommand dbCommand = dataTransaction.GetStoredProcCommand("spSMPP_Pdu_Insert"))
{
// Prepare the call
dataTransaction.AddInParameterString(dbCommand, "LogKey", logKey);
dataTransaction.AddInParameterInteger(dbCommand, "SMSCServiceID", smscServiceId);
dataTransaction.AddInParameterShort(dbCommand, "Direction", (short) pduDirectionType);
dataTransaction.AddInParameterLong(dbCommand, "CommandLength", commandLength);
dataTransaction.AddInParameterString(dbCommand, "CommandId", commandSet.ToString());
dataTransaction.AddInParameterString(dbCommand, "CommandStatusId", commandStatus.ToString());
dataTransaction.AddInParameterLong(dbCommand, "SequenceNumber", sequenceNumber);
dataTransaction.AddInParameterTable(dbCommand, "PduPropertyDetails", new PduPropertyDetails(details));
dataTransaction.AddInParameterTable(dbCommand, "PduDataBlocks", new SMSCPduDataBlocks(pduDataBlocks));
dataTransaction.AddOutParameterGuid(dbCommand, "PduHeaderId");
dataTransaction.ExecuteNonQuery(dbCommand);
pduHeaderId = dataTransaction.GetParameterValueGuid(dbCommand, "PduHeaderId");
}
return pduHeaderId;
}
public void Dispose()
{
if (dest == null) return;
if (attacking == true && attacktask != null) attacktask.Deactivate();
attacktask = null;
this.status = CommandStatus.FINISHED;
}
public static CommandStatus Or(this CommandStatus status1, CommandStatus status2)
{
if (status1 == CommandStatus.Normal || status2 == CommandStatus.Normal)
return CommandStatus.Normal;
if (status1 == CommandStatus.Disabled || status2 == CommandStatus.Disabled)
return CommandStatus.Disabled;
return CommandStatus.Unavailable;
}
/// <summary>Parameterized constructor.
/// </summary>
public CommandResult(CommandStatus status, string commandId, string aggregateRootId, string result = null, string resultType = null)
{
Status = status;
CommandId = commandId;
AggregateRootId = aggregateRootId;
Result = result;
ResultType = resultType;
}
/// <summary> Constructor </summary>
/// <param name="defaultEncoding"></param>
/// <param name="status"></param>
/// <param name="sequence"></param>
private GenericNackSm(DataCodings defaultEncoding, CommandStatus status, uint sequence)
: base(defaultEncoding)
{
Length = (uint) Header.HEADER_LENGTH;
Command = CommandSet.GenericNack;
Status = status;
Sequence = sequence;
}
/// <summary>Parameterized constructor.
/// </summary>
public CommandResult(CommandStatus commandStatus, string commandId, string aggregateRootId, int exceptionCode, string errorMessage)
{
Status = commandStatus;
CommandId = commandId;
AggregateRootId = aggregateRootId;
ExceptionCode = exceptionCode;
ErrorMessage = errorMessage;
}
/// <summary>Parameterized constructor.
/// </summary>
public CommandResult(CommandStatus status, string commandId, string exceptionTypeName, string errorMessage, IDictionary errorData)
{
this.Status = status;
this.CommandId = commandId;
this.ExceptionTypeName = exceptionTypeName;
this.ErrorMessage = errorMessage;
this.ErrorData = errorData;
}
public CommandStatusResult GetCommandStatus(IImmutableSet<IProjectTree> nodes, long commandId, bool focused, string commandText, CommandStatus progressiveStatus) {
if (commandId == RPackageCommandId.icmdSetDirectoryHere && nodes.Count == 1) {
var session = _interactiveWorkflowProvider.Active?.RSession;
bool enabled = session != null && session.IsHostRunning && !session.IsRemote;
return new CommandStatusResult(true, commandText, enabled ? CommandStatus.Enabled | CommandStatus.Supported : CommandStatus.Supported);
}
return CommandStatusResult.Unhandled;
}
/// <summary>Parameterized constructor.
/// </summary>
public CommandResult(CommandStatus status, string commandId, string aggregateRootId, string exceptionTypeName, string errorMessage)
{
Status = status;
CommandId = commandId;
AggregateRootId = aggregateRootId;
ExceptionTypeName = exceptionTypeName;
ErrorMessage = errorMessage;
}
/// <summary> Constructor </summary>
/// <param name="defaultEncoding"></param>
/// <param name="commandStatus"></param>
/// <param name="sequence"></param>
/// <param name="messageId"></param>
private SubmitMultiSmResp(DataCodings defaultEncoding, CommandStatus commandStatus, uint sequence, string messageId)
: base(defaultEncoding, CommandSet.SubmitMultiSmResp, commandStatus, sequence)
{
MessageId = messageId;
UnsuccessDestinationAddresses = new List<UnsuccessDestinationAddress>();
Optional = new TLVCollection();
}
public void Undo()
{
if (Status == CommandStatus.Ready || Status == CommandStatus.Undone)
throw new InvalidOperationException("The action needs to be done first.");
_Undo();
_commandStatus = CommandStatus.Undone;
}
public void Do()
{
if (Status == CommandStatus.Done || Status == CommandStatus.Redone)
throw new InvalidOperationException("The action has been done already.");
_Do();
_commandStatus = (_commandStatus == CommandStatus.Ready) ? CommandStatus.Done : CommandStatus.Redone;
}
/// <summary> Called to create a DataSmResp object </summary>
/// <param name="defaultEncoding"></param>
/// <param name="dataSm"></param>
/// <param name="commandStatus"></param>
/// <param name="messageId"></param>
/// <returns> DataSmResp </returns>
public static DataSmResp Create(DataCodings defaultEncoding, DataSm dataSm, CommandStatus commandStatus, string messageId)
{
if (dataSm.SourceAddr == string.Empty || dataSm.SourceAddr == null)
{
commandStatus = CommandStatus.ESME_RINVSRCADR;
}
return new DataSmResp(defaultEncoding, commandStatus, dataSm.Sequence, messageId);
}
/// <summary> Called to create a DataSmResp object </summary>
/// <param name="defaultEncoding"></param>
/// <param name="submitSm"></param>
/// <param name="commandStatus"></param>
/// <param name="messageId"></param>
/// <returns> DataSmResp </returns>
public static SubmitSmResp Create(DataCodings defaultEncoding, SubmitSm submitSm, CommandStatus commandStatus, string messageId)
{
if (submitSm.DestAddr == string.Empty || submitSm.DestAddr == null)
{
commandStatus = CommandStatus.ESME_RINVDSTADR;
}
return new SubmitSmResp(defaultEncoding, commandStatus, submitSm.Sequence, messageId);
}
/// <summary> Called to create a DeliverSmResp object </summary>
/// <param name="defaultEncoding"></param>
/// <param name="deliverSm"></param>
/// <param name="commandStatus"></param>
/// <returns> DeliverSmResp </returns>
public static DeliverSmResp Create(DataCodings defaultEncoding, DeliverSm deliverSm, CommandStatus commandStatus)
{
if (deliverSm.SourceAddr == string.Empty || deliverSm.SourceAddr == null)
{
commandStatus = CommandStatus.ESME_RINVSRCADR;
}
return new DeliverSmResp(defaultEncoding, commandStatus, deliverSm.Sequence);
}
/// <summary>
/// 공통 버튼 상태 변경
/// </summary>
/// <param name="buttonName">버튼 이름</param>
/// <param name="status">상태</param>
public void ChangeCommandButtonState(string commandName, CommandStatus status)
{
if (CurrentWorkingService.CurrentWorkspaceName == WorkspaceNames.ContentPart)
WorkItem.RootWorkItem.Commands[commandName].Status = status;
else if (CurrentWorkingService.CurrentWorkspaceName == WorkspaceNames.PopupPart)
{
if (CurrentWorkingService.ActiveView is AbstractPopupHostView)
((AbstractPopupHostView)(CurrentWorkingService.ActiveView)).ChangeCommandButtonState(commandName, status);
}
}
public Task<CommandStatusResult> GetCommandStatusAsync(IImmutableSet<IProjectTree> nodes, long commandId, bool focused, string commandText, CommandStatus status) {
if (_session.IsHostRunning && _commandIds.Contains(commandId)) {
if (nodes.Any(IsRData)) {
status |= CommandStatus.Supported | CommandStatus.Enabled;
return Task.FromResult(new CommandStatusResult(true, commandText, status));
}
}
return Task.FromResult(CommandStatusResult.Unhandled);
}
public bool QueryStatus(CommandID cmdId, CommandStatus status, CommandText text)
{
var frame = ActiveFrame;
if (frame == null)
return false;
var ct = frame.Pane as ICommandTarget;
if (ct == null)
return false;
return ct.QueryStatus(cmdId, status, text);
}
/// <summary>
/// Check if a specific command is supported and enabled.
/// </summary>
/// <param name="nodes">The project nodes being queried.</param>
/// <param name="commandId">The command ID.</param>
/// <param name="focused">A value indicating whether <paramref name="nodes"/> or the project have the user focus.
/// A value of <c>false</c> indicates this command is being routed through the application in search of command handlers to process a command that the focused UI did not handle.</param>
/// <param name="commandText">The default caption of the command that is displayed to the user. <c>null</c> to allow the default caption to be used.</param>
/// <param name="progressiveStatus">The query result thus far (as default, or as handed off from previous handler).</param>
/// <returns>A value that describes how this command may be handled.</returns>
public Task<CommandStatusResult> GetCommandStatusAsync(IImmutableSet<IProjectTree> nodes, long commandId, bool focused, string commandText, CommandStatus progressiveStatus)
{
if (commandId == 0x100)
{
return Task.FromResult(new CommandStatusResult(true, commandText, CommandStatus.Enabled | CommandStatus.Supported));
}
else
{
return Task.FromResult(CommandStatusResult.Unhandled);
}
}
public Task<CommandStatusResult> GetCommandStatusAsync(IImmutableSet<IProjectTree> nodes, long commandId, bool focused, string commandText, CommandStatus progressiveStatus) {
if ((commandId == RPackageCommandId.icmdSourceSelectedFiles || commandId == RPackageCommandId.icmdSourceSelectedFilesWithEcho) && nodes.GetSelectedNodesPaths().Count() > 0) {
foreach (var n in nodes) {
if (n.IsFolder || !Path.GetExtension(n.FilePath).EqualsIgnoreCase(".r")) {
return Task.FromResult(CommandStatusResult.Unhandled);
}
}
return Task.FromResult(new CommandStatusResult(true, commandText, CommandStatus.Enabled | CommandStatus.Supported));
}
return Task.FromResult(CommandStatusResult.Unhandled);
}
public void Update(object para)
{
try
{
if (mob.Map.HasHeightMap())
{
if (mob.Map.HeightMap.water_level != 0)
{
switch (mob.LivingSpace)
{
case Mob.Space.Land:
if (dest[2] < mob.Map.HeightMap.water_level)
{
this.Status = CommandStatus.FINISHED;
return;
}
break;
case Mob.Space.Water :
if (dest[2] >= mob.Map.HeightMap.water_level)
{
this.Status = CommandStatus.FINISHED;
return;
}
break;
}
}
}
if (mob.WalkSpeed == 0 || mob.Actor.Tasks.ContainsKey("Freezing") || mob.Actor.BattleStatus.Additions.ContainsKey("LowerBodyParalysis")) return;
float[] src = new float[3] { mob.Actor.x, mob.Actor.y, mob.Actor.z };
float[] dst = dest;
if (MobAI.GetDistance(src, dst) > 0)
{
float[] diff;
int yaw = MobAI.GetYawFromVector(MobAI.GetUnitVector(src, dst));
if (MobAI.GetDistance(src, dst) > mob.WalkSpeed) diff = MobAI.Add(src, MobAI.ScalarProduct(MobAI.GetUnitVector(src, dst), mob.WalkSpeed));
else diff = dst;
this.mob.Map.MoveActor(Map.MOVE_TYPE.START, this.mob.Actor, src, yaw, dst, 0, mob.mWalkSpeed);
src = diff;
this.mob.Actor.yaw = yaw;
this.mob.Actor.x = src[0];
this.mob.Actor.y = src[1];
this.mob.Actor.z = src[2];
}
else
{
this.mob.Map.MoveActor(Map.MOVE_TYPE.STOP, this.mob.Actor, src, this.mob.Actor.yaw, src, 0, mob.mWalkSpeed);
this.status = CommandStatus.FINISHED;
}
}
catch (Exception ex)
{
Logger.ShowError(ex, null);
}
}
/// <summary> Constructor </summary>
/// <param name="commandSet"></param>
/// <param name="commandStatus"></param>
/// <param name="defaultEncoding"></param>
public Header(DataCodings defaultEncoding, CommandSet commandSet, CommandStatus commandStatus)
{
DefaultEncoding = defaultEncoding;
PduData = null;
ExternalId = null;
Length = HEADER_LENGTH;
Command = commandSet;
Status = commandStatus;
Sequence = 0;
}
/// <summary>Parameterized constructor.
/// </summary>
public CommandResult(CommandStatus status, string commandId, Exception exception)
{
this.Status = status;
this.CommandId = commandId;
this._exception = exception;
if (exception == null)
return;
this.ExceptionTypeName = string.Concat(exception.GetType().FullName, ", ", exception.GetType().Assembly.GetName().Name);// ex.GetType().FullName;
this.ErrorMessage = exception.Message;
this.ErrorData = exception.Data;
}
public override bool QueryStatus(CommandID cmdID, CommandStatus status, CommandText txt)
{
if (cmdID.Guid == CmdSets.GuidDecompiler)
{
switch (cmdID.ID)
{
case CmdIds.ActionMarkProcedure:
case CmdIds.ActionScanHeuristically:
status.Status = MenuStatus.Enabled|MenuStatus.Visible;
return true;
}
}
return base.QueryStatus(cmdID, status, txt);
}
public static string GetStatusString(CommandStatus status)
{
switch (status)
{
case CommandStatus.Failure:
return "failure";
case CommandStatus.Success:
return "success";
default:
throw new InvalidOperationException();
}
}
public override bool QueryStatus(CommandID cmdId, CommandStatus status, CommandText text)
{
if (cmdId.Guid == CmdSets.GuidReko)
{
switch (cmdId.ID)
{
case CmdIds.ActionNextPhase:
case CmdIds.ActionFinishDecompilation:
status.Status = MenuStatus.Visible;
return true;
}
}
return base.QueryStatus(cmdId, status, text);
}
public GdbCommandResult (string line)
{
if (line.StartsWith ("^done")) {
Status = CommandStatus.Done;
ReadResults (line, 6);
} else if (line.StartsWith ("^error")) {
Status = CommandStatus.Error;
if (line.Length > 7) {
ReadResults (line, 7);
ErrorMessage = GetValue ("msg");
}
} else if (line.StartsWith ("^running")) {
Status = CommandStatus.Running;
}
}
public CommandStatusResult GetCommandStatus(IImmutableSet <IProjectTree> nodes, long commandId, bool focused, string commandText, CommandStatus progressiveStatus)
{
if ((int)commandId == _id && _nodesCheck(nodes))
{
return(new CommandStatusResult(true, commandText, CommandStatus.NotSupported | CommandStatus.Invisible));
}
return(CommandStatusResult.Unhandled);
}
/// <summary> Constructor </summary>
/// <param name="defaultEncoding"></param>
/// <param name="commandStatus"></param>
private CancelSmResp(DataCodings defaultEncoding,
CommandStatus commandStatus) : base(defaultEncoding,
CommandSet.CancelSmResp,
commandStatus)
{
}
protected override Task <CommandStatusResult> GetCommandStatusAsync(IProjectTree node, bool focused, string?commandText, CommandStatus progressiveStatus)
{
// We assume that if the AppDesignerTreeModifier marked an AppDesignerFolder, that we must support the Project Designer
if (node.Flags.Contains(ProjectTreeFlags.Common.AppDesignerFolder))
{
return(GetCommandStatusResult.Handled(commandText, CommandStatus.Enabled));
}
return(GetCommandStatusResult.Unhandled);
}
private async Task CompleteCommand(ProcessingCommand processingCommand, CommandStatus commandStatus, string resultType, string result)
{
var commandResult = new CommandResult(commandStatus, processingCommand.Message.Id, processingCommand.Message.AggregateRootId, result, resultType);
await processingCommand.MailBox.CompleteMessage(processingCommand, commandResult).ConfigureAwait(false);
}
public virtual bool QueryStatus(CommandID cmdId, CommandStatus status, CommandText text)
{
return(false);
}
public bool QueryStatus(CommandID cmdId, CommandStatus cmdStatus, CommandText cmdText)
{
var ct = GetSubCommandTarget();
if (ct != null && ct.QueryStatus(cmdId, cmdStatus, cmdText))
{
return(true);
}
if (currentPhase != null && currentPhase.QueryStatus(cmdId, cmdStatus, cmdText))
{
return(true);
}
if (cmdId.Guid == CmdSets.GuidReko)
{
if (QueryMruItem(cmdId.ID, cmdStatus, cmdText))
{
return(true);
}
switch (cmdId.ID)
{
case CmdIds.FileOpen:
case CmdIds.FileExit:
case CmdIds.FileOpenAs:
case CmdIds.FileAssemble:
case CmdIds.ViewProjectBrowser:
case CmdIds.ViewProcedureList:
case CmdIds.ToolsHexDisassembler:
case CmdIds.ToolsOptions:
case CmdIds.WindowsCascade:
case CmdIds.WindowsTileVertical:
case CmdIds.WindowsTileHorizontal:
case CmdIds.WindowsCloseAll:
case CmdIds.HelpAbout:
cmdStatus.Status = MenuStatus.Enabled | MenuStatus.Visible;
return(true);
//$TODO: finish implementing this :)
case CmdIds.ToolsKeyBindings:
cmdStatus.Status = MenuStatus.Visible;
return(true);
case CmdIds.FileMru:
cmdStatus.Status = MenuStatus.Visible;
return(true);
case CmdIds.ActionRestartDecompilation:
cmdStatus.Status = MenuStatus.Enabled | MenuStatus.Visible;
break;
case CmdIds.ActionNextPhase:
cmdStatus.Status = currentPhase.CanAdvance
? MenuStatus.Enabled | MenuStatus.Visible
: MenuStatus.Visible;
return(true);
case CmdIds.FileNewScript:
case CmdIds.FileAddBinary:
case CmdIds.FileAddMetadata:
case CmdIds.FileAddScript:
case CmdIds.FileSave:
case CmdIds.FileCloseProject:
case CmdIds.EditFind:
case CmdIds.ViewCallGraph:
case CmdIds.ViewFindAllProcedures:
case CmdIds.ViewFindStrings:
cmdStatus.Status = IsDecompilerLoaded
? MenuStatus.Enabled | MenuStatus.Visible
: MenuStatus.Visible;
return(true);
}
}
return(false);
}
/// <summary> Called to create a CancelSmResp object </summary>
/// <param name="defaultEncoding"></param>
/// <param name="status"></param>
/// <returns></returns>
internal static CancelSmResp Create(DataCodings defaultEncoding,
CommandStatus status)
{
return(new CancelSmResp(defaultEncoding,
status));
}
