Elsa Workflows Community, 12 Mar 2023

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: Elsa Workflows Community Meeting 27

Description

Elsa Community Meeting 27

Updates

- Revised store API

- Flow HTTP Request

- Improved JSON handling for HTTP workflows

- Improved parent/child workflows

- Added ability to upgrade composite activities

- Improved workflow instance journal

- Fixed checkbox issue

- HTTP RouteTable fixed

A

Hey man how's it going.

B

Yeah good find it in yeah.

A

Same took a minute yeah all right, so let me start sharing the screen and then maybe we can do some updates. So I've been quite busy with Elsa three past week, which was really good. There was this team from a customer that that are going to adopt Elsa 3, but wanted to tackle some of the issues with some issues with the designer some missing functionalities. So we were able to to do a lot.

A

That was pretty awesome, so I thought maybe it's nice to go over some of these items, so I created little list of updates. I can talk you through it. Of course. If you have any topics or questions, we can add them to the agenda as well. So what do you guys think on that? I will start from the top all the way to the bottom, the store API?

A

That's actually something I wanted to talk about last week, but didn't have the time so I'll do it now, for that we will open, try to open the back end. So basically, what this is about is just the refactoring uh in the distance apis of LSAT.

A

As you know, we're using abstractions so at the very core there are interfaces like I work for definition, store, I work, for instance, store execution, log stores, this one that's selected and that basically simplified the API, where you only have methods like save and find and find many as opposed to having specialized functions like find many by definition, ID or find many by correlation, ID and definition ID.

A

So there were all sorts of not arbitrary, but it seemed arbitrary because I would add functions based on a given use case, so it made the interface a little bit clunky in my eyes, so I simplified it by employing a a model, that's similar to the specification pattern, but not the way it was done in Elsa to where it was too open-ended and too too flexible, which made it really hard for implementers to. You know to realize what are the various permutations?

A

What are the actual specifications out there to implement so that made it very tricky to to to implement custom persistence stores? So here I took sort of a middle ground, I guess where, for example, taking the workflow instance store? That's not this one. Well, the work. This is not a good example. Let me let me open a different one.

A

So, let's take a look at the workflow instance store in the management module, so it has just basically one two well three four sets of of methods, and let's take a look at to find this thing guys you, as you can see the what they all have in common. Are they just accept a filter which is basically your specification and actually, let's take a look at the filter, the work lenses filter. The specification is well.

A

This filter is used as a bunch of fields that, if they are set, they will be included in the query and if not, they will not be considered. So, for example, if you wanted to get all workflow instances of a given status, you would just set the workflow status or maybe you're interested in a single workflow instance. Then you just set the ID, or maybe you want multiple. Then you set a collection of IDs.

A

This one also supports a search term, so it's very tailored towards this given persistent store, but the API is very clean, so the caller would just instantiate a word for definition. Filter fill out the fields that they want to fill to buy, and that's it it's a little bit inspired also on the API, where you also can construct, which is more advanced of, of course, more Dynamic this one. But the usage is nice, where you just have an object that you configure and then fire away.

A

The the request here are the the variants for getting single items and multiple items multiple matches, and there are some overloads. For example, if you wanted to order by a given property on the workflow definition, then you would use this overload where you get to specify the order. So the same refactoring has been applied to all of the other stores, so including the workflow definition store. Workflow instance store. We, we saw the other one here somewhere in the right time.

A

There you go so we have bookmark, store, trigger, store and the word for execution, lock, store and the workflow state store, and some of them are simpler. They they don't need all of the other methods yet, but um we might add it, but the idea is to keep it a little bit consistent, a.

C

Quick uh quick question: what is the advantage of creating a specific class filter regarding, for example, directly passing an expression, some equation like it? It does in the Azure table, SDK or Azure blob SDK, for example,.

A

Yeah good question, so we could do it, but then it depends on the underlying persistence mechanisms in API if it can actually translate that expression into something meaningful for the online resistance store and for Entity framework word would work out, maybe also for the scene. I I don't know, but maybe that will work out too, probably also for mongodb or most certainly it should work out for that.

A

But what, if you have a very, very special, specific or specialized persistent store, maybe in the form of a web API that you implemented, and you want to use your API to read and write data in that case, it would be probably very hard to translate these Expressions to API calls or parameters you want to send to your API. So that's the that's pretty much the only reason so as not to rely on Expressions being able to to be translated.

A

If, if we let go of that requirement, then then we could expose it and that would would simplify it from this point of view from the implementation point of view or the API point of view, but it it limits that scenario and I know at least one user who has who uses this in their application. Okay,.

C

So the ID is just to to be able to read the field specific class and get some information to be able to rewrite some specific implementation. Regarding the provider we use that's right. Yes,.

A

Correct yeah and actually I can show the difference between an EF core implementation and a leucine or elasticsearch implementation. So let's take a look at the.

C

Electric search is used for the the login only of all the the all the store.

A

uh There's only an implementation for workflow instance store and workflow execution like this store, but it could also be used for other stores if, if we wanted to but I I, don't think at this point at least that it doesn't make that doesn't add much value yeah, but maybe maybe that will change in the future contracts.

A

So here we have the workflow execution lock store, and if we look at its implementations, we have EF core elastics elastic, workflow, store and memory implementation, so the EF core memory they're very similar, because, let's see here, we have find then here it calls a method called filter which is private here and basically what it does. It takes the the filter and calls on apply on the filter, which is just a method on the filter itself. It translates the well. It applies its properties onto the queryable that spacing receives here using simple logic.

A

So, if some field is not now, then it will update the queryable by some appropriate condition. But that's the pattern here and to get back to your point. If we were to allow just Expressions directly, then we wouldn't even need this separate object, but let's look at the other implementation elastic. It has a similar throats here. It also has a filter, but then, of course the how the filter is applied here is is different. So, yes, here it's of course, you're familiar of course with the elasticsearch SDK. So here it uses maths Fields.

A

If there were a translation between expressions and elasticsearchs that queries, then that would simplify things, but at the same time it's I think this is a good proof concept that it doesn't matter what the actual underlying persistence is at this API service level, you just provide your filter object and the implementation takes care of creating the correct query. Okay,.

C

I understand thanks.

A

All right um so the there's a new activity called flow, HTTP request, which is like the HP request activity and just to remind you what that looks like. Let me start the designer and the back ends all right. So let's say we have HP request this one was there before we have a new one. Let me let me explain the reason for this one. So first we add HP request. Let's say we want to make a request to get a single user from our backends, for example this URL, and then that's it.

A

Of course we want to capture the output, so we can get the HP response stored in a variable so that we could test what the status code is. Maybe if it's 200 we want to go left and if it's 400, we want to do something else. So that would look like this. We would create a HP response variable and then this the response being stored in this variable. We could now add a if or maybe a row decision- and here we could say return is get HP response, dot status codes.

A

Let's say if it's 200, then we would return true, but otherwise we return false. So we could just do it like this. If it's 100, it's true, otherwise, it's of course we could also go with a flow switch and then we can handle multiple status codes if we wanted to, but just let's imagine this is what we want to do so. This works. This is fine, but we can do it better using the low ASP requests, which inherits from eight speed requests or actually both these activities.

A

They share a common base class, but this one allows you to provide expected status codes and if you were paying attention, you notice the same field here, but it's not fully implemented yet on this activity. But let's stick with this one for now the way this works is here we can like in LSAT 2.

A

We can provide the expected status codes that we want to handle so, let's say 200 and 400 and as you can see on the outputs immediately, we get the expected status codes available as outcomes so that we can get rid of the decision here for the switch whatever we wanted to use. So this is like a built-in switch, so that's new, which makes it a little bit easier to model your blog. So that's awesome.

B

So what is the reason to have it as a separate activity rather than implementing this? In the current HTTP request?.

A

Good question so, and that also takes me back to the reason we see it here, but when I mentioned it's not implemented it's. The difference is similar to when we have the flow decision here, where we have the true and false outcomes as ports as the as as these ports here, but we also have, if so, if and flow. This is in there functionally the same, but in terms of modeling they're different. So this one here also allows you to set a condition. It could be the same condition here.

A

Let's say it's like this and here what we can do is do something if this is true and if something is false and then continue on with the rest of the Vlog. So we could maybe just continue with this one here, and that is not possible with this flow decision here you have either true and false, and that's it so it's it's this direction or this direction in here you have some embedded logic. You can Implement and then continue on with the main flow. Similarly, with the HP request activity, you can do that as well.

A

So here you could have expected status codes like 200 400s, so now there's an error why? This is why you are seeing this issue here, but let's pretend there's no issue. What would happen is you would see similar to HC with? If you see you would see 200 and 400, so you can then execute some subflow in response to some status code and then continue on with the with the main flow. So this this flowchart model here that we are using it's like a hybrid between flowcharts and sequential workflows, okay,.

B

So the original HTTP activity will act more like an if, if you define status, codes and flow HTTP request will be like a normal HTTP request, followed by affiliation.

A

Yeah, so exactly this is this is designed for you using flowchart diagrams, but you can imagine if we have a sequential diagram editor similar to what we have in Windows workflow Foundation. You would probably use the this one here. That's Now hidden from view because the in those diagrams the ports here they don't make sense and these ports here they are used as connection points. So you can create connections between these ports and that makes sense in a flow chart, but it doesn't make sense in a sequential diagram. Do.

C

We have any information on this behavior on the activity. Is there any place where we have some documentation for an activity? The implementation, a documentation, not the description of what we why the developer use this activity in this in this workflow.

A

So referring to just a documentation, proactivity that.

C

A

When to use it wise, yeah.

C

A

I'm thinking, maybe we can add it in this documentation here, where we add a section called activities or activity Library here categorized, so we can list all of The, Primitives ones, the flow ones or or depending on how we want to categorize. There would be an HTTP category and that would then display at least those two activities with a description and use cases. Etc.

C

Do you think it could be useful to to to uh because this information will be sourced on the activity, class or activity development to be able to generate a documentation directly, and do you think it could be interesting to have this kind of information directly when we create the buffer yeah?

C

Anything like that, so.

A

C

They are like a tooltip.

A

Or like a tooltip yeah exactly so here we see descriptions right, there's just a visual glitch where it doesn't overflow here, but so these give you a brief description, but I I also like the idea of integrated documentation, especially with a tool like this, where maybe or maybe some some hyperlink or some button, that you can click that takes you to the documentation and this documentation, of course, is written manually.

A

But it would also be good to have XML or generated documentation based on XML, so that you have more details on on the specifics, and this is more like a like a guide yeah. But it's a it's a good point, because it's important as a newcomer and you see these variants it's. It can be very confusing when to use what without proper guidance and documentation, yeah and of course, some users may have a preference.

A

Maybe the maturity fuses will just be dealing with sequential or not sequential, but floater diagrams when using the designer- and they may not ever want to even see the sequential ones and always use these these things and that will be configurable from the application first and in the future. That would be configuration driven and then you can also assign it to potentially to user permissions and roles. But those are roadmap items all right. So that's uh that's. The thing flow HP request, improved Json handling for HTTP workflows.

A

So as we found when doing typical scenarios, for example, where you expose an HP endpoint on your workflow, receive some Json payloads, and maybe you just want to you access some fields on it or Echo back the the Json object to the response that didn't work very fluidly, but that's a lot of improvement has to be made there. So just to show you is a simple example: let's say we have an HTTP endpoint here and we make yeah. Let's say we just want to Echo back what we received.

A

So here we do demo post and let's say we- we submit this payload via post map, so this will be the structure that we post. So we have to remember that it starts with the.

C

A

It has a support field and data represents a user. It seems so there's a couple of things or more than a couple of things we can capture from the inbound request. The raw HP requests can be captured here using the result of type HTTP request, which is an actual C sharp object. Although yeah I think this is actually a non-serializable, the request that you get from.net, but let me let me double check to make sure I'm not saying anything.

A

That's not true here right, so this HP request lives in the Microsoft ASP networks to be namespace and important. Here is that this is non-sterilizable. So when you are going to capture this one through a variable, it's important to set the storage to memory, because otherwise the system is going to try and serialize it, and that might will likely fail in this case on this topic.

A

Thinking of making this a little bit more intelligent where you, it already knows, based on the type, whether it's realizable or not, and usually using the correct storage automatically or at least a supported store like memory. Of course, you still want to have control. Maybe you have a blob Source provider and others, so you can always override it, but maybe by default this will be unselected and that's default to workflow and then this intelligence intelligent decision making could kick it.

A

But for now, just this little heads up this little Buck, we still need to fix where it doesn't rebind when we change the variables, but it's on the list and to work around that just click away and then Focus again and then it should be there like so, but for this demo, I just will take the parse content directly. So this HP endpoint will also parse the inbound request body into the target type of whatever variable you have selected. So if you have a variable of type string, it will not do any parsing.

A

It will read the request body and store it as a string, but if you specify iterate.net type or an expand the object or just object, it will try and parse the string content into a Json object or in the case of a.net type. It will deserialize it into that attack. So here, since we don't have any.net type, we'll just use an expanded object, we could also choose to go with object and internally by default it will deserialize into an expanded object.

A

You could also choose to use a Json object, which is it which lives in the system text Json namespace. If you wanted to use that API to then Traverse, your Json object. So it's up to you, but this one is usually the most convenient because then you can use that notation to access fields on your incoming Json payload. So let's call this user payload and then we just want to write it back. Just the whole object, so we should be able to say get user payload.

A

We don't have to set a content type if we uh we can, but if we don't, it will default to application Json. If the content is complex object and if it's a string, then it will default to plain text and of course you can explicitly control the content type that you want to use. If the content type you want to use doesn't exist in this list, you can always switch to JavaScript or liquid and just enter the content type you want and, of course, we'll make this configurable at some point yeah.

A

If you want to provide some response, headers that works too, all you need to do is just return. A JavaScript object where the field names are the keys and the values are the values so, for example like this, and this will be parsed into a dictionary and maybe copied into the response stream. Okay. So this uh let's try this one out. If we send this one Base address, workflows, demo, of course, I. Don't I should not forget to set this one.

A

As can start workflow checking this box on a activity that supports triggers will create a triggering system so that you can actually invoke this one. So, as you can see, we send this data and we received it back, as is we could also choose to just return this field, so that would look like like this. So so we could say the Theta, because this is an expanded object with Dynamic access to its Fields, publish this and then try it again.

A

We just get that section, and this works for individual Fields as well, of course, and even constructing custom LTX that that works as well. So you could just say user like this, so this makes it very easy and convenient to quickly Implement API endpoints, using Wordpress, if you wanted to another common use case, is to actually make a call to some backend system. Let's imagine this thing. This API is our backend, so in in response to the HP endpoint activity, we will send an ATP request like this, and then the method is get content.

A

Type will be selected automatically, based on the response, content type and the outputs. We already created a variable called user payload which well it's a dynamic object, so we can use it here. We'll ignore this payload here we can actually just unset it we're not going to do anything here. Keep this as that's fine, but here when we send the HP request to this back end, this Mac API. We want to store it in the user payload here.

A

Here too, we can capture the HTTP response if we wanted to which allows you to access more objects that that are part of the HP response object, such as cookies and headers, but here we're just interested in the in the response body and because we we use the same model when we were just doing the demo a minute ago. The model will be the same, so we don't need to change this code here this. This will just work because it has a data fields.

A

Okay, so now, when we submit this again, nothing seems to have changed, but of course we know that. Actually let me not send anything here and do it again. You see it. This content came from this ASP request and then we echoed it back well, more or less, because we are modifying the result model here, a little bit all right. So we also improved community education, the composition between parents and child workflows. What I will show is the ability to create composite activities using the designer by creating workflow definitions.

A

So what we can do is create a workflow definition, design a reusable bit of logic, mark it as reusable or as an activity, and then we can use that so I already did the demo one during one of during one of the last meetings, but it's been improved a little bit more. There's now also the ability to configure the out possible outcomes. So, let's take a look. Let's say we create a simple sum operation.

A

It's the same demo I gave last time, but I I, don't exactly recall if if we implemented input and output at that point, but this one is certainly new with these outcomes, which allows you to say positive or negative, for example, and then we'll just rename this to determine.

A

That's not the correct word in this context, but I by lack of a better way. Words we'll use it like this. This is the activity name. Of course we are creating a word for definition, but by setting useless activity to yes, it's a it will be useful as an activity, and then this name will be used for that activity type. You can say it provide some description. It turns positive if the value is greater than zero. Let's do it like this. So we'll add another outcome called neutral if it's zero, alright.

A

So these are the outcomes, but of course we need some input. We need some value, some number to determine whether it's positive value or negative value or a neutral value. So we'll add a value of type int and we'll call this or this is the this will be the display name as presented to the user. That's using this composite activity, so we'll call this value. So here we have an inputs, we can provide an output, but in this case I will just demo the the outcomes.

A

Actually, let's do both so we'll also provide the some textual presentation of the positivity, so we'll say positivity of type string. Okay. So this is basically the the interface the the function signature, if you will, if you think of this workflow as a function, but now comes the implementation, and for that we will maybe use a JavaScript or actually, let's use it. Let's switch a switch, switch sounds perfect, all right, so we use this flow switch and then we have three cases and the first one is called positive and it's positive.

A

If the input the get value greater than zero negative, if gets value less than zero and neutral.

C

But the this is the same flow switch is like a switch but switch either. Don't don't that's right, okay, default and and proceed. Okay, like we have seen.

A

Here exactly yes, yeah, as you can see. Indeed, here these are embedded ports and these are external ports, yeah, okay, so so good! So now we have handled this input and we can return the positivity. But the question is now: how do we provide the output here and also, how do we communicate the outcome and for that we have I, think complete yeah, so using the complete activity, we can control the outcome of the current scope or the current workflow.

A

So here we'll say for positive: we'll return the positive outcome, so this list is fed from the outcomes here. So we'll connect these two and then the same goes for so let's there's a name, positive, negative and neutral okay, so that handles uh sending back the outcomes. And the question is: how do we provide the outputs and that's this one here set where workflow outputs and we can either basically repeat the logic here as to set the value.

A

So here we can set the output to positive, so that's directly bound to here, and the value could be basically a copy of what we implemented here, which is the easiest in this example I think. But of course you could also add a set workflow output in each Brands and do it this way, but to keep the flow well I want to say to keep the flow simple.

A

That's actually not going to be simple, because what do I connect to here it would work if we we're using the switch here with the cases setting completing the workflows and then setting the workflow outputs. But now that I see this, it's gonna be easier to just. Do it like this.

C

There is no other importance in uh settings or output and then complete the workload we can complete before settings. Workflow output.

A

That's a good question: let me check the implementation, because I know the finished one will cancel out every subsequent Point scheduled activity, so that would not work but I wonder if we're complete, if it.

B

Does something you can't reset the output before the switch Yes.

A

Actually, that's clever yeah, of course we set first, the output them to the switch on the output. Here we could, it doesn't provide some output, but uh but you're right of course, yes, and we could even store the the actual positivity in a variable. Then we use that variable to set the output and also switch on the variable here if we needed to yeah because well, actually, then we don't even need this flow switch because then we can just switch to JavaScript and return the outcome here. That's that's the easiest one.

A

So, let's I like that, let's keep it simple. So let's create a variable called and.

C

Could we do this with only one activity with only JavaScript? Yes,.

A

Yes, that's even simpler: you can just do JavaScript, actually I think we would be missing. We can set the output, that's okay, but so the dentist JavaScript have to return the output, but then there's no way to set the outcome, so we would either need another JavaScript and then a function to set it and I've seen in, for example, Orchards there they have also JavaScript activity, and it has a function called set outcome, I believe and then then you can also specify the list of possible outcomes and then they they appear as ports here.

A

So that's that's. Another could be a either a separate activity or an enhancement to run JavaScript but yeah, but that works too in part. But for now, let's do it like this. The positivity and notice that I'm not using positivity as which is which would conflict with the output name here, potentially I I haven't tested it. So I don't want to accidentally cause some weird Behavior I do need to test this before before long, but for now it is to be safe. I will just call it the positivity and it will be a string.

A

Of course object will work because an object can be anything, but in this case it I like to be specific, so we have a variable to positivity. Then we need to set that value using that variable. Okay, so here we have a string, the positivity, that's this one, then we will connect it to setting the output positivity and the output will be. It gets the positivity like, so that we that handles setting this- and finally, we just need one set outcome outcome would be a JavaScript expression.

A

Yeah take positive things just as this one, all right, so good thinking, uh Mohammed. That was uh that's much much easier, all right. So now that we published this one, we have a new category called workflows which contains this activity here, so we can use this now as an activity. So if we go back to the workflow here, we can add it here. So here we see the outcomes positive, negative neutral. Here we can provide a value, so we could say: let's try, let's try, actually, let's, um let's make it pyramid the rise rule.

A

So let's say we start this workflow from an HTTP endpoint and we'll create a new variable called The Arc. So that's what this will be, the contain a um it. Let's say it's a dynamic object and it will contain the value as a as a field on the Json and we'll capture it here as the arc.

A

Then here we'll use that as an input, so we'll say for the value you will use a JavaScript expression codes get the arc which will be an object containing a field called value, but here we'll be sending Json value, we'll call this 43, okay and then the outputs. We will capture using this, and this is a string.

C

A

We'll also, we can also connect some logic here, so we could maybe Echo back to the to the HTTP client. We can say positive, negative and neutral alright. So, let's see if this works not found. Oh yeah, let's make this a post, so we received an okay. We didn't get any content back. So that's an issue. Let's see if we can look at the workflow instance here so here we have the journal, so we have the HP endpoint here post. This is not right. This should be the evaluated value.

A

So let me double check something JavaScript. Okay, it looks like I broke something in the process and this this is not being evaluated. So so that's unfortunate for this demo, but you can see the the way it's going to work so having the main point being being able to create composite activities easily using the designer without having to do it in C sharp. Of course you can still do that, but this is. This, provides a a faster way and also more clear in case you do have some more complicated logic.

A

It's easier to look at it visually than potentially in C sharp and the ability to connect these these outcomes, but let's see if, if it at least Works without JavaScript, so let's imagine that we received it like this. Well, that's uh I should have I should have tested this before the demo. This is this. Is too bad? Let me let me quickly check the back ends here and just to double check. We set the variable to get value, set the outputs and we get a positivity that we complete here.

A

Well, there could be a bug anywhere. Maybe if this one doesn't actually return the value, then.

B

Is it it's instant step for the outcomes.

A

Maybe it could be neutral negative, so the casing is is correct so that shouldn't.

C

A

Oh, that's, okay, I will I, will double uh check this after the call and make sure it works the next time I demo, this one yeah. So let's see what's next, so this one is covered. This one is covered, although we found some issues ability to upgrade composite activities. So that's related to this one here. So now we have two uh two versions. This one is published. This was version one yeah, and here we have version two. So let's, let's imagine we we make a change where we say we accept yet another inputs parameter.

A

Let's call it input, 2 of type object doesn't matter, but the point is the signature has changed. We published this one. Oh I was wondering why I didn't publish and that's because it requires you for now, at least as a safety guard to be on the on the draft, because you can't publish anything, but the latest version.

A

Of course I will probably change it to when you click publish it will just take the the current latest one, but this was a quick fix to make sure it didn't break anything if you were looking at an older version. So, switching back to the latest version here, then publishing will work and again so the signature has changed here or wait. Where did my inputs? Go I, don't know what happened there.

A

Let me try this one again so input to publish here it's just one, and here we have two okay, so we are now at version three. But if we go back to our workflow here, this is the composite activity.

A

If we look at version, its current version is what, but we have a new version published uh and the reason it doesn't do this automatically is because if you change the implementation or the signature or both or either of a composite activity, then you could potentially break other workflows out there that are in production, they're running so you want to you, don't want to risk that.

A

So for that reason, when, as soon as you drag and drop, it comes the activity onto the canvas, it will take that version and it will be pinned to that version. So if you want to take advantage of the changes of the newest version, so here we just see one input.

A

But now, if we upgrade, we are now at the latest version and then we can take advantage of the update here, probably we'll add some tooling, so that you can do it in bulk, on maybe whole workflow definitions or maybe a selection of workflow definitions where you want to apply or upgrade the composite activities, but we'll have to think more about for now. It's it's this manual operation, which is a little bit of work, but but it's the it's. It's the safest option for now.

C

I think it could be a good idea to to be able to upgrade and choose a specific version in case of bug detection. We need to hold back to the previous version. Yeah.

A

That's a good good suggestion uh right now. You would do it by going to the composite definition here, let's say- and you say let's say this: one has a bug and this one is okay, so you can say revert it will create a new version, but based on this one, so this this is a copy of this one. You can publish this and then revert to the the latest version here, but I I agree. It would be good to just be able to select the version you want to use.

A

So maybe we'll change this UI with a drop down of the current version. So here it automatically update to the published version that maybe this should be a drop down and then you can select. So that's uh yeah. That's definitely a good suggestion. Yeah.

B

And what happens if a version is deleted.

A

I was afraid he was gonna, ask and because I don't have.

B

A

Good answer, but let's say we delete version four right, so we're just gonna, try it so I'm gonna go here. I'm gonna revert the revert, so we we can't delete it now, because it's the published version, but I'll just do this one, and now we should be able to delete this one and since it didn't disappear, I suspect something in the back end. Didn't go well, nothing wrong here. What about the console? Oh yeah, so um we got issues here. So this is.

A

This is something we need to improve in Safeguard, but for now you're more or less protected. By doing something like that and you're you just you just get an error, but the question is what should happen if we delete a version that is used to be maybe prevent it prevent the user from doing so by checking to see if there's any usages, probably.

B

C

B

Small town, Creator I, don't know it.

A

B

It depends which version you are deleting also.

A

So because I can imagine that if you delete a version, but then usages are being downgraded that will affect all of the workflow definitions using it. Yeah.

C

I I think at least we we must show the usage. We must be able to show the usage, and then we can think about how we can uh work on it because I think it's very difficult, because if we decide to change all the workflow, we need to republish all the workflow Etc. It could be a breaking something it could be, create some issue and a done done time in the in This Server. So it's a it's a real question. Yeah.

A

So so you're saying it should show the usages and then and then the user can manually, update these workflow definitions or at least be aware of what they're about to do. And then they have to manually here.

C

Yes, what's the first steps? Yes, it let us time to to to think about the the good choice We can give to the to the end user. Yeah makes sense.

A

So yeah, so that's a thing. We definitely need to improve here, but for now, as you can see that doesn't even work, I wonder if you can delete any version in the first place, nope latest version Oh find filter, H2 polished, okay, so this this error seems to be uh unrelated to using these things, but uh put some bug that cut in introduced. Well, thank you for the question Mohammed and uh and showing.

B

A

Part is, it still needs some work. Okay, yeah.

B

This is a fan of customer Behavior, but yeah. Let me ask these questions. Yeah yeah,.

A

It sounds like you've, uh you've you've gone through things, yeah.

B

A

Right, but that's good so we'll fix that, so that's the ability to upgrade composite activities improve workflow instance Journal. We already took a quick look at that. If we go to workflow instances, let me resume this first, so here we should be able to look at the yeah. So let me refresh.

C

A

Wow looks like this entire instance is broken now it's happening.

C

A

So that stems from from the bug that now seems to have corrupted some state, so what I will do is open the database and do some cleanup all right refresh all right. So let me show this following. So let's say we have two right lines: publish this one, take a note of definition. Id now, I'm gonna run this workflow using the execute endpoint so that this works executed and now we're going to look at the workflow instance. So here we have one instance.

A

This is the journal, so it shows the activities that they executed and what's different. Now in this version, is that originally it would just show the expression actually now. This is a poor demo, because it doesn't show you the difference. Let me fix that real quick. Let's imagine this was not a literal, but let's say it's a JavaScript that says return hello.

A

Let me execute this one again, all right. So, as you can see, it doesn't display the string extra, the JavaScript expression return, hello, but the evaluated result that's different here. So that's a that's! A good Improvement.

C

A

Also, if you may have noticed in one of the previous demos, even when using composite activities, even though you don't see the activities on the designer yet we'll add that capability later, you will be able to look at the executed activities of those composite activities and inspect their values here and what's nice as compared to elsa2. This does not only show you the the latest state of the activity, but you can click on the journal items here and and inspect the state of the activity at that time.

A

So if we were doing this, for example, in a loop, we should be able to see the state of the activity on a given iteration and now I haven't tried that but sounds like something fun to do so and easy as well. So let's say we have a looping construct, so we're gonna just delete this. One here delete this one for now, and then we say or one two three.

A

So this is a like a C sharp four uh loop from one to three we're gonna capture, the current value in a variable like that and then for each iteration, we'll write, something so we'll say right line. My property panel doesn't want to update okay, so I, don't know what at least was about. But here we have the right line and we're gonna write the current value, so we're going to say turn or we don't need to return necessarily we'll just say current step. Then we'll get the current value like this right.

A

We executed the workflow. This is the output. Now we'll take a look at the workflow instance. So here we see the the four uh okay so looks like there's an issue you here with the I, don't know where this comes from, but the idea was for each iteration to see well, basically see three right lines and then be able to click on those right lines and see it appear here. But unfortunately it's not allowing me to do so so for now I didn't actually know you were able to drill into it.

A

So this is a little surprise here, but it shows the latest step here, but you will be able once I fix this issue, be able to click on the individual iteration, and then you will see current set 2 and current step, one depending on which one you selected so not quite done yet, but step in the right direction.

A

um Yeah. Finally, there was some small issue fix with the checkbox doesn't seem very important in light of these issues that I just encountered, but just to show you what I was about is, if you use the HTTP endpoint it has this checkbox here. If you were to not do anything but just publish, it would suddenly be checked, so that's fixed and then finally, there was an issue with the 8 HP route table which is used for routed parameters.

A

So let's say you have an HP endpoint and you want a path like, let's say users, and then some user ID right like in an API controller. You can provide a route parameter in the routes. So here we can do that as well that that that works. But there was an issue. If you stop the application and start it again, the routes would the route table would not be re-initialized based on the triggers of of a workflow. So that's me fixed. It also means we.

A

We should be able to read this ID by capturing the route data. So that's an object dictionary and then this will contain a one entry with a key of ID which is retrieved from this route. It will contain the value of this route, so let's say number two and then we should be able to make a request here.

A

So that sounds like another fun thing to do, but we can say: URL actually switch this one to JavaScript, then we'll do it like this, so we'll say, get about params and now I'm, not sure if I am able to use that syntax I, don't think so, since this is a dictionary and it's not an expanded object, so I'm gonna guess it's gonna be like this ID all right. Let's see if this works, so the route was users ID ide2. We now exists so workflows. Users to ah this is a get.

A

So, let's change this to that and that worked, so we were able to capture this route parameter use it in a request to the back end or request and request regress re-exist soon. So we can try. Let's what do we get with three? This is a different user all right, so that was the the final one that I wanted to show, but as it's clear, it's not yet ready for prime time there's still some uh some some some small, some bigger issues to to correct.

B

So what do you guys think yeah to school? I have one question by looking at this demo, so suppose I have a workflow that needs to connect to certain API and collect the data periodically, and for this API I need to have an access token, so I need to log in get an access token and then use it in the workflow. And this token maybe will expire after several hours. But I don't want to request a new token. Every time I skew the workflow.

B

So is there a way to Cache the token and then reuse it until it expires.

C

I think we need to to add some activities to Cache to cache data, get cash insert data into cash and and this activity could also allow the user to choose what implementation you want to use. If you want to use some release or some other cache system, so.

A

That would be similar to using a set variable, so the variable is like a cash but either stored as part of of the workflow or maybe a redis storage, or, as you said, as you suggest, maybe there should be a a cast activity that could make sense. It could make sense to to store stuff in the cache and then you can request this access.

A

Token store it in Cache use it, but but you would have to do some logic right to check if to see if the gas value is still there or maybe even handle the 401 response from your initial HP or your yeah, your HP request. You could, for example, use this this this thing here to make your API call and initially it. If there's no token, it will respond with a 401, so it would say you basically would expect to go out to 0 and 401.

A

So what you could do in the 401 Brands, you would say authenticate. Let's say: let's say this is authenticate, and then you can just try again so because here authenticate will in the output, you will capture the response here: HP response which will carry the access token or maybe, as part of a Json object. You would set it to some some cash value, maybe or a variable. Let's keep it simple for now and use a variable access token. So this would be like. Let's use use data.

A

Let's imagine this is just the entire payload and it has a field goal to access data access. Token, sorry and then here we have set variable where you say: access token equals that use the data dot access. Token, for example. So here.

C

A

Store access token and then there we can try the request again. We can go back here and this time. Ideally this, of course, will include your access token in the settings here in the authorization we had access. Token like so and and what's nice here is because of this automatic Loop. You don't have to do anything else. You can now just to continue on to whatever else you need to do. Yeah.

C

Yeah and if we have some some cache mechanism, we can just encapsulate this into a composite to our flow, get the access token. If it's a, if it is found, we check the the time Etc and if it's not found or if it is that time is incorrect, we can get a new access token and add it into the cache.

A

That's a very good point: you can that's a that's a beautiful use case for composite activities created in designer in implementing that logic, and then you can reuse it as a high level component in your overall workflow yeah. That's beautiful, yeah yeah.

B

It sounds good great.

A

Then that's all I have I'll be working on those issues. We get closer to potential release candidates material every every day. Now so realistically, hopefully a month from now, we can do a release candidate with uh with with a stable version, good yeah yeah, pretty excited about that all right, then. Thank you guys for attending and I'll see you next next time. Yes, thank you. Bye.

C

B

Thank you very much.

B