Breaking into the Vault: iLogic Edition

TIFFANY HAYDEN: Hi, my name is Tiffany Hayden. And welcome to Breaking into the Vault iLogic Edition. In 2024, Autodesk created many enhancements to iLogic. They're listed right in the slide. Those-- in this class, we are going to actually talk more about how to expand it even further than what's listed.

For everybody watching and in the class that isn't familiar with iLogic, I'd just like to talk a few-- have a few points on what it is, what it's used for, why we even use it. One of the top ones is it's a code editor simple, very simple. It's based off of vb.net code. Many people use model and drawing automation. This actually accesses the API. So you can have access to certain calls for model and drawing automation and other automation.

Actually accessing iProperty and parameter functionality inside of parts and assemblies is a huge part of iLogic. That's primarily what, in my company, we use it for is driving iProperties and parameters to drive your components, assemblies, constraints, and so on. You can modify and add features to [INAUDIBLE] parts. You could create extrusions on the fly. You can create assembly extrusions, add participants to them, create patterns, drive the quantity of patterns, and where they're located in the assembly, and everything.

Parent/child relationships, you can add components into assembly through iLogic. You can remove them, edit them, many things, and so, so much more. That is just the very peak of the amount of-- the very tip of the amount of things that you can do with iLogic.

The question is, what if you want more? What if you're not on 2024? What if you are-- what if you're on 2024, but you see something that you want to expand further? And what if you have iLogic and you have Vaults and you want to connect them? What's the question there? The answer is the DLL. Simple, that is a dynamic link library.

The key to all of this is Visual Studio. Visual Studio, I've linked two QR codes in there for Visual Studio and Community and Professional. So it creates-- you could go directly to those for the downloads. One thing that we are going to do is we're going to create a project in Visual Studio. We're going to add references to it. The references are important. These are Autodesk references and Windows references.

And let's go ahead and demo in Visual Studio. Let's go ahead and get Visual Studio open. I'm currently using Visual Studio 2019. Later Visual Studios will work as well. So this is what-- when you open up Visual Studio, this is what you'll see. And what we're going to do is we're going to create a project.

And since I've done this many times, it's under my recent projects as a class library. If you don't have this available under your recent projects, just go ahead and type it in here. I'm gonna type class library. And you'll see that where you, the very first one that comes up is class library for dot NET framework. So we'll do that.

And we're going to name this one AU2023. And we're going to put it in this location. Just a simple location. You can put it anywhere that makes sense to you while you're following. The dot NET framework, it's very important to keep the dot NET framework, 4.8 is a pretty good dot NET framework to use with Autodesk products. You may receive errors if you use newer ones. So you just want to make sure that you look at the documentation for Autodesk products and what the latest version available for them to work with a certain dot NET framework. So it's going to create the project.

And this is what you will see as soon as you create a project there's a few things that we're going to do to make it accessible to Autodesk products. The first thing we need to do is we need to add the references available for both Vault and Inventor. So go to your Solutions Explorer and right click on References. And then go to Add References. And we're going to hit Browse. And we're going to go to this-- it didn't do a copy for me. Let's do it. Let's do that.

OK, so this is the first place we're going to go to, the Vault Client 2023. I'm using 2023. If you follow the handout, I will show the latest 2024 locations, 2023, and I will give you some tips on previous version locations that are helpful, all the way back to 2019. So just scroll down until you start seeing Autodesk. So you'll start seeing Autodesk DLLs pop up.

We're going to first do the extensibility framework, web services, connectivity-- or web services, extensibility, webservices.wscf. Then we're going to go to Client Framework, Client Framework Forms, Client Framework Vault, Forms, and DLL. And then scroll down a little bit further. And you're going to also add Autodesk Inventor.interop. And then hit Add.

Going to add them to your DLLs. You're going to add them to the references. But before we go ahead and hit OK, we're going to browse again and add Vault references. So we're going to go to a different location. And also, go down, start going down to the connectivity.common and then connectivity.inventoraddin. So you kind of got to scroll down a little bit further, inventor.addin.edmaddin. And then hit Add.

We have one more thing that we're going to add. So we're these are Windows references. So go to Assemblies. And then scroll down to where it starts saying system. You're going to look for System, Deployment, Drawing, and windows.form, windows.forms. OK, so we have all of our Autodesk DLLs. We have some Windows DLLs.

The next thing that we have to add is two files. These files control the connectivity of Vault within Inventor. So it talks to the Vault addin and grabs that connection, instead of us having to establish a separate connection outside of that Vault addin.

So to do that, you need to go up to where it says AU2023, and right click, and go to Add Existing Item. And then we're going to go to a different path. And scroll down. And you start seeing that there's no DLLs. There's a trick to that. You want to change this to read all files. And then when you scroll down, you'll start seeing more DLLs.

So start scrolling down until you start seeing ADSK. Let me see, where is it? OK, there it is. ADSK licensing SDK. And you also want to choose ADSSO services.dll. And we hit Add. The next thing, we're going to change the name of our class. And it's a simple rename to vaultlib.

The final thing that we're going to see with Visual Studio before we go back to the presentation is we need to change the platform. Me personally, I haven't had much luck with using the platform Any CPU. I have to change it to a 64-bit platform. This just makes error handling a little bit better. I have had zero issues since I started using that. So we'll go to the Configuration Manager.

And then when it says any CPU, you want to do new. And it's going to automatically default to the x64. Go ahead and hit OK. And then we're going to hit close. So it went ahead and changed our platform to 64-bit. I already have the code source for this class that I'm going to give to all of the people that are attending. I'm going to go ahead and paste that in. So we can talk about it when we start going through all of the different functions that this class has.

And since we pasted in all of the code, we can go ahead and build the solution. You can see that it's starting to build. And it was successful, which is great. We'll show you where the DLL is kind of located. So let me drag this up.

The DLL is located in the BIM directory under the 64-bit folder, and then debug, since we are still in debug mode. And you'll just grab this. And it just needs to be in a local directory. At my work, we actually have it on the network. And then every single time a user starts up Inventor, it copies it down to a local directory. So they always have the latest and greatest DLL. Doesn't matter if we've made changes, the next time they load up Inventor, they'll receive those changes.

All right, so going back to the presentation, GitHub is where the data sources are going to be located. I've put the QR code and the link to both the GitHub repo and the GitHub desktop. I highly recommend you download the GitHub desktop if you're going to be working with this repo. You can do-- it just allows you to do a lot of different things from the desktop app.

And the repo looks similar. Let's review the repo. The repo looks similar to this. This is actually the repo. You will be able to get all the code that I've written for this, and download it locally, and just start playing with it. All right.

So the code review, just to review, we're going to use Visual Studio, which I've already-- we've already went through. We're going to use iLogic and Vault Pro to show you exactly what is going on. The DLL is on my local machine. And these are the 13 subroutines and functions that we're going to go through. These, you can take back to your work and make changes to them, make them better, kind of explore all the options.

This is just a small area of things that you can do with this DLL and connecting iLogic to Vault. All right, let's go to the demo. And demo in Inventor. So I'm just going to load up just an empty assembly. OK, that's loading.

One thing I'll talk about too is the Vault files that we're going to be dealing with is in a local directory, in our working directory within Vault. I've just created a folder called AU2023. And in Vault, it has files associated with that. And those are the files that we're going to be using during this process.

So to compare, these are the 13 different external rules we're going to go through. And then we're going to be jumping back and forth between the external rules and Visual Studio to give you an idea about what's happening in the background of these external rules. The very first one, I'm actually going to show a video. We'll do the rest of them live.

So this video is going to talk about Vault connections. It's going to tell you whether you are connected to Vault through the Inventor addin or not. So you see before this video starts, you see there's no Vault connection. It's not logged in. And I kind of reorganized my external rules. But it works the same. I'll show you the external roles as soon as it gets done.

You see, it logged in. And now it's telling you that it's connected to true. All right, so the external rule for that one looks like this. So when I talked about downloading your DLL to a local directory, there's a purpose for that. You actually have to add that local directory as a reference in your external rule.

So when you do add reference up here with all your imports, that gives the iLogic access to that DLL. So when you create a new connection to the class, it allows you to access all of the subroutines and functions that are available inside of that class. So for this, what it's going to do is it's going to access the class inside the DLL. And then I created a Boolean for is connected. It's going to read the Vault_isconnected subroutine or function. And it's going to return back true or false, based off of what it finds.

So in this instance, it returned true or false based off the Vault connection. The next external rule that we're going to talk about is getting a file by a file name. There are many different ways for you to find files and get files. You can get them by properties. You can get them by path, local or Vault, this is just one way to get a file by a specific a file name.

So in this subroutine-- sorry, in this external rule, we have another string that's been declared. And that is a part that will be retrieved from Vault and placed locally. And this function actually returns the path of the file that it gets. And if it doesn't get a file, that string will return an empty string. So it tells you whether it was successful or not. So we'll go ahead and save and run.

Middle of the day connection. Oh, come on, you could do it. OK, so it went to go get the file from Vault and it returned back the full path to the local directory. And you see the file popped up right there. I had another test that we could run in here.

So what we'll do is-- actually, that was just a copy. Never mind. The next one is getting a entire folder based off the folder path. So number 3 is what it does is you have your connection to the class, and then you give it a local file path. And then you put that local file path in the function folder_getbypath. And let's go ahead and hit save and run.

You see how it's downloading all the files. And then it returns the path of the folder as a function. So if it wasn't successful, it will return an empty string. OK, so we went through the first three. We're going to jump over to Visual Studio and jump into the code and explain what's going on.

Now, I am going to go through this fast. I will go into more detail in the handout that is given with this class. So if you have any questions about it, please reference the handout. I'm going to put a lot of different information in the handout, very detailed. So the first subroutine that we ran was number one, which it-- or function we ran was number one, which is vault_isconnected.

What it's going to do is it is going to use the EDMS, which is the connection to that VAULT addin, that is going-- will define the object and then use the Vault connection to connect to it. Then the next routine we talked about was file_getbyfilename. That actually has a few different functions and subroutines that kind of go along with it.

So I'm going to start with the very first one. The very first task that you have to do is you have to find the file. And to do that, you use a search condition which you're probably very familiar with if you use the Find feature in Vault. You have created a search condition. So it's very similar to that process.

You have to set up a few different objects during this process. And we want to make sure that we are connected to Vault through that function. And then we're going to use this-- we're going to grab all the files associated with that specific file name. And we will jump into that.

Let's go to that definition. So this is a search-- this is the one I was talking about with the search criteria. And there are a few things that are important that you need to know. The get property definitions by entity class, if you're looking for a file, it's file. If you're looking for a folder, it's FLDR. Let me double check that. Yeah, FLDR. We're looking for an item, it's just item.

So that is more like-- in the Find feature, you have that dropdown where you get to choose what you want to search in, that's pretty much what that is. And the sys name is a backend name. I'm going to talk about both sys name and display name in this process. Sys name is more of a backend name for a specific property. You don't typically use them. But I just wanted to show you that they are available.

These are actually available in the SDK. If that is a acronym that doesn't make sense to you, I'm going to go through that also in the handout very thoroughly. And I will talk about that here in a few minutes on where to go and some different searches that are important to be able to get some of this information.

And then you have a few different definitions-- a few different methods that you have to set inside of the search. One of them is what kind of search that-- what property you're looking for. You're looking for a single property, multiple property. Your search offer, it is a number between-- I believe it's 1 and 8 or 9. I'll look at that. I'll show you that here in a few minutes. That, it tells you whether you want to do an and, or, and how that property needs to be searched.

Do you want to search it contains. Do you want to search is empty? Do you want to search is exactly? Those are the different search operators that you can have. This is do you want must, may, there's a few other options that are available, must, may, must not. And then the search text is the actual file name that we're giving the function up here.

And then we're going to search for all the folders associated with find folders by path, the folders that are associated with that file name. You could have-- if you're searching contains, you could have multiple folders that are associated with that specific part of that file name. So we want to make sure we're grabbing all of them. And what this is going to do is it's going to return all of the folders. You want to loop through all the folders and get the folder ID because you're going to pass that folder ID into the search condition down here.

And then you want to return. And this will return a file associated with this file name. So coming back up here, we've gotten the file. We want to create a file iteration. The file iteration uses the file and the Vault connection to create the file iteration. We also want to define what this function is going to return. We want it to return the full path. So you have to get that working that path based off of the file iteration.

And then the final thing that we're going to do is actually acquire the file. So that is getting the file from Vault and downloading into your local directory. So let's jump into that, get the definition. So there are a few objects that we have to set. You'll see similar things over and over throughout this. That's on purpose. I didn't want to make it too condense that you didn't see what was going on.

So we're going to do Vault connection. Make sure we're connected to Vault again. Create a file iteration. Then we're going to use the connection, the parent, and whether we want to download the files. So we actually have to type that out as a string. And then this actually creates the settings that you would like to use to download the file.

For a part, some of these don't really matter. But for an assembly, you can definitely see that recursive children, recursive parents, and so on, you want to make sure that you have all your settings correct. I just changed them all to false. But you can definitely expand this to make them all inputs to this function to make it very versatile.

This function also has the ability to do a checkout. You just have to set it right here. So it's either going to do a checkout or it's going to do a download. And then after we set all the settings, we add those settings to the acquire files. And then that actually gets the file and brings it from Vault and puts it in the local directory.

The next one that we went over and y'all saw was the a folder_getbypath. You'll-- like I've said, you will see a repetitive thing going on, checking for Vault. We want to make sure that we remove that last dash. So that's what this is doing. If the last dash is there, it's going to go ahead and remove it. This function has the ability to delete the directory prior to you downloading the files.

So let's say you have a directory that maybe has been old. And it has files or directories in there that no longer exist in Vault. But it's kind of orphaned files. For my work's purpose, we usually use this to make sure that our directories are clean and they match Vault. And we're downloading the latest and greatest. So you can turn that to true. And it'll go ahead and clear the contents of that folder for you.

You'll notice too that we are making the local path equal the Vault path. And there's a few different differences between a local path and a Vault path. When you're going to the local path, you have backslashes. If you want to convert a file path to a Vault path, you want to change backslashes to forward slashes. And then you want to replace your working directory with a dollar sign. So those are two things that have to be done to make your local path a Vault path.

Similarly, we have to find the folders. We'll jump in that real quick. This is doing another search for a specific folder. You see FLDR, we're searching for a folder based off-- this time, we're using display name and not sys name. We want to get all the folders for the search criteria. These are similar to what you've seen in the previous function. Make sure that we're connected to Vault. And this is going to return a list of folders.

And then back up here, we get that list of folders. And we want to loop through that list, or array of folders, for a specific folder with a specific path. So let's say you have many folders that came back, but you only want to get one that matches you know your path, that's what this is doing. The full path needs to match the Vault path.

We're going to create a folder entity, which is similar to a file iteration. It uses a-- uses the connection with the folder to create the folder entity. And the next important step is actually acquiring the entire folder. So that is another subroutine that is similar to the one we just looked at.

But we-- there are different settings associated with that. It is not expanded to include all the settings. But it definitely can be expanded, just like we've done with the previous one. You're going to create the folder entity and then add that folder entity to the Add Entity to Acquire. And then you're going to add all those settings to the acquire files-- yeah, so the acquire files here.

So let's minimize these. And we can go back to-- we can go back to Inventor and continue on. OK, so we've done getting a file by a file name, getting a folder by a path. The next one is exporting a list of files associated with a folder. In the sense of-- we have used that at my work to autopopulate dropdowns. That's been very helpful.

Let's say a list of templates that we have, it grows. Let's say we convert it to a new version and we need another template. Well, that's always a good-- to get that latest and greatest list of files, so you know what to get from Vault, is important. You could also use the get folder. And it'll return the entire path and get all of the-- all of the files in that folder as well.

So folder get by extension, I have a few tests in here. And I'll show you the different tests. So what it's going to do it's going to return based off the extension, a list of file names. So want to return all the file names that end in dot ipt. So it's going to return back all the files that end in ipt.

And then let's try all the files that end in dash [INAUDIBLE]. The extension isn't quite just the extension. It's everything from the end forward. So if you wanted to include the end of a file name, you could definitely do that. We do that at my work. We grab the end of a file name plus the extension. And it makes it very, very easy. So you see how it returns all the IMs.

The other functionality of this is that you can actually export the list to a text file or to any kind of file. You can export it to a-- I haven't tried it. But you could try to export it to an Excel file. Text file is all I've tried. So don't quote me on that. So let's try to do that. And I'll show you what that looks like. So you see how it exports it. And it lists all the IEMs. And let's do one more-- one more test.

And that returned everything. So the key to that one is to put all in the extension file. So if you type ALL in all caps, it will grab everything that's in that folder. The next one is determining whether a file is checked out or not. So we're going to show Vault for a second. So let's go ahead and check out a file.

Let's go check out-- OK. And so we're going to tell-- it's going to tell me whether this specific file is checked out or not. So it says it's true. And then let's do an undo check out. And we'll run that again. And now, it's going to tell me it's false.

So that's very-- that external rule is very useful if you are worried about dealing with a file that's checked out or not checked out. If you want to do checks on certain files while you're in a workflow, you want to do that, you can do that as well. This functionality can definitely expand into other aspects. The next one we're going to look at is the undo checkout. So let's check that file back out.

All right, and then let's run this. We have to do a refresh. Let me see how it is made the file not checked out. Let's jump back over to Visual Studio and go through those three subroutines. So the folder export by extension, it is going to, of course, check to make sure your Vault is connected.

It's going to do what we've done in previous subroutines and functions, where it's going to make the local file path equal the Vault path, just by kind of messing with the string. We're going to get all the files associated with it by that path. We've gone through that subroutine. We're going to loop through all the files. We're going to ignore all the ones that are hidden that, of course, can be changed.

If it's all, then we're going to add all of them to the string. If it's not all of them, then we're going to only look at what it ends with. And it's also going to look at the SDR file extension, make it an upper. So we don't have any sort of conflicts on case. And set it to true and add it to the SDR file name.

And this, if there is a target path, then it's going to go ahead and write all that information to that file, create the file if the file doesn't exist. If it needs to be cleared out and wrote to again, then this will do that as well. All right, let's scroll down here. OK, file is checked out.

This is creating the Inventor application object, file iteration, file object, making sure the Vault is connected. Using that find by file name that we've gone through, it's going to return a file. We're going to create a file iteration. And then there's a functionality in the file iteration where you can choose a method called is checked out. This actually has a functionality that you can put in true or false for Boolean to current user.

That means that if you turn that to true, it's going to check to see if the file is checked out to the current user, which would be me. So that's going to return that. This is the undo checkout. The undo checkout is doing very similar things, finding the file by the file name. Instead of doing-- so we'll do the file iteration and then getting the full path to return to the function.

Then we will determine whether the file is checked out or not. If it is checked out, then we are going to call the connection.filemanager.undocheckout with the file iteration added to it. And that's going to take the file, create the file iteration, and then undo checkout if it's checked out.

All right, let's go back to [INAUDIBLE] and show some more. So the next one we'll look at is-- this is all talking-- the next three are just talking about life cycle states. For my company, it is important for certain life cycle states, especially as a developer, we are typically using only the released version of the life cycle state for all of our users.

So we want to make sure and making sure that the users are only using the release date, even if the latest date isn't at the release date. So this is how we do that. OK, we are going to look at number 7. So number 7 is get from file latest version by lifecycle state.

So it's going to get the file, at its latest version. So let's say we currently have this file. And we want to just go ahead and get that. Your latest version is going to be number 5, or the local version will be number 5. So we'll go ahead and hit and run that. Oh, that's the creator. So that's going to return the latest version, latest version creator.

So it's going to return me. So let's keep this up just a tad. And then we're going to-- so the latest version creator is me. And then the next one is number 8. It's going to return the file at a specific lifecycle state. So for this one, we have a couple of different states that we're going to test out. So since we're not at the latest version, we'll go ahead and run that state.

So that is going to-- when you do a refresh, that is going to change the local version of number 7, which is work in progress right there. Let's do another test to the release date. So let's run that. And gonna return back the path, and let's do a refresh. And it's going to do number 4. So number 4, version 4 is at the release date.

The very last one, dealing with life cycle states is actually just returning the latest version's life cycle state. So it should return work in progress. So it's work in progress. OK, well, let's jump back over to Visual Studio. And let's scroll down. So get the creator. So we're creating a few different objects, checking Vault connection, similar to what we've been doing.

Getting the file by the file name, creating that file version, that is going to return all the versions associated with that specific file name. Then we're going to reverse the array. Wait-- am I going through the right one? Yeah, the creator. Yeah, then we're going to get the creator's username off of that specific version.

You have to reverse the array because it comes back in descending order, which would be the latest-- the first version. And in this case, we want to do the latest version. So I've just reversing it. So it's easier to find that specific version.

The next one is we're going to get the latest version life cycle state. So we're doing similar things, getting the file name, getting the file based off of the file name, reversing the array, creating the file versions, reversing the array, looping through the versions. And then we're going to get that lifecycle state. So whatever lifecycle state we tell it to get, it's going to try to find the lifecycle state name of that version. And in reverse order, so from 7 to 1, and then it's going to find that specific lifecycle state and then return that file based off of that file version.

We're going to do the file iteration. And if the file is checked out, go ahead and acquire that file based off of that file version. And it's going to return the full path name if that's successful. If it's not, it's going to be an empty string. Number 9, doing very similar things as the previous function, but instead, down here, it's actually going to return the lifecycle state of the very first version, or the latest version. So it would be number 7 in that case.

So let's go back to Inventor. And we'll go through a couple more. So the next one is number 10. We're going to clear contents of that folder. So that folder-- this folder. So we want to clear contents of this folder. What it's going to do is it's going to clear all the files and folders associated with that file path.

I don't currently having it separating the two. It's just going to clear the entire folder based off of folders and files. So let's go ahead and hit save and run. You'll see all this stuff disappeared, gone. The next one is number 11. We're going to dive into items just for a few minutes.

We're going to get a prop, which is a property value from an item. So you have a prop name. And I have a few different examples here. So we're going to look at prop name on an item. So let's go to the item master and search for this specific item. And let's look at its properties.

So if we run this, it should return false for bulk. So let's go ahead and make sure it does that. So it's going to return false, cool. Let's do one more. One more test in that one. Let's return the lifecycle state-- or lifecycle definition. So let's do save and run. And it should return item release process, which it did.

The next one is number 12. We're going to get all the properties and values for a specific item. This is going to-- in Visual Studio, it's actually getting all these properties and writing them to a definition, or a dictionary. And the key is the property name. And the value is the value of the property.

So I'm only returning about 20 properties. You can, of course, return as many as you want. This is more for testing purposes. It'll return-- it'll go ahead and get all the properties. But it's only going to display 20. So you see there's a list of all the properties and their associated values inside of Vault.

Find all associated files. So associated files are these files that are listed here. For this one, it should return a 101-m. So let's hit save and run. Make sure it does. So it's-- oh, I must have had a different one in there. Hold on. Oh, typo, OK. And so 101-d, that is correct. So that one is what it returns. It also returns other associated files if you have tertiary or secondary files. I do have one that does have that.

So let's search for that one real quick. And we'll go ahead and run it. And I'll show you what it's going to look while Vault is updating. OK, so it's going to return a primary and a tertiary. So we have both of those show up.

Let's go back to Visual Studio quickly and dive into the items. So your items, there's a different-- do you remember going back into the functions? You saw a lot of O doc service. When you go into the items, you'll see O item service. That goes to the webservicemanager.itemservice. That's where you're going to get a lot of the information regarding items.

For a property definition, you have to tell it that you want to look at an item. You also want to define what a filter-- what filter you want to do. There's many filters associated with this. The default is include all. So it is going to return the prop val for that value, for that property, the value for that property.

The next one, it's going to get all the props and vals for a specific item. So it's going to do very similar things. You want to include all. But instead, we're going to loop through all the properties and add them to a dictionary. So this is what that is doing. And it's actually going to return a dictionary in the function.

The next set is returning the associated files. This one's a little different. You want to get all the associated files based off of the item ID and based off of what property. So what this is going to do is it's going to loop through and get all of the associated files for all the different variations that can occur, so primary, primary sum, tertiary, secondary, secondary sum, it's going to add all of those to a dictionary, which this is what's going on.

If there's not one associated with that, it's going to go ahead and add it. But it's going to blank-- it'll give a blank value for that key for the dictionary. So it's doing it for all of them. And then it's going to return a dictionary as the function name. So let's go back to PowerPoint.

So some links that I find very helpful and important sites is the Autodesk Community. I get so much information. And I value all of the input from everybody that actually gets on there, and contributes, and communicates with people. So you have the Inventor iLogic VB.net forum and the Vault customization forum. Both those QR codes link to those sites. And that's it. I appreciate you joining me. And have a good rest of your day.