private static string ConvertActivityCondition(ActivityCondition condition, RuleDefinitions ruleDefinitions)
        {
            var builder = new StringBuilder();

            if (condition != null)
            {
                if (condition is RuleConditionReference)
                {
                    var ruleRef = (RuleConditionReference)condition;
                    builder.AppendLine(RuleTranslator.ConvertRuleConditionReference(ruleDefinitions, ruleRef));
                }
                else
                {
                    throw new NotSupportedException("Type not found:" + condition.GetType());
                }
            }
            else
            {
                builder.AppendLine("This activity gets executed if the other conditions fail in the evaluation process");
            }
            return(builder.ToString());
        }
        private static string ConvertActivity(Activity current, RuleDefinitions ruleDefinitions)
        {
            var builder = new StringBuilder();

            if (current is IfElseActivity)
            {
                //var activity = current as IfElseActivity;
                //if (activity.Activities.Count > 0) // there are branches if..else..activity
                //{
                //    string[] dependents = activity.Activities.Select(x => x.Name).ToArray();

                //    builder.AppendFormat("There are {0} conditions executed in this scenario namely -", activity.Activities.Count)
                //        .AppendLine(dependents.ToCSV())
                //        .AppendLine();
                //}
            }
            else if (current is IfElseBranchActivity)
            {
                var activity = current as IfElseBranchActivity;
                builder.AppendLine(ConvertActivityCondition(activity.Condition, ruleDefinitions));
            }
            else if (current is WhileActivity)
            {
                var activity = current as WhileActivity;
                builder.AppendLine(ConvertActivityCondition(activity.Condition, ruleDefinitions));
            }
            //else if (current is SequenceActivity)
            //{

            //}
            //else if (current is ListenActivity)
            //{

            //}
            //else if (current is StateActivity)
            //{

            //}
            //else if (current is StateInitializationActivity)
            //{

            //}
            else if (current is SetStateActivity)
            {
                var activity = current as SetStateActivity;
                builder.AppendFormat("This activity sets the next state of the workflow to {0}", activity.TargetStateName).AppendLine();
            }
            //else if (current is EventDrivenActivity)
            //{

            //}
            else if (current is PolicyActivity)
            {
                var activity = current as PolicyActivity;
                builder.AppendLine(RuleTranslator.ConvertRuleSetReference(activity.RuleSetReference, ruleDefinitions));
            }
            else
            {
                Log.Debug("Not supported: " + current.GetType());
            }

            return(builder.ToString().TrimEnd(Environment.NewLine.ToCharArray()));
        }