public FlowManager(
IConfiguration configuration,
IStateManager stateManager,
IContextProvider contextProvider,
INamedSemaphore namedSemaphore,
IActionProvider actionProvider,
ISender sender,
IDocumentSerializer documentSerializer,
IEnvelopeSerializer envelopeSerializer,
IArtificialIntelligenceExtension artificialIntelligenceExtension,
IVariableReplacer variableReplacer,
ILogger logger,
ITraceManager traceManager,
IUserOwnerResolver userOwnerResolver,
IInputExpirationHandler inputExpirationHandler,
Application application)
{
_configuration = configuration;
_stateManager = stateManager;
_contextProvider = contextProvider;
_namedSemaphore = namedSemaphore;
_actionProvider = actionProvider;
_sender = sender;
_documentSerializer = documentSerializer;
_envelopeSerializer = envelopeSerializer;
_artificialIntelligenceExtension = artificialIntelligenceExtension;
_variableReplacer = variableReplacer;
_logger = logger;
_traceManager = traceManager;
_userOwnerResolver = userOwnerResolver;
_inputExpirationHandler = inputExpirationHandler;
_applicationIdentity = application.Identity;
_applicationNode = application.Node;
}
public async void InitFromMetadata(IActionProvider actionProvider, Base.ActionMetadata actionMetadata, Base.ActionPoint actionPoint)
{
InitDialog(actionProvider, actionMetadata, actionPoint);
actionParameters = await Base.Parameter.InitActionParameters(actionProvider.GetProviderId(), actionParametersMetadata.Values.ToList(), DynamicContent, OnChangeParameterHandler, DynamicContentLayout, CanvasRoot, CurrentActionPoint, false);
nameInput.SetValue(Base.ProjectManager.Instance.GetFreeActionName(actionMetadata.Name));
}
private static void Dispose()
{
protocol = null;
commandManager = null;
actionProvider = null;
testManager = null;
}
private void BindConnections()
{
// First test if connections are possible
if (_activeSection.ModuleType != null)
{
ModuleBase moduleInstance = base.ModuleLoader.GetModuleFromSection(_activeSection);
if (moduleInstance is IActionProvider)
{
IActionProvider actionProvider = (IActionProvider)moduleInstance;
// OK, show connections panel
pnlConnections.Visible = true;
rptConnections.DataSource = _activeSection.Connections;
rptConnections.DataBind();
if (_activeSection.Connections.Count < actionProvider.GetOutboundActions().Count)
{
hplNewConnection.Visible = true;
if (ActiveNode != null)
{
hplNewConnection.NavigateUrl =
String.Format("~/Admin/ConnectionEdit.aspx?NodeId={0}&SectionId={1}", ActiveNode.Id,
_activeSection.Id);
}
else
{
hplNewConnection.NavigateUrl = String.Format("~/Admin/ConnectionEdit.aspx?SectionId={0}",
_activeSection.Id);
}
}
else
{
hplNewConnection.Visible = false;
}
}
}
}
//////////////////////////////////////////////////////////////////////////
public static void GetActionByName(string ActionName, List<IActionProvider> ActiveObjects, out IActionProvider OutObj, out Action OutAct)
{
OutObj = null;
OutAct = null;
if(Actions.ContainsKey(ActionName))
{
List<Action> Acts = Actions[ActionName];
// find nearest available object, if any
foreach (IActionProvider Obj in ActiveObjects)
{
foreach(Action Act in Acts)
{
if (Act.ContextType == Obj.GetType())
{
OutObj = Obj;
OutAct = Act;
return;
}
}
}
}
return;
}
private void Page_Load(object sender, EventArgs e)
{
if (Context.Request.QueryString["SectionId"] != null)
{
Title = "Add connection";
// Get section data
_activeSection = (Section)base.CoreRepository.GetObjectById(typeof(Section),
Int32.Parse(
Context.Request.QueryString["SectionId"
]));
ModuleBase moduleInstance = base.ModuleLoader.GetModuleFromSection(_activeSection);
if (moduleInstance is IActionProvider)
{
_activeActionProvider = moduleInstance as IActionProvider;
if (!IsPostBack)
{
BindSection();
BindCompatibleSections();
}
}
else
{
ShowError("The module that is connected to the section doesn't support outgoing connections.");
}
}
}
public async Task ApplyShouldReturnSuccessResponseWhenActionHandlerWasSuccessfullyProcessed()
{
// Arrange
var action = new TestAction(nameof(ApplyShouldReturnNoMatchingActionResponseWhenProviderReturnsFalse));
Mock.Get(this.reducer)
.Setup(r => r.TryGetProvider(TestStateId.New, out It.Ref <IActionProvider <TestStateSubject> > .IsAny))
.Callback(new StateOutputCallback <TestStateSubject>((StateId id, out IActionProvider <TestStateSubject> provider) =>
{
provider = this.provider;
}))
.Returns(true);
Mock.Get(this.provider)
.Setup(p => p.TryGet(out It.Ref <IActionHandler <TestAction, TestStateSubject> > .IsAny))
.Callback(new ActionOutputCallback <TestAction, TestStateSubject>((out IActionHandler <TestAction, TestStateSubject> handler) =>
{
handler = this.handler;
}))
.Returns(true);
Mock.Get(this.handler)
.Setup(h => h.Execute(action, It.Is <IStateView <TestStateSubject> >(x => x.StateId == TestStateId.New && x.Subject == this.context)))
.ReturnsAsync(TestStateId.Processing);
Mock.Get(this.reducer)
.Setup(r => r.SetState(It.Is <StateId>(x => x.Name == TestStateId.Processing.Name), this.context));
// Act
var result = await this.state.Apply(action);
// Assert
Assert.Equal(StateResponse.Success.Id, result?.Id);
}
//////////////////////////////////////////////////////////////////////////
public void DeactivateObject(IActionProvider Obj)
{
if (ActiveObjects.Contains(Obj))
{
ActiveObjects.Remove(Obj);
}
}
//////////////////////////////////////////////////////////////////////////
public void ActivateObject(IActionProvider Obj)
{
if (!ActiveObjects.Contains(Obj))
{
ActiveObjects.Insert(0, Obj);
}
}
private void resources_CallManager_IncomingCallNotification(int callId, string number, string info)
{
_log.Info("Incoming call with id '{0}' from '{1}', info: {2}", callId, number, info);
//HACK: how to discover accountid?
IAccount account = _resources.Configurator.Accounts[0];
IActionProvider actionProvider = null;
if (account != null && typeof(IActionProvider).IsAssignableFrom(account.GetType()))
{
actionProvider = (IActionProvider)account;
}
SIPIncomingCall call = new SIPIncomingCall(this, _resources, callId, number, actionProvider);
call.CallState = CallState.Ringing;
lock (_calls)
{
_calls.Add(call);
}
if (OnIncomingCall != null)
{
OnIncomingCall(call);
}
}
public AutoFillAction(IActionProvider actionProvider, IEnumerable <IWebElement> elements, object seedWith)
{
_actionProvider = actionProvider;
_elements = elements;
_seedWith = seedWith;
_isSimpleSeed = IsSeedSimple();
_constraintHelper = _actionProvider.UsingFixture.Data.Locate <IConstraintHelper>();
}
public static void InitializeApp()
{
CheckData();
protocol = new Protocol();
commandManager = new CommandManager(protocol);
actionProvider = new ActionProvider(commandManager);
testManager = new TestManager(actionProvider);
}
public SIPCall(SIPCallProvider callProvider, SipekResources resources, int sipekCallId, IActionProvider actionProvider)
{
_resources = resources;
_sipekCallId = sipekCallId;
_callProvider = callProvider;
_actionProvider = actionProvider;
_date = DateTime.Now;
}
public SIPCall(SIPCallProvider callProvider, SipekResources resources, int sipekCallId, IActionProvider actionProvider)
{
_resources = resources;
_sipekCallId = sipekCallId;
_callProvider = callProvider;
_actionProvider = actionProvider;
_date = DateTime.Now;
}
public StateTests()
{
this.reducer = Mock.Of <IStateReducer <TestStateSubject> >(MockBehavior.Strict);
this.provider = Mock.Of <IActionProvider <TestStateSubject> >(MockBehavior.Strict);
this.handler = Mock.Of <IActionHandler <TestAction, TestStateSubject> >(MockBehavior.Strict);
this.context = new TestStateSubject();
this.state = new State <TestStateSubject>(TestStateId.New, this.context, this.reducer);
}
protected override void OnExecute(IActionProvider provider, IContext context)
{
for (int i = 0; i < m_actions.Count; i++)
{
IAction action = m_actions[i];
action.Execute(provider, context);
}
}
public RecordActionsState(BaseController controller, int actionsCount)
{
this.controller = controller;
this.attacker = controller.Attacker;
this.actionsCount = actionsCount;
timePassed = 0;
this.timer = (float)Global.config.GetValue("Config", "AttackTime");
}
public BuildingPlanExecutionJob(IServiceProvider service) : base(service)
{
_buildingRepository = service.GetService <IBuildingRepository>();
_villageRepository = service.GetService <IVillageRepository>();
_mapper = service.GetService <IMapper>();
_actionProvider = service.GetService <IActionProvider>();
_commandFactory = service.GetService <ICommandFactory>();
_unitRepository = service.GetService <IUnitRepository>();
}
public XmlActionPatternProvider(string xmlPath, IActionProvider actionProvider, IPatternProvider patternProvider)
{
if (xmlPath == null) throw new ArgumentNullException("xmlPath");
if (actionProvider == null) throw new ArgumentNullException("actionProvider");
if (patternProvider == null) throw new ArgumentNullException("patternProvider");
_ActionProvider = actionProvider;
_PatternProvider = patternProvider;
LoadXml(XmlReader.Create(xmlPath));
}
public PageBaseFactory(IWebDriver driver, IActionProvider action, IBaseElement element)
{
Contract.Requires(driver != null);
Contract.Requires(action != null);
Contract.Requires(element != null);
_driver = driver;
_element = PageOperation(_driver, element);
_action = action;
}
public XmlActionPatternProvider(Stream xmlStream, IActionProvider actionProvider, IPatternProvider patternProvider)
{
if (xmlStream == null) throw new ArgumentNullException("xmlStream");
if (actionProvider == null) throw new ArgumentNullException("actionProvider");
if (patternProvider == null) throw new ArgumentNullException("patternProvider");
_ActionProvider = actionProvider;
_PatternProvider = patternProvider;
LoadXml(XmlReader.Create(xmlStream));
}
public XmlActionPatternProvider(XmlReader xmlReader, IActionProvider actionProvider, IPatternProvider patternProvider)
{
if (xmlReader == null) throw new ArgumentNullException("xmlReader");
if (actionProvider == null) throw new ArgumentNullException("actionProvider");
if (patternProvider == null) throw new ArgumentNullException("patternProvider");
_ActionProvider = actionProvider;
_PatternProvider = patternProvider;
LoadXml(xmlReader);
}
public async void CreateNewAction(string action_id, IActionProvider actionProvider, string newName = null)
{
try {
ActionMetadata actionMetadata = actionProvider.GetActionMetadata(action_id);
List <IParameter> actionParameters = await Base.Parameter.InitActionParameters(actionProvider.GetProviderId(),
actionMetadata.ParametersMetadata.Values.ToList(), HiddenPlace, OnChangeParameterHandler, HiddenPlaceLayout, HiddenPlace, currentActionPoint, false, CanvasGroup);
string newActionName;
if (string.IsNullOrEmpty(newName))
{
newActionName = Base.ProjectManager.Instance.GetFreeActionName(actionMetadata.Name);
}
else
{
newActionName = Base.ProjectManager.Instance.GetFreeActionName(newName);
}
if (Base.Parameter.CheckIfAllValuesValid(actionParameters))
{
List <IO.Swagger.Model.ActionParameter> parameters = new List <IO.Swagger.Model.ActionParameter>();
foreach (IParameter actionParameter in actionParameters)
{
if (!actionMetadata.ParametersMetadata.TryGetValue(actionParameter.GetName(), out Base.ParameterMetadata actionParameterMetadata))
{
Base.Notifications.Instance.ShowNotification("Failed to create new action", "Failed to get metadata for action parameter: " + actionParameter.GetName());
return;
}
IO.Swagger.Model.ActionParameter ap = new IO.Swagger.Model.ActionParameter(name: actionParameter.GetName(), value: JsonConvert.SerializeObject(actionParameter.GetValue()), type: actionParameter.GetCurrentType());
parameters.Add(ap);
}
try {
addedActionName = newActionName;
Hide();
AREditorResources.Instance.LeftMenuProject.SetActiveSubmenu(AREditorResources.Instance.LeftMenuProject.CurrentSubmenuOpened);
await Base.WebsocketManager.Instance.AddAction(currentActionPoint.GetId(), parameters, Base.Action.BuildActionType(
actionProvider.GetProviderId(), actionMetadata.Name), newActionName, actionMetadata.GetFlows(newActionName));
foreach (Transform t in HiddenPlace.transform)
{
if (!t.CompareTag("Persistent"))
{
Destroy(t.gameObject);
}
}
} catch (Base.RequestFailedException e) {
Base.Notifications.Instance.ShowNotification("Failed to add action", e.Message);
addedActionName = null;
}
}
} catch (Base.RequestFailedException e) {
Base.Notifications.Instance.ShowNotification("Failed to add action", e.Message);
}
}
public XmlActionPatternProvider(Assembly assembly, string resourceName, IActionProvider actionProvider, IPatternProvider patternProvider)
{
if (assembly == null) throw new ArgumentNullException("assembly");
if (actionProvider == null) throw new ArgumentNullException("actionProvider");
if (patternProvider == null) throw new ArgumentNullException("patternProvider");
_ActionProvider = actionProvider;
_PatternProvider = patternProvider;
Stream stream = assembly.GetManifestResourceStream(resourceName);
LoadXml(XmlReader.Create(stream));
}
public RateItViewModel(IShortcutService shortcutService, IActionProvider actionProvider, ISegmentSupervisor segmentSupervisor, IMessageBoxService messageBoxService, EditorController editorController)
{
_actionProvider = actionProvider;
_segmentSupervisor = segmentSupervisor;
_messageBoxService = messageBoxService;
_editorController = editorController;
_shortcutService = shortcutService;
Initialize();
UpdateActionTooltips();
}
protected override void OnExecute(IActionProvider provider, IContext context)
{
if (provider.Current.TryGet(out IActionCommandList <TCommand> commands))
{
for (int i = 0; i < commands.Count; i++)
{
TCommand command = commands.Get(i);
OnExecute(provider, context, command);
}
}
}
public DeathState(BaseController controller, IActionProvider deadman)
{
this.deadman = deadman;
this.controller = controller;
timePassed = 0;
deadman.Reset();
koSound = (AudioStreamPlayer)this.controller.GetNode("Sounds").GetNode("KOSound");
koSound.Play();
deadman.Animate(Action.Death);
controller.ResetKOLabel();
}
public void ActionAdded(IO.Swagger.Model.Action projectAction, string parentId)
{
ActionPoint actionPoint = GetActionPoint(parentId);
IActionProvider actionProvider = GetActionProvider(Action.ParseActionType(projectAction.Type).Item1);
Base.Action action = SpawnAction(projectAction.Id, projectAction.Name, Action.ParseActionType(projectAction.Type).Item2, actionPoint, actionProvider);
// updates name of the action
action.ActionUpdateBaseData(projectAction);
// updates parameters of the action
action.ActionUpdate(projectAction);
OnProjectChanged?.Invoke(this, EventArgs.Empty);
}
private void SetupDependencyInjection(IWebDriver webDriver,
SeleniumFixtureConfiguration configuration,
DefaultFixtureConfiguration dataConfiguration)
{
Data = new SimpleFixture.Fixture(dataConfiguration);
Data.Return(this);
Data.Return(webDriver);
Data.Return(configuration.BaseAddress).WhenNamed("BaseAddress");
Data.Return(() => Data.Configuration.Locate <IConstraintHelper>());
Driver = webDriver;
Data.Behavior.Add((r, o) =>
{
if (o.GetType().IsValueType || o is string)
{
return(o);
}
PageFactory.InitElements(webDriver, o);
return(o);
});
Data.Behavior.Add(ImportPropertiesOnLocate);
_actionProvider = new FixtureActionProvider(this);
Data.Return(_actionProvider);
if (Configuration.ExecuteValidate)
{
Data.Behavior.Add(ValidateBehavior);
}
Data.Export <AutoFillAction>().As <IAutoFillAction>();
Data.Export <AutoFillAsActionProvider>().As <IAutoFillAsActionProvider>();
Data.Export <ClearAction>().As <IClearAction>();
Data.Export <ClickAction>().As <IClickAction>();
Data.Export <DoubleClickAction>().As <IDoubleClickAction>();
Data.Export <FillAction>().As <IFillAction>();
Data.Export <GetAction>().As <IGetAction>();
Data.Export <MouseMoveAction>().As <IMouseMoveAction>();
Data.Export <NavigateAction>().As <INavigateAction>();
Data.Export <SendToAction>().As <ISendToAction>();
Data.Export <SwitchAction>().As <ISwitchToAction>();
Data.Export <TakeScreenshotAction>().As <ITakeScreenshotAction>();
Data.Export <WaitAction>().As <IWaitAction>();
Data.Export <YieldsAction>().As <IYieldsAction>();
}
public CoreEngine(IUIEngine uiEngine, IField field, IPlayer player, IActionProvider actionProvider = null, IMovement movement = null, ISolvedChecker solvedChecker = null)
{
this._uiEngine = uiEngine;
this._inputProvider = uiEngine.InputProvider;
this._field = field;
this._player = player;
this._highScores = HighScores.Instance;
this.ActionProvider = actionProvider ?? new DefaultActionProvider(this);
this.Movement = movement ?? new BackwardMovement(field);
this.SolvedChecker = solvedChecker ?? new DefaultSolvedChecker();
this.AttachUIToEvents();
}
public virtual void Init(IO.Swagger.Model.Action projectAction, ActionMetadata metadata, ActionPoint ap, IActionProvider actionProvider)
{
ActionPoint = ap;
this.metadata = metadata;
ActionProvider = actionProvider;
Data = projectAction;
UpdateName(Data.Name);
if (actionProvider != null)
{
UpdateType();
}
//UpdateRotation(null);
SelectorItem = SelectorMenu.Instance.CreateSelectorItem(this);
}
public static void RegisterContext(string contextName, IActionProvider obj, params string[] properties)
{
Contexts[contextName] = obj;
obj.PropertyChanged += (s, e) =>
{
if (properties.Contains(e.PropertyName))
Refresh();
};
Actions[contextName] = new List<CharmAction>();
foreach (var item in obj.ProvideActions())
{
Actions[contextName].Add(item);
}
}
public NegateActionsState(BaseController controller, List <Action> recordedActions)
{
this.controller = controller;
this.defender = controller.Defender;
this.attacker = this.controller.Attacker;
this.recordedActions = recordedActions;
timePassed = 0;
iterator = 0;
this.timer = (float)Global.config.GetValue("Config", "DefendTime");
gruntSound = (AudioStreamPlayer)this.controller.GetNode("Sounds").GetNode("GruntSound");
evadeSound = (AudioStreamPlayer)this.controller.GetNode("Sounds").GetNode("EvadeSound");
}
public TestManager(IActionProvider actionProvider)
{
this.actionProvider = actionProvider;
this.testFiles = TestFiles.GetTestCollection();
this.testNames = TestFiles.GetTestNames();
this.pageFiles = new DataProvider().GetPageFiles();
this.cases = new TestCaseParser(testFiles).GetCases();
this.testResults = new TestResults(testNames);
InitializePages();
InitializeTests();
this.validator = new Validator(this);
}
public void InitDialog(IActionProvider actionProvider, Base.ActionMetadata actionMetadata, Base.ActionPoint actionPoint) {
this.actionMetadata = actionMetadata;
CurrentActionPoint = actionPoint;
this.actionProvider = actionProvider;
actionParametersMetadata = new Dictionary<string, Base.ActionParameterMetadata>();
foreach (IO.Swagger.Model.ActionParameterMeta meta in actionMetadata.Parameters) {
actionParametersMetadata.Add(meta.Name, new Base.ActionParameterMetadata(meta));
}
foreach (Transform t in DynamicContent.transform) {
Destroy(t.gameObject);
}
nameInput.SetLabel("Name", "Name of the action");
nameInput.SetType("string");
}
public App()
{
_actionProvider = new PropertyActionProvider(this);
actions = _actionProvider.GetActions();
actionLog = _actionProvider.GetActionLog();
actions.actionDeleted += actionLog.OnActionRemoved;
Logging.logger.WriteMessage(actionLog);
InitializeComponent();
MainPage = new NavigationPage(new TimeLoggingApp.MainPage());
}
//////////////////////////////////////////////////////////////////////////
public bool Invoke(IActionProvider Provider, object Sender)
{
try
{
ActionParam Param = new ActionParam();
Param.Type = ActionParam.QueryType.Invoke;
Param.Processed = false;
Method.Invoke(Provider, new object[] { Param });
return(Param.Processed);
}
catch
{
return(false);
}
}
public static void RegisterContext(string contextName, IActionProvider obj, params string[] properties)
{
Contexts[contextName] = obj;
obj.PropertyChanged += (s, e) =>
{
if (properties.Contains(e.PropertyName))
{
Refresh();
}
};
Actions[contextName] = new List <CharmAction>();
foreach (var item in obj.ProvideActions())
{
Actions[contextName].Add(item);
}
}
//////////////////////////////////////////////////////////////////////////
public State GetState(IActionProvider Provider)
{
try
{
ActionParam Param = new ActionParam();
Param.Type = ActionParam.QueryType.GetState;
Param.Processed = false;
Method.Invoke(Provider, new object[] { Param });
if (Param.Processed) return Param.State;
else return State.Sensitive;
}
catch
{
return State.Sensitive;
}
}
public void DoWorkAsync(IActionProvider provider)
{
exitState = ExitState.NORMAL;
CancellationToken token = tokenSource.Token;
Task mainTask = Task.Factory.StartNew(() =>
{
while (true)
{
if (token.IsCancellationRequested) break;
try
{
Action[] actions = provider.GetActions();
if (actions.Length == 0) break;
List<Task> tasks = new List<Task>();
foreach (Action action in actions)
{
if (token.IsCancellationRequested) break;
try
{
Task subtask = Task.Factory.StartNew(action, token);
subtask.ContinueWith(TaskFailed, TaskContinuationOptions.OnlyOnFaulted);
tasks.Add(subtask);
}
catch
{
exitState = ExitState.ERROR;
tokenSource.Cancel();
break;
}
}
try
{
Task.WaitAll(tasks.ToArray(), tokenSource.Token);
}
catch (OperationCanceledException){}
}
catch
{
exitState = ExitState.ERROR;
break;
}
}
}, TaskCreationOptions.LongRunning);
mainTask.ContinueWith(Done, scheduler);
}
//////////////////////////////////////////////////////////////////////////
public bool CustomBuild(IActionProvider Provider, ToolStripItemCollection Items, bool AsMenu)
{
try
{
ActionParam Param = new ActionParam();
Param.Type = ActionParam.QueryType.CustomBuild;
Param.Items = Items;
Param.BuildAsMenu = AsMenu;
Param.Processed = false;
Method.Invoke(Provider, new object[] { Param });
return Param.Processed;
}
catch
{
return false;
}
}
//////////////////////////////////////////////////////////////////////////
public bool LoadData(IActionProvider Provider, ActionData Data)
{
try
{
ActionParam Param = new ActionParam();
Param.Type = ActionParam.QueryType.SaveData;
Param.Processed = false;
Param.Data = Data;
Method.Invoke(Provider, new object[] { Param });
return Param.Processed;
}
catch
{
return false;
}
}
//////////////////////////////////////////////////////////////////////////
public void ActivateObject(ActiveObjectSlot Slot, IActionProvider Obj)
{
ActiveObjectSlots[(int)Slot] = Obj;
StripBuilder.RefreshManagedToolStrips();
}
//////////////////////////////////////////////////////////////////////////
public bool Invoke(IActionProvider Provider, object Sender)
{
try
{
ActionParam Param = new ActionParam();
Param.Type = ActionParam.QueryType.Invoke;
Param.Processed = false;
Method.Invoke(Provider, new object[] { Param });
return Param.Processed;
}
catch
{
return false;
}
}
public static void RemoveHandler(IActionProvider provider, ActionEventHandler handler)
{
if (!map.ContainsKey(provider))
{
return;
}
ActionDispatcher dispatcher = map[provider];
dispatcher.ActionEvent -= handler;
if (dispatcher.ActionEvent.GetInvocationList().Length == 0)
{
dispatcher.Release();
map.Remove(provider);
}
}
public static void AddHandler(IActionProvider provider, ActionEventHandler handler)
{
ActionDispatcher dispatcher;
if (map.ContainsKey(provider))
{
dispatcher = map[provider];
}
else
{
dispatcher = new ActionDispatcher(provider);
map.Add(provider, dispatcher);
}
dispatcher.ActionEvent += handler;
}
public SIPIncomingCall(SIPCallProvider callProvider, SipekResources resources, int sipekCallId, String remoteIdentifier, IActionProvider actionProvider)
:base(callProvider, resources, sipekCallId, actionProvider)
{
_remoteIdentifier = remoteIdentifier;
}
//////////////////////////////////////////////////////////////////////////
public bool Invoke(IActionProvider Provider, object Sender)
{
#if !DEBUG
try
{
#endif
ActionParam Param = new ActionParam();
Param.Type = ActionParam.QueryType.Invoke;
Param.Sender = Sender;
Param.Processed = false;
Method.Invoke(Provider, new object[] { Param });
return Param.Processed;
#if !DEBUG
}
catch(Exception e)
{
MessageBox.Show("Error invoking command:\n\n" + e.InnerException.Message, "", MessageBoxButtons.OK, MessageBoxIcon.Error);
return false;
}
#endif
}
//////////////////////////////////////////////////////////////////////////
public ActionState GetState(IActionProvider Provider, object Sender)
{
try
{
ActionParam Param = new ActionParam();
Param.Type = ActionParam.QueryType.GetState;
Param.Sender = Sender;
Param.State = new ActionState(true, true);
Method.Invoke(Provider, new object[] { Param });
return Param.State;
}
catch
{
return new ActionState(false);
}
}
//////////////////////////////////////////////////////////////////////////
public ActionData SaveData(IActionProvider Provider)
{
try
{
ActionParam Param = new ActionParam();
Param.Type = ActionParam.QueryType.SaveData;
Param.Processed = false;
Param.Data = null;
Method.Invoke(Provider, new object[] { Param });
if (Param.Processed) return Param.Data;
else return null;
}
catch
{
return null;
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (Context.Request.QueryString["SectionId"] != null)
{
Title = "Add connection";
ModuleBase moduleInstance = ModuleLoader.GetModuleFromSection(_activeSection);
if (moduleInstance is IActionProvider)
{
_activeActionProvider = moduleInstance as IActionProvider;
if (! IsPostBack)
{
BindSection();
BindCompatibleSections();
}
}
else
{
ShowError("The module that is connected to the section doesn't support outgoing connections.");
}
}
}
private void Page_Load(object sender, System.EventArgs e)
{
if (Context.Request.QueryString["SectionId"] != null)
{
this.Title = "Add connection";
// Get section data
this._activeSection = (Section)base.CoreRepository.GetObjectById(typeof(Section),
Int32.Parse(Context.Request.QueryString["SectionId"]));
ModuleBase moduleInstance = base.ModuleLoader.GetModuleFromSection(this._activeSection);
if (moduleInstance is IActionProvider)
{
this._activeActionProvider = moduleInstance as IActionProvider;
if (! this.IsPostBack)
{
BindSection();
BindCompatibleSections();
}
}
else
{
ShowError("The module that is connected to the section doesn't support outgoing connections.");
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ActionDispatcher"/> class.
/// </summary>
/// <param name="provider">The provider.</param>
protected ActionDispatcher(IActionProvider provider)
{
provider.Target = this;
provider.Action = ObjectiveCRuntime.Selector("doAction:");
}
