protected override void Execute(CodeActivityContext context)
        {
            String CreateVariableKey      = VariableName.Get(context);
            object CreateVariableNewValue = VariableNewValue.Get(context);

            my_data.UpdateData(CreateVariableKey, CreateVariableNewValue);
        }
Пример #2
0
        protected override void Execute(CodeActivityContext context)
        {
            ContextClient contextClient = null;

            if (ContextClient.Expression == null)
            {
                var ContextClientArgument = context.DataContext.GetProperties()["ContextClient"];
                contextClient = ContextClientArgument.GetValue(context.DataContext) as ContextClient;
                if (contextClient == null)
                {
                    throw (new ArgumentException("ContextClient was not provided and cannot be retrieved from the container."));
                }
            }
            else
            {
                contextClient = ContextClient.Get(context);
            }

            contextClient.SetVariable(VariableName.Get(context), VariableValue.Get(context));
        }
        protected override void Execute(CodeActivityContext context)
        {
            String CreateVariableKey = VariableName.Get(context);

            VariableOutput.Set(context, my_data.RetrieveData(CreateVariableKey));
        }
Пример #4
0
        /// <inheritdoc />
        protected override void Execute(Context context)
        {
            HasValue.Set(context, false);
            ValueType.Set(context, null);
            StringValue.Set(context, null);
            JsonValue.Set(context, null);
            BooleanValue.Set(context, default(bool));
            DateTimeValue.Set(context, default(DateTime));
            DecimalValue.Set(context, default(decimal));
            MoneyValue.Set(context, default(Money));
            DoubleValue.Set(context, default(double));
            IntegerValue.Set(context, default(int));

            var variableName = VariableName.Get(context);

            if (string.IsNullOrWhiteSpace(variableName))
            {
                throw new InvalidWorkflowExecutionException("Variable Name is empty.");
            }

            if (!context.SourceContext.SharedVariables.ContainsKey(variableName))
            {
                return;
            }
            var value = context.SourceContext.SharedVariables[variableName];

            if (value == null)
            {
                ValueType.Set(context, "Null");
                return;
            }

            ValueType.Set(context, value.GetType().Name);

            HasValue.Set(context, true);

            var stringValue = value as string ?? value.ToString();

            StringValue.Set(context, stringValue);

            var booleanValue = value as bool? ?? !(stringValue.Equals("false", StringComparison.OrdinalIgnoreCase) || stringValue.Equals("0") || stringValue.Equals("+0") || stringValue.Equals("-0"));

            BooleanValue.Set(context, booleanValue);

            DateTime dateTimeValue;

            if (value is DateTime)
            {
                DateTimeValue.Set(context, (DateTime)value);
            }
            else if (DateTime.TryParse(stringValue, out dateTimeValue))
            {
                DateTimeValue.Set(context, dateTimeValue);
            }

            decimal decimalValue;

            if (value is decimal)
            {
                decimalValue = (decimal)value;
                DecimalValue.Set(context, decimalValue);
                MoneyValue.Set(context, new Money(decimalValue));
            }
            else if (decimal.TryParse(stringValue, out decimalValue))
            {
                DecimalValue.Set(context, decimalValue);
                MoneyValue.Set(context, new Money(decimalValue));
            }

            var moneyValue = value as Money;

            if (moneyValue != null)
            {
                DecimalValue.Set(context, moneyValue.Value);
                MoneyValue.Set(context, moneyValue);
            }

            double doubleValue;

            if (value is double)
            {
                DoubleValue.Set(context, (double)value);
            }
            else if (double.TryParse(stringValue, out doubleValue))
            {
                DoubleValue.Set(context, doubleValue);
            }

            int integerValue;

            if (value is int)
            {
                IntegerValue.Set(context, (int)value);
            }
            else if (int.TryParse(stringValue, out integerValue))
            {
                IntegerValue.Set(context, integerValue);
            }

            JsonValue.Set(context, JsonConvert.SerializeObject(value, new JsonSerializerSettings
            {
                ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
                DateFormatHandling    = DateFormatHandling.IsoDateFormat,
                NullValueHandling     = NullValueHandling.Ignore
            }));
        }