public CmmnTransform(CmmnTransformer transformer)
{
this.transformer = transformer;
this.expressionManager = transformer.ExpressionManager;
this.handlerRegistry = transformer.CmmnElementHandlerRegistry;
this.transformListeners = transformer.TransformListeners;
}
protected internal virtual void initializeOutputParameter(CmmnElement element, CmmnActivity activity, CmmnHandlerContext context, CallableElement callableElement)
{
ExpressionManager expressionManager = context.ExpressionManager;
IList <CamundaOut> outputs = getOutputs(element);
foreach (CamundaOut output in outputs)
{
// create new parameter
CallableElementParameter parameter = new CallableElementParameter();
callableElement.addOutput(parameter);
// all variables
string variables = output.CamundaVariables;
if ("all".Equals(variables))
{
parameter.AllVariables = true;
continue;
}
// source/sourceExpression
string source = output.CamundaSource;
if (string.ReferenceEquals(source, null) || source.Length == 0)
{
source = output.CamundaSourceExpression;
}
ParameterValueProvider sourceValueProvider = createParameterValueProvider(source, expressionManager);
parameter.SourceValueProvider = sourceValueProvider;
// target
string target = output.CamundaTarget;
parameter.Target = target;
}
}
/// <summary>
/// Handles the SaveChanges event of the EditSaveControl control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
void EditSaveControl_SaveChanges(object sender, SaveControl.SaveEventArgs e)
{
// Validate form
if (!this.Page.IsValid)
{
e.RunScript = false;
return;
}
ExpressionDto expression = (ExpressionDto)Session[_ExpressionDtoEditSessionKey]; //null;
if (ExpressionId > 0 && expression == null)
{
expression = ExpressionManager.GetExpressionDto(ExpressionId); //Int32.Parse(Parameters["ExpressionId"].ToString()));
}
else if (ExpressionId == 0)
{
expression = new ExpressionDto();
}
IDictionary context = new ListDictionary();
context.Add(_ExpressionDtoString, expression);
ViewControl.SaveChanges(context);
if (expression.HasChanges())
{
ExpressionManager.SaveExpression(expression);
}
// we don't need to store Dto in session any more
Session.Remove(_ExpressionDtoEditSessionKey);
}
SpriteRenderer spriteRen; //声明该组件用来更换表情
public void Start()
{
expresMana = FindObjectOfType <ExpressionManager>();
enemyChar = GetComponent <EnemyCharacter>();
testing = GetComponent <TestingPlayer>();
spriteRen = GetComponentInChildren <SpriteRenderer>();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void setup()
public virtual void setup()
{
modelInstance = Cmmn.createEmptyModel();
definitions = modelInstance.newInstance(typeof(Definitions));
definitions.TargetNamespace = "http://camunda.org/examples";
modelInstance.Definitions = definitions;
caseDefinition = createElement(definitions, "aCaseDefinition", typeof(Case));
casePlanModel = createElement(caseDefinition, "aCasePlanModel", typeof(CasePlanModel));
context = new CmmnHandlerContext();
CaseDefinitionEntity caseDefinition = new CaseDefinitionEntity();
caseDefinition.TaskDefinitions = new Dictionary <string, TaskDefinition>();
context.CaseDefinition = caseDefinition;
ExpressionManager expressionManager = new ExpressionManager();
context.ExpressionManager = expressionManager;
DeploymentEntity deployment = new DeploymentEntity();
deployment.Id = "foo";
context.Deployment = deployment;
}
/// <summary>
/// Processes the delete command.
/// </summary>
/// <param name="items">The items.</param>
void ProcessDeleteCommand(string[] items)
{
for (int i = 0; i < items.Length; i++)
{
string[] keys = EcfListView.GetPrimaryKeyIdStringItems(items[i]);
if (keys != null)
{
string id = keys[0];
List <int> expressionList = new List <int>();
SegmentDto dto = SegmentManager.GetSegmentDto(Int32.Parse(id));
if (dto.Segment.Count > 0)
{
SegmentDto.SegmentRow segmentRow = dto.Segment[0];
foreach (SegmentDto.SegmentConditionRow condition in segmentRow.GetSegmentConditionRows())
{
expressionList.Add(condition.ExpressionId);
}
dto.Segment[0].Delete();
SegmentManager.SaveSegment(dto);
}
// Delete corresponding expressions
foreach (int expressionId in expressionList)
{
ExpressionDto expressionDto = ExpressionManager.GetExpressionDto(expressionId);
if (expressionDto != null && expressionDto.Expression.Count > 0)
{
expressionDto.Expression[0].Delete();
ExpressionManager.SaveExpression(expressionDto);
}
}
}
}
}
protected internal virtual void ParseValidation(Element formField, FormFieldHandler formFieldHandler,
BpmnParse bpmnParse, ExpressionManager expressionManager)
{
var validationElement = formField.ElementNs(BpmnParse.CamundaBpmnExtensionsNs, "validation");
if (validationElement != null)
{
var constraintElements = validationElement.ElementsNS(
BpmnParse.CamundaBpmnExtensionsNs.NamespaceUri, "constraint");
foreach (var property in constraintElements)
{
var validator = Context.ProcessEngineConfiguration.FormValidators.CreateValidator(property,
bpmnParse, expressionManager);
var validatorName = property.GetAttributeValue("name");
var validatorConfig = property.GetAttributeValue("config");
if (validator != null)
{
var handler = new FormFieldValidationConstraintHandler();
handler.Name = validatorName;
handler.Config = validatorConfig;
handler.Validator = validator;
formFieldHandler.ValidationHandlers.Add(handler);
}
}
}
}
/// <summary>
/// Loads the expressions.
/// </summary>
private void LoadExpressions()
{
ExpressionDto dto = ExpressionManager.GetExpressionDto(ExpressionCategory.GetExpressionCategory(ExpressionCategory.CategoryKey.Policy).Key);
ddlExpression.DataSource = dto;
ddlExpression.DataBind();
}
/// <summary>
/// Creates the expression row.
/// </summary>
/// <param name="expressionDto">The expression dto.</param>
/// <returns></returns>
public ExpressionDto.ExpressionRow CreateExpressionRow(ref ExpressionDto expressionDto)
{
PromotionDto.PromotionConditionRow row = null;
ExpressionDto.ExpressionRow expressionRow = null;
if (_PromotionDto.PromotionCondition.Count == 0)
{
row = _PromotionDto.PromotionCondition.NewPromotionConditionRow();
row.PromotionId = _PromotionDto.Promotion[0].PromotionId;
expressionRow = expressionDto.Expression.NewExpressionRow();
expressionRow.ApplicationId = MarketingConfiguration.Instance.ApplicationId;
expressionRow.Category = ExpressionCategory.CategoryKey.Promotion.ToString();
expressionRow.Created = DateTime.UtcNow;
}
else
{
row = _PromotionDto.PromotionCondition[0];
expressionDto = ExpressionManager.GetExpressionDto(row.ExpressionId);
expressionRow = expressionDto.Expression[0];
}
expressionRow.ModifiedBy = Page.User.Identity.Name;
expressionRow.Description = _Config.Description;
expressionRow.Name = _Config.Type;
row.ExpressionId = expressionRow.ExpressionId;
if (row.RowState == DataRowState.Detached)
{
PromotionDto.PromotionCondition.Rows.Add(row);
}
return(expressionRow);
}
/// <summary>
/// Loads the expressions.
/// </summary>
/// <param name="iStartIndex">Start index of the i.</param>
/// <param name="iNumItems">The i num items.</param>
/// <param name="sFilter">The s filter.</param>
private void LoadExpressions(int iStartIndex, int iNumItems, string sFilter)
{
ExpressionDto dto = ExpressionManager.GetExpressionDto(ExpressionCategory.GetExpressionCategory(ExpressionCategory.CategoryKey.Promotion).Key);
ExpressionFilter.DataSource = dto.Expression;
ExpressionFilter.DataBind();
}
/// <summary>
/// フィルタに基づいて検索を実行し、Members に結果をセットします。
/// </summary>
/// <param name="previousOrder">直前の並び替え順。なるべくこの順番を維持するように結果が生成されます。null もしくは 要素数 0 の場合は適当に生成されます。</param>
public void UpdateMembers(IEnumerable <int> previousOrder = null)
{
if (Expressions == null)
{
Expressions = new ExpressionManager();
}
if (InclusionFilter == null)
{
InclusionFilter = new List <int>();
}
if (ExclusionFilter == null)
{
ExclusionFilter = new List <int>();
}
ValidateFilter();
if (!Expressions.IsAvailable)
{
Expressions.Compile();
}
var newdata = Expressions.GetResult(KCDatabase.Instance.Ships.Values).Select(s => s.MasterID).Union(InclusionFilter).Except(ExclusionFilter);
IEnumerable <int> prev = (previousOrder != null && previousOrder.Count() > 0) ? previousOrder : (Members ?? new List <int>());
// ソート順序を維持するため
Members = prev.Except(prev.Except(newdata)).Union(newdata).ToList();
}
public void ExportVrmExpression(ExpressionManager src, List <MeshGroup> _, List <Material> materials, List <Node> nodes)
{
foreach (var x in src.ExpressionList)
{
Storage.gltfVrm.Expressions.Add(x.ToGltf(nodes, materials));
}
}
/// <summary>
/// Gets the marketing helper.
/// </summary>
/// <param name="useCache">if set to <c>true</c> [use cache].</param>
/// <returns></returns>
private MarketingHelper GetMarketingHelper(bool useCache)
{
MarketingHelper helper = null;
string cacheKey = MarketingCache.CreateCacheKey("MarketingHelper");
if (useCache)
{
object cachedObject = MarketingCache.Get(cacheKey);
if (cachedObject != null)
{
helper = (MarketingHelper)cachedObject;
}
}
// If marketing is not initialized, init it
if (helper == null)
{
// Load promotion Dto
PromotionDto promotionDto = PromotionManager.GetPromotionDto(FrameworkContext.Current.CurrentDateTime);
// Get all the data from the database first
helper = new MarketingHelper(CampaignManager.GetCampaignDto(), ExpressionManager.GetExpressionDto(), PolicyManager.GetPolicyDto(), promotionDto, SegmentManager.GetSegmentDto());
// Insert cache
//if (useCache)
MarketingCache.Insert(cacheKey, helper, MarketingConfiguration.Instance.CacheConfig.PromotionCollectionTimeout);
}
return(helper);
}
public Runtime(string text = "", IFileCache fileCache = null)
{
Sys = new Sys();
stack = new ValueStack();
blockManager = new BlockManager();
printBuffer = new Buffer();
patternManager = new PatternManager();
Regions = new RegionManager(Sys, text);
expressionManager = new ExpressionManager();
FieldPattern = (Pattern)(STRING_BEGIN_PATTERN + "+" + STRING_END_PATTERN);
RecordPattern = (Pattern)(STRING_BEGIN_PATTERN + "'`r`n' | '`r' | '`n'" + STRING_END_PATTERN);
FieldSeparator = (String)" ";
RecordSeparator = (String)"\r\n";
seed = DateTime.Now.Millisecond;
random = new Random(seed);
valueStacks = new Stack <ValueStack>();
FileCache = fileCache ?? new StandardFileCache();
takeArray = new Array();
defaultParameterNames = new Stack <DefaultParameterNames>();
defaultParameterNames.Push(new DefaultParameterNames(true));
buffer = new Buffer();
ArgumentDepth = 0;
invokeables = new Hash <string, IInvokeable>();
extenders = new Hash <string, InvokeableReference>();
Parser.InClassDefinition = false;
consoleManager = new ConsoleManager();
indent = "";
}
private static ArgumentCollection CreateArgumentCollection <TFake>(TFake fake, LambdaExpression callSpecification)
{
var methodCall = callSpecification.Body as MethodCallExpression;
MethodInfo method = null;
object[] arguments = null;
if (methodCall != null)
{
method = methodCall.Method;
arguments =
(from argument in methodCall.Arguments
select ExpressionManager.GetValueProducedByExpression(argument)).ToArray();
}
else
{
var propertyCall = callSpecification.Body as MemberExpression;
var property = propertyCall.Member as PropertyInfo;
method = property.GetGetMethod();
arguments = new object[] { };
}
return(new ArgumentCollection(arguments, method));
}
private TestHostContext CreateTestContext([CallerMemberName] String testName = "")
{
var hc = new TestHostContext(this, testName);
var expressionManager = new ExpressionManager();
expressionManager.Initialize(hc);
hc.SetSingleton <IExpressionManager>(expressionManager);
Dictionary <string, VariableValue> variablesToCopy = new Dictionary <string, VariableValue>();
_variables = new Variables(
hostContext: hc,
copy: variablesToCopy);
_ec = new Mock <IExecutionContext>();
_ec.SetupAllProperties();
_ec.Setup(x => x.Variables).Returns(_variables);
_contexts = new DictionaryContextData();
_jobContext = new JobContext();
_contexts["github"] = new DictionaryContextData();
_contexts["runner"] = new DictionaryContextData();
_contexts["job"] = _jobContext;
_ec.Setup(x => x.ExpressionValues).Returns(_contexts);
_ec.Setup(x => x.JobContext).Returns(_jobContext);
_stepContext = new StepsContext();
_ec.Setup(x => x.StepsContext).Returns(_stepContext);
_ec.Setup(x => x.PostJobSteps).Returns(new Stack <IStep>());
_stepsRunner = new StepsRunner();
_stepsRunner.Initialize(hc);
return(hc);
}
protected internal override void initializeActivity(CmmnElement element, CmmnActivity activity, CmmnHandlerContext context)
{
// execute standard initialization
base.initializeActivity(element, activity, context);
// create a taskDefinition
TaskDefinition taskDefinition = createTaskDefinition(element, context);
// get the caseDefinition...
CaseDefinitionEntity caseDefinition = (CaseDefinitionEntity)context.CaseDefinition;
// ... and taskDefinition to caseDefinition
caseDefinition.TaskDefinitions[taskDefinition.Key] = taskDefinition;
ExpressionManager expressionManager = context.ExpressionManager;
// create decorator
TaskDecorator taskDecorator = new TaskDecorator(taskDefinition, expressionManager);
// set taskDecorator on behavior
HumanTaskActivityBehavior behavior = (HumanTaskActivityBehavior)activity.ActivityBehavior;
behavior.TaskDecorator = taskDecorator;
// task listeners
initializeTaskListeners(element, activity, context, taskDefinition);
}
/// <exception cref="BpmnParseException"> if the parameter is invalid </exception>
protected internal static ParameterValueProvider parseParamValueProvider(Element parameterElement)
{
// LIST
if ("list".Equals(parameterElement.TagName))
{
IList <ParameterValueProvider> providerList = new List <ParameterValueProvider>();
foreach (Element element in parameterElement.elements())
{
// parse nested provider
providerList.Add(parseParamValueProvider(element));
}
return(new ListValueProvider(providerList));
}
// MAP
if ("map".Equals(parameterElement.TagName))
{
SortedDictionary <ParameterValueProvider, ParameterValueProvider> providerMap = new SortedDictionary <ParameterValueProvider, ParameterValueProvider>();
foreach (Element entryElement in parameterElement.elements("entry"))
{
// entry must provide key
string keyAttribute = entryElement.attribute("key");
if (string.ReferenceEquals(keyAttribute, null) || keyAttribute.Length == 0)
{
throw new BpmnParseException("Missing attribute 'key' for 'entry' element", entryElement);
}
// parse nested provider
providerMap[new ElValueProvider(ExpressionManager.createExpression(keyAttribute))] = parseNestedParamValueProvider(entryElement);
}
return(new MapValueProvider(providerMap));
}
// SCRIPT
if ("script".Equals(parameterElement.TagName))
{
ExecutableScript executableScript = parseCamundaScript(parameterElement);
if (executableScript != null)
{
return(new ScriptValueProvider(executableScript));
}
else
{
return(new NullValueProvider());
}
}
string textContent = parameterElement.Text.Trim();
if (textContent.Length > 0)
{
// EL
return(new ElValueProvider(ExpressionManager.createExpression(textContent)));
}
else
{
// NULL value
return(new NullValueProvider());
}
}
public void Should_CreatePath_BasicExpression()
{
var manager = new ExpressionManager();
var expressions = CreateExpressions <ComplexObject>(x => x.Id);
var paths = expressions.Select(x => manager.GetPropertyPath(x)).ToList();
CollectionAssert.AreEqual(new[] { ".Id" }, paths);
}
private TestHostContext CreateTestContext([CallerMemberName] String testName = "")
{
var hc = new TestHostContext(this, testName);
_expressionManager = new ExpressionManager();
_expressionManager.Initialize(hc);
return(hc);
}
private ExpressionManager GetExpressionManager()
{
var expr = new ExpressionManager();
expr.Initialize(_expressions, _expressions.CustomFunctions);
return(expr);
}
/// <summary>
/// Loads the fresh.
/// </summary>
/// <returns></returns>
private ExpressionDto LoadFresh()
{
ExpressionDto expression = ExpressionManager.GetExpressionDto(ExpressionId);
// persist in session
Session[_ExpressionDtoEditSessionKey] = expression;
return(expression);
}
protected internal virtual void CreateMultiInstanceLoopCharacteristics(BpmnParse bpmnParse, Activity modelActivity)
{
MultiInstanceLoopCharacteristics loopCharacteristics = modelActivity.LoopCharacteristics;
// Activity Behavior
MultiInstanceActivityBehavior miActivityBehavior;
if (loopCharacteristics.Sequential)
{
miActivityBehavior = bpmnParse.ActivityBehaviorFactory.CreateSequentialMultiInstanceBehavior(modelActivity, (AbstractBpmnActivityBehavior)modelActivity.Behavior);
}
else
{
miActivityBehavior = bpmnParse.ActivityBehaviorFactory.CreateParallelMultiInstanceBehavior(modelActivity, (AbstractBpmnActivityBehavior)modelActivity.Behavior);
}
modelActivity.Behavior = miActivityBehavior;
ExpressionManager expressionManager = Context.ProcessEngineConfiguration.ExpressionManager;
// loop cardinality
if (!string.IsNullOrWhiteSpace(loopCharacteristics.LoopCardinality))
{
miActivityBehavior.LoopCardinalityExpression = expressionManager.CreateExpression(loopCharacteristics.LoopCardinality);
}
// completion condition
if (!string.IsNullOrWhiteSpace(loopCharacteristics.CompletionCondition))
{
miActivityBehavior.CompletionConditionExpression = expressionManager.CreateExpression(loopCharacteristics.CompletionCondition);
}
// activiti:collection
if (!string.IsNullOrWhiteSpace(loopCharacteristics.InputDataItem))
{
if (loopCharacteristics.InputDataItem.Contains("{"))
{
miActivityBehavior.CollectionExpression = expressionManager.CreateExpression(loopCharacteristics.InputDataItem);
}
else
{
miActivityBehavior.CollectionVariable = loopCharacteristics.InputDataItem;
}
}
// activiti:elementVariable
if (!string.IsNullOrWhiteSpace(loopCharacteristics.ElementVariable))
{
miActivityBehavior.CollectionElementVariable = loopCharacteristics.ElementVariable;
}
// activiti:elementIndexVariable
if (!string.IsNullOrWhiteSpace(loopCharacteristics.ElementIndexVariable))
{
miActivityBehavior.CollectionElementIndexVariable = loopCharacteristics.ElementIndexVariable;
}
}
public virtual void setUp()
{
task = (TaskEntity)taskService.newTask();
taskService.saveTask(task);
expressionManager = processEngineConfiguration.ExpressionManager;
taskDefinition = new TaskDefinition(null);
taskDecorator = new TaskDecorator(taskDefinition, expressionManager);
}
protected internal virtual void parseFormData(BpmnParse bpmnParse, ExpressionManager expressionManager, Element extensionElement)
{
Element formData = extensionElement.elementNS(BpmnParse.CAMUNDA_BPMN_EXTENSIONS_NS, "formData");
if (formData != null)
{
this.businessKeyFieldId = formData.attribute(BUSINESS_KEY_ATTRIBUTE);
parseFormFields(formData, bpmnParse, expressionManager);
}
}
public void Should_CreatePath_WithChildrenFirst()
{
var manager = new ExpressionManager();
var expressions = CreateExpressions <ComplexObjectWithListChildren>(
x => x.Children.First().BasicChild.BasicChildId
);
var paths = expressions.Select(x => manager.GetPropertyPath(x)).ToList();
CollectionAssert.AreEqual(new[] { ".Children.BasicChild.BasicChildId" }, paths);
}
protected internal virtual void ParseFormField(Element formField, BpmnParse bpmnParse,
ExpressionManager expressionManager)
{
var formFieldHandler = new FormFieldHandler();
// parse Id
var id = formField.GetAttributeValue("id");
if (ReferenceEquals(id, null) || (id.Length == 0))
{
bpmnParse.AddError("attribute id must be set for FormFieldGroup and must have a non-empty value",
formField);
}
else
{
formFieldHandler.Id = id;
}
if (id.Equals(BusinessKeyFieldId))
{
formFieldHandler.BusinessKey = true;
}
// parse name
var name = formField.GetAttributeValue("label");
if (!ReferenceEquals(name, null))
{
IExpression nameExpression = (Bpm.Engine.Impl.EL.IExpression)expressionManager.CreateExpression(name);
formFieldHandler.Label = nameExpression;
}
// parse properties
ParseProperties(formField, formFieldHandler, bpmnParse, expressionManager);
// parse validation
ParseValidation(formField, formFieldHandler, bpmnParse, expressionManager);
// parse type
var formTypes = FormTypes;
var formType = formTypes.ParseFormPropertyType(formField, bpmnParse);
formFieldHandler.SetType(formType);
// parse default value
var defaultValue = formField.GetAttributeValue("defaultValue");
if (!ReferenceEquals(defaultValue, null))
{
IExpression defaultValueExpression = (Bpm.Engine.Impl.EL.IExpression)expressionManager.CreateExpression(defaultValue);
formFieldHandler.DefaultValueExpression = defaultValueExpression;
}
FormFieldHandlers.Add(formFieldHandler);
}
public void ExportVrmExpression(ExpressionManager src, List <MeshGroup> _, List <Material> materials, List <Node> nodes)
{
if (Storage.gltfVrm.Expressions == null)
{
Storage.gltfVrm.Expressions = new List <UniGLTF.Extensions.VRMC_vrm.Expression>();
}
foreach (var x in src.ExpressionList)
{
Storage.gltfVrm.Expressions.Add(x.ToGltf(nodes, materials));
}
}
protected internal virtual void ParseFormData(BpmnParse bpmnParse, ExpressionManager expressionManager,
Element extensionElement)
{
var formData = extensionElement.ElementNs(BpmnParse.CamundaBpmnExtensionsNs, "formData");
if (formData != null)
{
BusinessKeyFieldId = formData.GetAttributeValue(BusinessKeyAttribute);
ParseFormFields(formData, bpmnParse, expressionManager);
}
}
protected internal virtual void ParseFormFields(Element formData, BpmnParse bpmnParse,
ExpressionManager expressionManager)
{
// parse fields:
var formFields = formData.ElementsNS(BpmnParse.CamundaBpmnExtensionsNs, FormFieldElement);
foreach (var formField in formFields)
{
ParseFormField(formField, bpmnParse, expressionManager);
}
}
