public bool HandleResult( IResult result, IFormatInfo outputFormat, HttpRequestBase request, HttpResponseBase response )
{
response.AddHeader("Accept-Ranges", "bytes");
Range range;
if ( !TryGetRequestedRange( request, out range ) )
{
return false;
}
if (!ValidateIfRangeHeader(request, result))
{
return false;
}
var offset = range.Start ?? 0;
var end = range.End.HasValue ? range.End.Value : result.ContentLength - 1;
var length = end - offset + 1;
response.AddHeader( "Content-Range", "bytes " + offset + "-" + end + "/" + result.ContentLength );
response.StatusCode = 206;
result.Serve( response, offset, length );
return true;
}
public MainViewModel(IApriori apriori, IResult resultWindow)
{
_items = new ObservableSet<Item>();
_transactions = new ObservableCollection<string>();
this._apriori = apriori;
this._resultWindow = resultWindow;
}
public ResultExecutionTask(IResult result, ActionExecutionContext context)
{
Result = result;
Context = context;
CompletionEventArgs = new ResultCompletionEventArgs();
ExecutionCompleteWaitHandle = new ManualResetEvent(false);
}
public override IResult Execute(IResult previousResults)
{
try
{
using (var key = Registry.CurrentUser.OpenSubKey(KeyPath, true))
{
if (key == null)
return new NextResult();
var value = key.GetValue(ValueName).ToIntOrDefault(0);
if (value == 0)
return new NextResult();
key.SetValue(ValueName, 0);
Log.InfoFormat("Internet-connection proxy disabled");
}
return new NextResult();
}
catch (Exception e)
{
return new ExceptionOccurred(e);
}
}
void AuthCallBack(IResult result)
{
if (result.Error != null)
{
// display error popup
popup.SetActive(true);
newGame.enabled = true;
loadGame.enabled = true;
rulesButton.enabled = true;
}
else
{
if (FB.IsLoggedIn)
{
FB.API("/me?fields=first_name,last_name", HttpMethod.GET, DisplayUsername);
FB.API("/me/friends?fields=first_name,last_name", HttpMethod.GET, DisplayFriends);
//FB.API("me/picture?type=square&height=128&width=128", HttpMethod.GET, DisplayProfilePic);
FB.GetAppLink(GetAppLink);
}
else
{
// display error popup
popup.SetActive(true);
newGame.enabled = true;
loadGame.enabled = true;
rulesButton.enabled = true;
}
}
}
public ContinueResultDecorator(IResult inner, Func<IEnumerable<IResult>> coroutine)
: base(inner)
{
if (coroutine == null) throw new ArgumentNullException("coroutine");
_coroutine = coroutine;
}
/// <summary>
/// Called by the bootstrapper's constructor at runtime to start the framework.
/// </summary>B
protected virtual void StartRuntime()
{
EventAggregator.HandlerResultProcessing = (target, result) =>
{
var task = result as Task;
if (task != null)
{
result = new IResult[] { task.AsResult() };
}
var coroutine = result as IEnumerable<IResult>;
if (coroutine != null)
{
var viewAware = target as IViewAware;
var view = viewAware != null ? viewAware.GetView() : null;
var context = new CoroutineExecutionContext { Target = target, View = view };
Coroutine.BeginExecute(coroutine.GetEnumerator(), context);
}
};
AssemblySourceCache.Install();
AssemblySource.Instance.AddRange(SelectAssemblies());
Configure();
IoC.GetInstance = GetInstance;
IoC.GetAllInstances = GetAllInstances;
IoC.BuildUp = BuildUp;
}
public override IResult Execute(IResult previousResults)
{
try
{
var request =
EndpointManager.GetContract<AbstractIdentityQueryContract>(EndPointFunctions.IdentityQuery);
request.LoginId = SettingsManager.GetTemporarySettingString(UsernameKey);
request.Credential1 = SettingsManager.GetTemporarySettingString(PassphraseKey);
request.Credential2 = SettingsManager.GetTemporarySettingString(Credential2Key);
request.Credential3 = SettingsManager.GetTemporarySettingString(Credential3Key);
request.Credential4 = SettingsManager.GetTemporarySettingString(Credential4Key);
request.Provider = CertificateProvider;
request.Properties = _properties;
request.GroupPaths = _groupPaths;
var result = request.MakeRequest<IdentityQueryResult>();
if (result == null)
return request.GetErrorResult();
SettingsManager.SetTemporaryObject(UserPropertiesKey, result.Properties);
SettingsManager.SetTemporaryObject(GroupPathsKey, result.Groups);
return new NextResult();
}
catch (Exception e)
{
return new ExceptionOccurred(e);
}
}
private static bool ValidateLastModifyDate(string ifModifiedSinceHeader, IResult result)
{
if (string.IsNullOrEmpty(ifModifiedSinceHeader))
{
return true;
}
if (!result.LastModified.HasValue)
{
return false;
}
DateTime modifiedSince;
if (string.IsNullOrEmpty(ifModifiedSinceHeader) || !DateTime.TryParse(ifModifiedSinceHeader, out modifiedSince))
{
return false;
}
if (modifiedSince <= result.LastModified.Value.Subtract(TimeSpan.FromSeconds(1)))
{
return false;
}
return true;
}
public override IResult Execute(IResult previousResults)
{
try
{
if (string.IsNullOrWhiteSpace(SettingKey))
throw new Exception("No settings key specified");
var info = SettingsManager.GetTemporaryObject(SettingKey) as FileInfoWrapper;
if (info == null)
throw new Exception("Data object is invalid");
var result = info.VerifyFile(PathUtilities.DownloadFolder);
if (!result.Result)
{
Log.Warn(result.Reason);
return new CouldNotVerifyFile { Target = info.FileName, Issue = result.Reason };
}
return new NextResult();
}
catch (Exception e)
{
return new ExceptionOccurred(e);
}
}
private void ChildCompleted(IResult previous, Exception exception)
{
if(exception != null)
{
if (exception is CancelResult)
OnComplete(null);
else OnComplete(exception);
return;
}
if(previous != null)
previous.Completed -= ChildCompleted;
if(_enumerator.MoveNext())
{
try
{
var next = _enumerator.Current;
next.Completed += ChildCompleted;
next.Execute(_message, _handlingNode);
}
catch(Exception ex)
{
OnComplete(ex);
return;
}
}
else OnComplete(null);
}
public void SetUp()
{
var path = new[] { "path1, path2 " };
this.ContentRepository.Stub(r => r.FindContent(path)).Return(null);
this.result = this.RenderingService.GetPage(path, null, null, false);
}
public override IResult Execute(IResult previousResults)
{
try
{
var result = SecurityUtilities.QuerySecurityProviderHealth(SecurityUtilities.SecurityProviders.AntiVirus);
switch (result)
{
case SecurityUtilities.SecurityProviderHealth.Good:
Log.Info("Windows reports that this computer's anti-virus software is in good health.");
return new NextResult();
case SecurityUtilities.SecurityProviderHealth.NotMonitored:
Log.Warn("Windows reports that this computer's anti-virus software is not monitored.");
return new AntiVirusHealthNotMonitored();
case SecurityUtilities.SecurityProviderHealth.Poor:
Log.Warn("Windows reports that this computer's anti-virus software is in poor health.");
return new AntiVirusHealthPoor();
case SecurityUtilities.SecurityProviderHealth.Snooze:
Log.Warn("Windows reports that this computer's security center is not active.");
return new SecurityCenterNotActive();
default:
throw new Exception(string.Format("Could not evaluate anti-virus health: Windows returned unexpected result ({0})",result));
}
}
catch (Exception e)
{
return new ExceptionOccurred(e);
}
}
public void SetUp()
{
var placeholder1 = new Placeholder("area 1");
var placeholder2 = new Placeholder("area 2");
var widgetSpecification = new WidgetSpecification("widget");
widgetSpecification.Insert(0, placeholder1);
widgetSpecification.Insert(1, placeholder2);
var area = new Area("area 1");
var widget = new Widget("widget", new[] { area });
var buildContext = new BuildData(Enumerable.Empty<IContextItem>());
var builder = new Builder(RenderingInstructions.BuildForPreview(), w => widgetSpecification, null);
var instance = widget.Build(builder, new[] { 0 }, buildContext);
var rendererFactory = MockRepository.GenerateStub<IRendererFactory>();
this.viewHelper = MockRepository.GenerateStub<IViewHelper>();
var multiRenderer = new MultiRenderer(rendererFactory);
KolaConfigurationRegistry.RegisterRenderer(multiRenderer);
this.result = instance.Render(multiRenderer);
}
public override IResult Execute(IResult previousResults)
{
try
{
var startTime = DateTime.UtcNow;
TimeSpan elapsed;
do
{
DialogsManager.WaitForDurationOrCancel(DateTime.UtcNow, new TimeSpan(0,0,0,Interval));
if (DialogsManager.CancelRequested)
break;
if (SecurityUtilities.SecurityProviderHealth.Good ==
SecurityUtilities.QuerySecurityProviderHealth(Provider))
break;
elapsed = DateTime.UtcNow.Subtract(startTime);
} while (elapsed.Duration().TotalSeconds < Duration);
return new NextResult();
}
catch (Exception e)
{
return new ExceptionOccurred(e);
}
}
public async Task<IResult> NegotiatedResult(IRequestContext context, IResult result)
{
foreach (var interceptor in _interceptors) {
result = await interceptor.NegotiatedResult(context, result);
}
return result;
}
public override IResult Execute(IResult previousResults)
{
try
{
if (string.IsNullOrWhiteSpace(ObjectKey))
throw new Exception("Object key cannot be null");
if (string.IsNullOrWhiteSpace(SettingsKey))
throw new Exception("Setting key cannot be null");
if (string.IsNullOrWhiteSpace(BaseText))
BaseText = "{0}";
var updateCollection = SettingsManager.GetTemporaryObject(ObjectKey) as UpdateCollection;
if (updateCollection == null)
throw new Exception("Update collection not present");
SettingsManager.SetTemporarySettingString(SettingsKey, string.Format(BaseText, updateCollection.Count));
return new NextResult();
}
catch (Exception e)
{
return new ExceptionOccurred(e);
}
}
public override IResult Execute(IResult previousResults)
{
try
{
if (!string.IsNullOrWhiteSpace(WindowTitle))
AdvancedMenuManager.WindowTitle = WindowTitle;
if (!string.IsNullOrWhiteSpace(DefaultTitle))
AdvancedMenuManager.DefaultTitle = DefaultTitle;
if (!string.IsNullOrWhiteSpace(DefaultDescription))
AdvancedMenuManager.DefaultDescription = DefaultDescription;
if (_leftOffset.HasValue)
AdvancedMenuManager.InitialLeftOffset = _leftOffset.Value;
if (_topOffset.HasValue)
AdvancedMenuManager.InitialTopOffset = _topOffset.Value;
if (!string.IsNullOrWhiteSpace(HelpTopic))
AdvancedMenuManager.HelpTopic = HelpTopic;
return new NextResult();
}
catch (Exception e)
{
return new ExceptionOccurred(e);
}
}
public override IResult Execute(IResult previousResults)
{
try
{
var eventData = new LoggingEventData
{
Level = Event.GetAssociatedLevel(),
Message = Message,
TimeStamp = DateTime.Now
};
if (eventData.Level == null)
{
Log.Warn("Cannot upload log event; Level is null");
return new NextResult();
}
if (string.IsNullOrWhiteSpace(eventData.Message))
eventData.Message = "[no content]";
var eventEntry = Asynchronous
? new LoggingEvent(eventData)
: new BlockingLoggingEvent(eventData);
Log.Logger.Log(eventEntry);
return new NextResult();
}
catch (Exception e)
{
Log.WarnFormat("An exception occurred while attempting to record a log event: {0}", e.Message);
return new NextResult();
}
}
public override IResult Execute(IResult previousResults)
{
try
{
if (string.IsNullOrWhiteSpace(Archive))
throw new Exception("The archive parameter cannot be null or empty");
if (string.IsNullOrWhiteSpace(Icon))
throw new Exception("The icon parameter cannot be null or empty");
if (!File.Exists(Archive))
return new FileNotFound { Target = Archive };
var trustedResult = CertificateUtilities.IsFileTrusted(Archive);
if (!trustedResult.Result)
return new CouldNotImportContent { Issue = trustedResult.Reason };
var bytes = CabArchiveUtilities.ExtractFile(Archive, Icon);
if (bytes == null)
throw new Exception(string.Format("Could not extract {0} from archive", Icon));
using (var stream = new MemoryStream(bytes))
AppearanceManager.ApplicationIcon = BitmapFrame.Create(stream);
return new NextResult();
}
catch (Exception e)
{
return new ExceptionOccurred(e);
}
}
public override IResult Execute(IResult previousResults)
{
try
{
if (string.IsNullOrWhiteSpace(Value))
throw new Exception("Cannot truncate value; value is empty.");
if (string.IsNullOrWhiteSpace(SettingKey))
throw new Exception("Setting key cannot be empty");
if (Length<=0)
throw new Exception("Length must be greater than zero");
var newValue = Value;
if (Length < Value.Length)
newValue = Value.Substring(0, Length);
SettingsManager.SetTemporarySettingString(SettingKey, newValue);
return new NextResult();
}
catch (Exception e)
{
Log.WarnFormat("An exception occurred while attempting to truncate a string: {0}", e.Message);
return new NextResult();
}
}
public override IResult Execute(IResult previousResults)
{
try
{
using (var controller = ServiceUtilities.GetServiceInstance("LanmanServer"))
{
if (controller == null)
{
if (!ServiceUtilities.IsServiceInfoInRegistry("LanmanServer"))
return new ServiceInfoNotInRegistry { ServiceName = "LanmanServer"};
return new ServiceInstanceNotAvailable { ServiceName = "LanmanServer" };
}
var result = Enabled ? EnableService(controller) : DisableService(controller);
if (!result.Result)
throw new Exception(result.Reason);
return new NextResult();
}
}
catch (Exception e)
{
return new ExceptionOccurred(e);
}
}
public override IResult Execute(IResult previousResults)
{
try
{
if (string.IsNullOrWhiteSpace(ChildDialog))
throw new Exception("Child dialog key cannot be null or empty");
if (string.IsNullOrWhiteSpace(Banner))
throw new Exception("Banner key cannot be null or empty");
var dialog = DialogsManager.GetExistingDialog(ParentDialog);
if (dialog == null)
return new DialogInstanceNotFound { Dialog = ParentDialog };
var childManager = DialogsManager.GetDialog<BorderedChildDialogModel>(ChildDialog);
if (childManager == null)
{
return new DialogInstanceNotFound { Dialog = ChildDialog };
}
return dialog.ShowChildBannerModal(childManager, Banner);
}
catch (Exception e)
{
return new ExceptionOccurred(e);
}
}
//, Result C)
protected void GreedySearchGlobalMinima(int parent, object q, IResult res)
{
var rs = this.SEQ.Unravel (parent);
var children_count = rs.Count1;
var closer_dist = double.MaxValue;
var closer_objID = -1;
for (int rank = 1; rank <= children_count; ++rank) {
var objID = rs.Select1(rank);
var dist = this.DB.Dist(q, this.DB[objID]);
res.Push (objID, dist);
if (dist < closer_dist) {
closer_dist = dist;
closer_objID = objID;
}
//if (C != null) C.Push (objID, dist);
}
if (closer_objID >= 0) {
this.GreedySearchGlobalMinima (closer_objID, q, res); //, C);
}
// for (int childID = 0; childID < children_count; ++childID) {
// var child_objID = C[childID];
// var child_dist = D[childID];
// var radius = res.CoveringRadius;
// //Console.WriteLine ("---- cov: {0}", this.COV[child_objID]);
// if (child_dist <= radius + this.GetCOV(child_objID) && child_dist <= closer_dist + radius + radius) {
// this.SearchKNNNode(child_objID, q, res);
// }
// }
}
public void HandleResult(IResult result)
{
if (result == null)
{
print ( "Null Response\n");
return;
}
// Some platforms return the empty string instead of null.
if (!string.IsNullOrEmpty(result.Error))
{
print("Error Response:\n" + result.Error);
}
else if (result.Cancelled)
{
print("Cancelled Response:\n" + result.RawResult);
}
else if (!string.IsNullOrEmpty(result.RawResult))
{
print("Success Response:\n" + result.RawResult);
getUserData();
}
else
{
print("Empty Response\n");
}
}
public override IResult Execute(IResult previousResults)
{
try
{
foreach (var setter in _setters)
{
var key = setter.Key;
var value = setter.Value;
if (string.IsNullOrWhiteSpace(key))
{
Log.Warn("Cannot retrieve settings value to user settings; settings key not specified");
continue;
}
var settingsPropertyName = value;
if (string.IsNullOrWhiteSpace(settingsPropertyName))
settingsPropertyName = key;
var settingsValue = Properties.Settings.Default.GetKeyedProperty(settingsPropertyName);
SettingsManager.SetTemporarySettingString(key, settingsValue);
}
return new NextResult();
}
catch (Exception e)
{
Log.Warn(e);
return new NextResult();
}
}
public override IResult Execute(IResult previousResults)
{
try
{
if (string.IsNullOrWhiteSpace(Target))
throw new InvalidOperationException("The target path cannot be empty");
if (!File.Exists(Target))
Target = Path.Combine(PathUtilities.DownloadFolder, Target);
if (!File.Exists(Target))
return new FileNotFound { Target = Target };
var result = CertificateUtilities.ImportUserCertificateFromFile(
Target,
SettingsManager.GetSecureTemporarySettingString(CredentialsKey));
if (!result.Result)
return new CouldNotImportContent{Issue = result.Reason};
return new NextResult();
}
catch (Exception e)
{
return new ExceptionOccurred(e);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ContinueResultDecorator"/> class.
/// </summary>
/// <param name="result">The result to decorate.</param>
/// <param name="coroutine">The coroutine to execute when <paramref name="result"/> was canceled.</param>
public ContinueResultDecorator(IResult result, Func<IEnumerable<IResult>> coroutine)
: base(result) {
if (coroutine == null)
throw new ArgumentNullException("coroutine");
this.coroutine = coroutine;
}
public override IResult Execute(IResult previousResults)
{
try
{
if (string.IsNullOrWhiteSpace(SettingKey))
throw new Exception("Setting key not specified");
var request =
EndpointManager.GetContract<AbstractLocationQueryContract>(EndPointFunctions.LocationQuery);
request.IgnoreCertificateErrors = true;
var result = request.MakeRequest<LocationQueryResult>();
if (result == null)
{
Log.WarnFormat("An issue occurred while querying server for location data: {0}",
request.GetErrorResult().GetDetails());
return null;
}
SettingsManager.SetTemporarySettingString(SettingKey, result.Location);
return new NextResult();
}
catch (Exception e)
{
return new ExceptionOccurred(e);
}
}
public IEnumerable<Bitmap> IteratePartsKNN(IResult res, double dqp, float stddev, float mean, Sequence seq)
{
var sym = this.Discretize(dqp, stddev, mean);
yield return seq.Unravel(sym);
var left = sym - 1;
var right = sym + 1;
bool do_next = true;
while (do_next) {
do_next = false;
var __left = this.Discretize(dqp - res.CoveringRadius, stddev, mean);
if (0 <= left && __left <= left) {
yield return seq.Unravel(left);
--left;
do_next = true;
}
var __right = this.Discretize(dqp + res.CoveringRadius, stddev, mean);
if (right <= __right && right < seq.Sigma) {
yield return seq.Unravel(right);
++right;
do_next = true;
}
/*Console.WriteLine ("left: {0}, right: {1}, __left: {2}, __right: {3}",
left, right, __left, __right);*/
}
}
private Task OnCommandExecuted(Optional <CommandInfo> commandInfo, ICommandContext context, IResult result)
{
if (!result.IsSuccess)
{
_logger.LogError("Failed running command {CommandName} for reason {Reason} in guild {Guild} ({GuildId}) for user {User} ({UserId})",
commandInfo.IsSpecified ? commandInfo.Value.Name : "Unknown",
result.ErrorReason,
context.Guild?.Name ?? "DM",
context.Guild?.Id ?? context.User.Id,
context.User.Username,
context.User.Id);
}
return(Task.CompletedTask);
}
private async Task HandleCommandResultAsync(Optional <CommandInfo> command, ICommandContext context, IResult result)
{
_commandScopes.TryRemove(context, out var commandScope);
using (commandScope)
{
if (!result.IsSuccess)
{
var error = $"{result.Error}: {result.ErrorReason}";
if (!string.Equals(result.ErrorReason, "UnknownCommand", StringComparison.OrdinalIgnoreCase))
{
Log.LogWarning(error);
}
else
{
Log.LogError(error);
}
if (result.Error != CommandError.Exception)
{
await _commandErrorHandler.AssociateError(context.Message, error);
}
else
{
await context.Channel.SendMessageAsync("Error: " + error);
}
}
}
}
/// <summary>
/// Adds behavior to the result which is executed when the <paramref name = "result" /> is cancelled
/// </summary>
/// <param name = "result"></param>
/// <returns></returns>
public static ICancelledHandler WhenCancelled(this IResult result)
{
return(new CancelledHandler(result));
}
/// <summary>
/// Adds a rescue for all exceptions to the <paramref name = "result" />
/// </summary>
/// <param name = "result"></param>
/// <returns></returns>
public static IExceptionHandler <Exception> Rescue(this IResult result)
{
return(Rescue <Exception>(result));
}
/// <summary>
/// Adds a rescue for <typeparamref name = "TException" /> to the <paramref name = "result" />
/// </summary>
/// <typeparam name = "TException"></typeparam>
/// <param name = "result"></param>
/// <returns></returns>
public static IExceptionHandler <TException> Rescue <TException>(this IResult result)
where TException : Exception
{
return(new RescueHandler <TException>(result));
}
/// <summary>
/// Returns an <see cref = "IEnumerable{IResult}" /> with one item, the result
/// </summary>
/// <param name = "result"></param>
/// <returns></returns>
public static IEnumerable <IResult> AsCoroutine(this IResult result)
{
yield return(result);
}
/// <summary>
/// Logs a failed HELO operation
/// </summary>
/// <param name="result"></param>
private static void LogFailedHelloOperation(IResult result)
{
Log.Info("Error when trying to execute HELO operation - {0} - {1}", result.Message, result.Exception);
}
public IResult PerformCommand(IMobileObject performer, ICommand command)
{
IResult result = base.PerfomCommand(performer, command);
if (result != null)
{
return(result);
}
if (command.Parameters.Count <= 0)
{
StringBuilder strBldr = new StringBuilder();
foreach (Equipment.AvalableItemPosition position in Enum.GetValues(typeof(Equipment.AvalableItemPosition)))
{
if (position != Equipment.AvalableItemPosition.NotWorn)
{
bool found = false;
foreach (IEquipment equipment in performer.EquipedEquipment)
{
if (equipment.ItemPosition == position)
{
strBldr.AppendLine(position.ToString() + " " + equipment.ShortDescription);
found = true;
break;
}
}
if (!found)
{
strBldr.AppendLine(position.ToString() + " <Nothing>");
}
}
}
return(new Result(strBldr.ToString().Trim(), true));
}
IParameter parm = command.Parameters[0];
IItem item = GlobalReference.GlobalValues.FindObjects.FindHeldItemsOnMob(performer, parm.ParameterValue, parm.ParameterNumber);
if (item != null)
{
if (!(item is IEquipment equipment) ||
equipment.ItemPosition == Equipment.AvalableItemPosition.NotWorn)
{
string message = string.Format("You can not equip the {0}.", item.SentenceDescription);
return(new Result(message, true));
}
IEquipment equipedItem = performer.EquipedEquipment.Where(i => i.ItemPosition == equipment.ItemPosition).FirstOrDefault();
if (equipedItem != null)
{
string message = string.Format("You already have {0} in the {1} position.", equipedItem.SentenceDescription, equipedItem.ItemPosition);
return(new Result(message, true));
}
else
{
performer.Items.Remove(equipment);
performer.AddEquipment(equipment);
string message = string.Format("You equipped the {0}.", equipment.SentenceDescription);
return(new Result(message, false));
}
}
else
{
string message = string.Format("You were unable to find {0}.", parm.ParameterValue);
return(new Result(message, true));
}
}
/// <summary> /// Creates a new instance of <see cref="Passed"/>, if the <paramref name="condition"/> is true and <paramref name="result"/> is not already <see cref="Failed"/>. /// Otherwise a new instance of <see cref="Failed"/> is created. /// </summary> /// <param name="result">The source <see cref="IResult"/> object the returned object is based on.</param> /// <param name="condition">If true creates <see cref="Passed"/>, otherwise <see cref="Failed"/>.</param> /// <returns>A new instance of <see cref="IResult"/> with the requested modifications.</returns> public static IResult PassIf(this IResult result, bool condition) => condition?result.Pass() : result.Fail();
public async Task CommandExecutedAsync(Optional <CommandInfo> command, ICommandContext context, IResult result)
{
// command is unspecified when there was a search failure (command not found); we don't care about these errors
if (!command.IsSpecified)
{
return;
}
// the command was successful, we don't care about this result, unless we want to log that a command succeeded.
if (result.IsSuccess)
{
return;
}
// the command failed, let's notify the user that something happened.
await context.Channel.SendMessageAsync($"error: {result}");
}
public TestableResultDecorator(IResult inner)
: base(inner)
{
}
public static ISelect <None, IEnumerable <T> > Many <T>(this IResult <IFixture> @this, uint count) => @this.Then().Select(new Many <T>(count)).Accept().Get();
public ArrayStore(IResult <Array <T> > source) : this(source.Get)
{
}
public IResult PerformCommand(IMobileObject performer, ICommand command)
{
IResult result = base.PerfomCommand(performer, command);
if (result != null)
{
return(result);
}
if (command.Parameters.Count <= 0)
{
return(new Result("What would you like to get?", true));
}
else if (command.Parameters.Count == 1)
{
IParameter parameter = command.Parameters[0];
if (parameter.ParameterValue.ToUpper() == "ALL")
{
for (int i = performer.Room.Items.Count - 1; i >= 0; i--)
{
IItem roomItem = performer.Room.Items[i];
ICommand innerCommand = new Command();
IParameter innerParameter = new Parameter(roomItem.KeyWords[0]);
innerCommand.Parameters.Add(innerParameter);
IResult innerResult = PerformCommand(performer, innerCommand);
GlobalReference.GlobalValues.Notify.Mob(performer, new TranslationMessage(innerResult.ResultMessage));
}
return(new Result("", false));
}
else
{
IItem item = GlobalReference.GlobalValues.FindObjects.FindItemsInRoom(performer.Room, parameter.ParameterValue, parameter.ParameterNumber);
if (item != null)
{
if (!item.Attributes.Contains(ItemAttribute.NoGet))
{
if (item is ICorpse corpse)
{
if (corpse.Killer != null) //allow you to pick up corpses that don't have a killer
{
IPlayerCharacter playerCharacter = performer as IPlayerCharacter;
if ((corpse.Killer != performer &&
corpse.OriginalMob != performer) &&
(playerCharacter != null &&
corpse.Killer.SentenceDescription != performer.SentenceDescription &&
corpse.OriginalMob.SentenceDescription != performer.SentenceDescription))
{
return(new Result($"Unable to pickup the corpse belonging to {corpse.Killer.KeyWords[0]}.", true));
}
}
}
IRoom room = performer.Room;
GlobalReference.GlobalValues.Engine.Event.Get(performer, item);
room.RemoveItemFromRoom(item);
AddItemToPerformer(performer, item);
string message = string.Format("You pickup the {0}.", item.SentenceDescription);
return(new Result(message, false));
}
else
{
string message = string.Format("You were unable to get {0}.", item.SentenceDescription);
return(new Result(message, true));
}
}
else
{
string message = string.Format("You were unable to find {0}.", parameter.ParameterValue);
return(new Result(message, true));
}
}
}
else
{
IParameter parameterContainer = command.Parameters[1];
if (GlobalReference.GlobalValues.FindObjects.FindObjectOnPersonOrInRoom(performer, parameterContainer.ParameterValue, parameterContainer.ParameterNumber, true, true, false, false) is IContainer container)
{
if (container is ICorpse corpse)
{
if (corpse.Killer != performer)
{
return(new Result($"Unable to get items from the corpse belonging to {corpse.Killer.KeyWords[0]}.", true));
}
}
IParameter parameterItem = command.Parameters[0];
if (parameterItem.ParameterValue.ToUpper() == "ALL")
{
for (int i = container.Items.Count - 1; i >= 0; i--)
{
IItem containerItem = container.Items[i];
ICommand innerCommand = new Command();
IParameter innerParameter = new Parameter(containerItem.KeyWords[0]);
innerCommand.Parameters.Add(innerParameter);
innerCommand.Parameters.Add(parameterContainer);
IResult innerResult = PerformCommand(performer, innerCommand);
GlobalReference.GlobalValues.Notify.Mob(performer, new TranslationMessage(innerResult.ResultMessage));
}
return(new Result("", false));
}
else
{
List <IItem> foundItems = container.Items.FindAll(i => i.KeyWords.Contains(parameterItem.ParameterValue)).ToList();
if (foundItems.Count > parameterItem.ParameterNumber)
{
IItem item = foundItems[parameterItem.ParameterNumber];
string message;
if (!item.Attributes.Contains(ItemAttribute.NoGet))
{
GlobalReference.GlobalValues.Engine.Event.Get(performer, item, container);
container.Items.Remove(item);
AddItemToPerformer(performer, item);
if (item is IMoney)
{
IMoney money = item as IMoney;
string moneyString = GlobalReference.GlobalValues.MoneyToCoins.FormatedAsCoins(money.Value);
message = string.Format("You get the {0} from the {1}.", moneyString, parameterContainer.ParameterValue);
}
else
{
message = string.Format("You get the {0} from the {1}.", parameterItem.ParameterValue, parameterContainer.ParameterValue);
}
}
else
{
message = string.Format("You were unable to get {0}.", item.SentenceDescription);
}
return(new Result(message, false));
}
else
{
string message = string.Format("Unable to find item {0} in container {1}.", parameterItem.ParameterValue, parameterContainer.ParameterValue);
return(new Result(message, true));
}
}
}
else
{
string message = string.Format("Unable to find container {0}.", parameterContainer.ParameterValue);
return(new Result(message, true));
}
}
}
/// <summary>
/// Executes the <paramref name="result"/> on a seperate worker thread
/// </summary>
/// <param name="result"></param>
/// <returns></returns>
public static IResult OnWorkerThread(this IResult result)
{
return(new WorkerThreadResultDecorator(result));
}
public static IResult <TValue> Run <TValue, TPreviousValue>(Func <TValue> func, IResult <TPreviousValue> previousResult)
{
try
{
return(new SuccessResult <TValue>(func(), previousResult));
}
catch (Exception ex)
{
return(new ErrorResult <TValue, Exception>(ex, previousResult: previousResult));
}
}
public static IError AddExceptionError <T>(this IResult <T> result, string key, Exception exception)
{
var message = $"{exception.Message}\n{exception.StackTrace}";
return(result.AddError(ErrorType.Error, key, message));
}
public OwnApiHttpResponse Edit([FromBody] RopSysRoleEdit rop)
{
IResult result = AdminServiceFactory.SysRole.Edit(this.CurrentUserId, Enumeration.BelongSite.Admin, rop);
return(new OwnApiHttpResponse(result));
}
public OwnApiHttpResponse InitAdd()
{
IResult result = AdminServiceFactory.SysRole.InitAdd(this.CurrentUserId, Enumeration.BelongSite.Admin);
return(new OwnApiHttpResponse(result));
}
public static TaskResult GetTaskResult(this IResult result)
{
return(s_taskResults[result.State]);
}
protected void Create(DM model)
{
IResult result = this.Presenter.Add(model);
this.TakeIResult(result);
}
public OwnApiHttpResponse InitEdit([FromUri] string id)
{
IResult result = AdminServiceFactory.SysRole.InitEdit(this.CurrentUserId, Enumeration.BelongSite.Admin, id);
return(new OwnApiHttpResponse(result));
}
protected void UnDelete(object model)
{
IResult result = this.Presenter.UnDelete(model);
this.TakeIResult(result);
}
public OwnApiHttpResponse GetList([FromUri] RupSysRoleGetList rup)
{
IResult result = AdminServiceFactory.SysRole.GetList(this.CurrentUserId, Enumeration.BelongSite.Admin, rup);
return(new OwnApiHttpResponse(result));
}
public OuterDecorator(IResult result)
{
this.Result = result;
}
protected void GetById <TModel>(object id, ref TModel outModel)
{
IResult result = this.Presenter.GetById <TModel>(id);
this.TakeIResult(result, ref outModel);
}
public static IError AddValidationError <T>(this IResult <T> result, string key, string message) => result.AddError(ErrorType.ValidationError, key, message);
protected void Edit(DM model)
{
IResult result = this.Presenter.Update(model);
this.TakeIResult(result);
}
public static bool HasValidationErrors <T>(this IResult <T> result) => result.HasErrors(ErrorType.ValidationError);
public InnerDecorator(IResult result)
{
this.Result = result;
}