m (Alexandra moved page Calling your own c:hash: to Calling your own c .net things from Turnkey–server side over redirect) |
|
(No difference)
|
Revision as of 20:14, 28 October 2018
As MDriven Turnkey works on your defined model and information you will have access to everything you need – until you don’t.
For example we had these use-cases that called for the ability to reach out from the standard turnkey implementation:
- Add a key generation algorithm that use advanced cryptography
- Call external web-api’s and wait for the result to add as data in the current model
Luckily there is an extension mechanism that allows for this – and once you have implemented it, it is easy to call logic from your extensions straight from the model.
Assembly Eco.Interfaces namespace Eco.Services { // // Summary: // Allows you to supply domain object method implementations with late bound assembly public interface IExternalLateBoundService { IElement Execute(IClassifier classifier, IObject theobject, IMethod method, IModifiableVariableList variableList); } }
Create a new class library with .net4.5. Set its output name to “TurnKey_ExternalLateBound.dll” (important)
Create a type in the assembly that implements the above interface IExternalLateBoundService.
In the Execute method – check the classifier and method name – like this:
public Eco.ObjectRepresentation.IElement Execute(Eco.UmlRt.IClassifier classifier,
Eco.ObjectRepresentation.IObject theobject,
Eco.UmlRt.IMethod method,
Eco.ObjectRepresentation.IModifiableVariableList variableList) { if (theobject != null && method != null) { if (theobject.UmlClass.Name == "SiteAsset") { if (method.Name == "SendAsset") { string res = "Sending asset: " + SendSiteAssetToTurnkeySite(theobject, variableList); return EcoServiceHelper.GetVariableFactoryService(theobject.ServiceProvider).CreateConstant(res); } } else if (theobject.UmlClass.Name == "RuntimeKey") { if (method.Name == "GenerateKey") { return RuntimeKey_GenerateKey(theobject, variableList); } } else { string res = "No logic for " + theobject.UmlClass.Name + "." + method.Name; return EcoServiceHelper.GetVariableFactoryService(theobject.ServiceProvider).CreateConstant(res); }
} } return null; }
As you can see from the code above it simply checks if the sent in object is of a certain model class – if so is the method named a certain way – if so we do things given the parameters we got and we return a result.
In the actual implementation of my external logic I can access the parameters sent in to the method like this:
variableList["vStartPart"].Element.GetValue<string>()
I can access properties of the object that own the method like this:
var pageStyle = viewoverride.Properties["PageStyle"].GetValue<string>();
I can navigate associations like this:
IObject Product = theobject.Properties["Product"].Element as IObject;
To make the logic available to your turnkey site you must upload the assembly – and all other assemblies it depends on - to the folder “EXT_LateBoundAssembly” that is under the root of your turnkey site.
In your model you define the methods on the classes and leave their implementation blank and you fill in a tagged value on the method Eco.ExternalLateBound=True:
Once you have followed these steps you can call your method from an action, a button or even from a derivation (if it the method is marked as a query) – and Turnkey will route the call to your assembly and execute your code.