In the Actions Console one can specify a NO_Match when a user's response does not match an existing parameter. But that NO_MATCH does not provide a transition to another scene. When the user input is not recognized, I want to return to the start of the conversation and start over. How can I do that?
It does seem odd that the only transition that NO_MATCH supports in the Actions Builder/SDK is to the (mandatory) End Conversation scene. But this is more a conceptual notion - NO_MATCH indicates that you want to attempt conversation recovery, or that you're giving up on it.
If you want to capture what is said and/or take action on it (ie - transition to a different scene) you can do something like this:
Create a Type that takes "Free form text" (I usually call it "Any"), by creating a type and selecting this for "What kind of values" will it support.
Create an Intent where all the sample phrases use this Any type - I've named it "fallback" in this example. You should specify that this is not a global Intent, since we only want it explicitly triggered in a Scene. Then create an intent parameter that uses the Any type and some sample phrases that use this parameter. Make sure you highlight some of the words in the phrases to show which parts are the "Any" type, since they won't automatically match.
Finally, in your scene, place this as the last Custom Intent. (Note that it must be the last Custom Intent, since they are evaluated in order.) You can then assign it to transition to whatever scene you want.
Related
In our implementation of the Rules Engine we have a test form similar to Rule Test Form on the online demo on "Business Rules Engine Demo". What we would like to do is conditionally show only the Test Fields for the items in use in the rule. We are doing this by grabbing the rule.definition JSON from the ruleeditor then look for the items which we can conditionally create using AngularJS's ng-if directive. This works great with Fields. If the user selects a method, our method of parsing the string is failing. What it appears is the Field Names are stored in the JSON as plain text however the Method Names are not. Is there a way we can configure the control to either A not encrypt the method names or is there a way that we can tap into the encryption to identify if a method is in use in our rule? Thanks in advance.
Methods and actions can have overloads which the Code Effects rule editor supports. Therefore, we can't have multiple menu entries with the same name. Instead, we use a signature hash on all in-rule methods and rule actions regardless of whether it has an overload or not to make them unique on the client.
You need to have either the Full Source or the Editor Source license in order to change the code to either stop that hashing, or tap into the process, or implement it your own way. You don't have that option with any other Code Effects perpetual license.
I'm building a class (sorry - Agent) that will work with a set of Tank objects (Fluid Library) - doing things like monitoring individual levels or total level of all tanks, reporting on levels and initiating actions based on levels - things of that nature. For argument's sake let's call it a "TankMonitor" agent.
Ideally I'd like to be able to define a Parameter in my "TankMonitor" agent that allows me to define the tanks of interest when I place a TankMonitor in main. I have tried to define the type of the parameter as Other - ArrayList<Tank> however I don't know how to set up the next step to allow me to populate the ArrayList of Tanks when I put an instance of this agent in main. My preference would be to have a list type control to populate the ArrayList - much like the way the AnyLogic Seize block allows you to specify multiple resource pools to choose from.
Has anyone attempted this before and been successful?
This is possible as follows:
Change the type to "Other" and then 'Tank[]' , i.e. an Array of Tanks
Change the control type to "one-dimensional array"
Example below. Now you have the same UI to pre-define tanks at design time for your agent instance.
In addition to Benjamin's perfect answer, I'd just add the manual workaround, which is not needed here but can be useful when the parameter in question has a more complicated structure than covered by the pre-made controls, say a list of lists, a map, or similar.
In such a case, the Control Type is still Text, and populating it in an instance happens by pointing it to a new object of the parameter's type. E.g. for an ArrayList<Tank> parameter, you might instantiate a new ArrayList object, which you fill with a list of objects like so:
new ArrayList<Tank>(Arrays.asList(tankA, tankB))
In the Java code, whatever is written into that text box will end up on the right side of a parameter assignment statement in the embedded Agent instance's auto-generated parameter setup function. Therefore, multi-statement code won't work in this spot. Instead, if the process of building the parameter value doesn't fit neatly into a single expression, you can hide the code in a function which returns the desired object, and call that from the parameter's text box.
I have an intent in DialogFlow that accepts an input/parameter from the user for validation purposes. The parameter is of fixed length and is alphanumberic (e.g. ABC1234). It is a random ID different for different users. The data input is validated at the backend using a webhook call.
In order for the input value to be accepted, I have to set the type of the parameter as #sys.any. It does work and the value is passed through to webhook for validation. But since this intent has no "Input contexts", the next intents are never triggered because each input from the user is evaluated to#sys.any.
What I need is a type that accepts custom value. But I can't find any.
Here is screenshot for the intent:
Also note that the next intent that doesn't get triggered has the "In context" = authentication
And user says expressions like book me. Due to #sys.any in the intent above, book me causes the above intent to trigger.
This question has similar requirements but no answers: DialogFlow - Improve entity/parameter recognition for alphanumeric parameters
Also: https://discuss.api.ai/t/alphanumeric-support/2572
So after some digging, I had to change the approach. That is, #sys.any is not the way to go. Instead of alpha-numeric, I opted to use the numeric part of the input param (last four digits) and handled any duplication at the server end/webhook. The type I used instead is #sys.number-sequence.
I still had to handle the contexts in a way that any input of number-sequence doesn't trigger this intent.
This is not possible on Dialogflow. You can achieve that in your webhook with a regular expression for example.
I would like to build an app with a oral code verification.
i could just set my cde in dialogflow before then, juste verify it.
GH : "For continue, give me the code"
Me : " 1 2 3 4"
GH " Access granted" / "Access denied"
But how can do an input a get this code on dialogflow?
First of all - consider if you really want to do this. Having someone say a passcode out loud isn't really very secure and adds very little additional security in a multi-user environment.
There are two stages to this - the first is setting up an Intent to handle this, specifically in the format you want, and the second would be handling and verifying this is the correct code.
Setting up the Intent
We'll need two intents - one that prompts and sets a context so we know we're expecting the validation code, and one that checks for the code.
The prompting intent might look something like this:
The notable part here is that it is setting an output context. We'll see why that matters in a moment.
The one to handle numeric input might look like this:
There is a lot more to this one. First note that we're requiring an input context that matches the output context from the last Intent. This means that this Intent should only match if that Context has been set. This lets us talk about numbers elsewhere in our conversation without triggering this validation.
Next we're looking for sequences of numbers that match the #sys.number-sequence built-in Entity type. There are other entity types that may be useful for you - see the documentation for details and pick one that makes sense or experiment to find what works best in your case.
Finally, we're going to use a webhook for fulfillment to verify if the code is correct. Which is the next session...
Verifying the code
While there are ways to do the verification without a webhook, this is really the most straightforward way to do it. If you're using Google's library to handle input from Dialogflow, you can get the value with something like
var code = app.getArgument('number-sequence');
using whatever the parameter name is. If you're not using the library, you can find this in the JSON at result.parameters.number-sequence.
You would then verify this code, however you want, and return a message indicating if it is correct or not.
If you want to use a sequence of numbers as your code you can use the #sys.number-sequence entity to recognize it and then check the code in your webhook.
Another way would be to simply make a custom entity 'code' that has an entry of '1234'.
I'm just picking up om.next and have run into a situation where I've got some form inputs realized as components which hold on to local state, e.g. validation state, actual input value, etc--this state is updated and accessed via om.next/update-state! and om.next/get-state. The trouble with this seems to be when I wrap the inputs in a form in a parent component I'm unsure how to get the state held by the input components. Is it better to pass along the parent component as a property of the input component? What about situations where there is no parent component?
It seems to me that there are 2 options for the use case you want to achieve:
pass the parent component as an argument as you said
have an entry in the global app-state that represents the current form being edited, which you can update via transact! irregardless of the component corresponding to the input. This way every component that represents an input knows where in the app-state to update itself (which key in the current form) — probably captured succintly in one mutation function.
1) is probably the easiest to implement given the code you have currently, but I always like to go for 2) because it doesn't deviate from the "single source of truth" opinion that Om Next recommends (and tries to enforce). Form data is in fact business data, which might not be desirable to have scattered in components. Testability is just one advantage that I immediately see from such approach.