private static K2Field CreateK2Field <TValueType>(K2FieldPart fieldPart)
        {
            K2Field field = new K2Field(fieldPart);

            field.ValueType = typeof(TValueType);
            return(field);
        }
Example #2
0
        private K2FieldPart Simplify(K2FieldPart fieldPart)
        {
            if (!(fieldPart is K2Field))
            {
                return(fieldPart);
            }

            K2Field field = (K2Field)fieldPart;

            while (field.Parts.Count > 0)
            {
                if (field.Parts.Count != 1)
                {
                    return(fieldPart);
                }
                if (field.Parts[0] is K2Field)
                {
                    field = (K2Field)field.Parts[0];
                }
                else
                {
                    return(field.Parts[0]);
                }
            }

            return(field);
        }
 bool addingFieldPart_CheckRead(object sender, K2FieldPart part)
 {
     if (part.CanRead)
     {
         return(true);
     }
     return(false);
 }
 bool addingFieldPart_CheckWrite(object sender, K2FieldPart part)
 {
     if (part.CanWrite)
     {
         return(true);
     }
     return(false);
 }
 bool addingFieldPart_CheckRead(object sender, K2FieldPart part)
 {
     if (part.CanRead)
     {
         return true;
     }
     return false;
 }
 bool addingFieldPart_CheckWrite(object sender, K2FieldPart part)
 {
     if (part.CanWrite)
     {
         return true;
     }
     return false;
 }
Example #7
0
        private CodeTypeMember GenerateInputMapMethod(VariableItem item, PowerShellEventItem powerShellEventItem, int mapNr)
        {
            CodeMemberMethod method = new CodeMemberMethod();

            CodeParameterDeclarationExpression rsParam = new CodeParameterDeclarationExpression(new CodeTypeReference("System.Management.Automation.Runspaces.Runspace"), "rs");
            CodeParameterDeclarationExpression k2Param = new CodeParameterDeclarationExpression(new CodeTypeReference("$contexttype$"), "K2");

            method.Name       = "InputMap" + mapNr.ToString();
            method.ReturnType = new CodeTypeReference(typeof(void));
            method.Parameters.Add(k2Param);
            method.Parameters.Add(rsParam);



            // Some variables we need
            CodeVariableReferenceExpression k2Field = new CodeVariableReferenceExpression("K2");


            //Declare a object variable
            CodeVariableDeclarationStatement varValueDecl = new CodeVariableDeclarationStatement(typeof(object), "variableValue");
            CodeVariableReferenceExpression  varValueRef  = new CodeVariableReferenceExpression("variableValue");

            method.Statements.Add(varValueDecl);



            //TODO: use getsimplfy function? Check why that is there?
            K2FieldPart part = Simplify(item.VariableValue);
            string      data = ((IRuntimeDataProvider)part).GetGetRuntimeData();

            // This creates a 'getvalue' method
            CodeFieldReferenceExpression resolverManagerProperty = new CodeFieldReferenceExpression(k2Field, "ResolverManager");
            CodeMethodInvokeExpression   getValue = new CodeMethodInvokeExpression(
                resolverManagerProperty,
                "GetValue",
                new CodeExpression[] { new CodePrimitiveExpression(data) }
                );

            // Assign the getValue to a variable.
            CodeAssignStatement assignCurrentValue = new CodeAssignStatement();

            assignCurrentValue.Right = getValue;
            assignCurrentValue.Left  = varValueRef;
            method.Statements.Add(assignCurrentValue);

            method.Statements.Add(new CodeSnippetStatement("  if (variableValue != null) {"));
            method.Statements.Add(new CodeSnippetStatement(string.Format("rs.SessionStateProxy.SetVariable(\"{0}\", variableValue);", item.Name)));
            method.Statements.Add(new CodeSnippetStatement("  }"));


            return(method);
        }
        public static K2Field CreateK2FieldFormat(string format, params object[] args)
        {
            K2Field field = new K2Field();

            field.ValueType = typeof(string);

            if (args.Length == 0)
            {
                field.Value = format;
                return(field);
            }

            int state = 0;

            StringBuilder buffer = new StringBuilder();

            foreach (char c in format)
            {
                switch (c)
                {
                case '{':
                    if (state != 0)
                    {
                        throw new FormatException("Input string was not in a correct format.");
                    }
                    state = 1;
                    break;

                case '}':
                    if (state != 2)
                    {
                        throw new FormatException("Input string was not in a correct format.");
                    }
                    state = 3;
                    break;
                }

                switch (state)
                {
                case 0:     // normal
                    buffer.Append(c);
                    break;

                case 1:     // begin indexer
                    if (buffer.Length > 0)
                    {
                        if (field.Parts.Count > 0 && field.Parts[field.Parts.Count - 1] is ValueTypePart)
                        {
                            field.Parts[field.Parts.Count - 1].Value = string.Concat(field.Parts[field.Parts.Count - 1].Value, buffer.ToString());
                        }
                        else
                        {
                            field.Parts.Add(new ValueTypePart(buffer.ToString()));
                        }
                    }
                    buffer = new StringBuilder();
                    state  = 2;
                    break;

                case 2:     // inside indexer
                    buffer.Append(c);
                    break;

                case 3:     // end indexer
                    int idx = int.Parse(buffer.ToString());

                    if (args[idx] == null)
                    {
                        throw new InvalidOperationException("One of the arguments have a null value.");
                    }

                    K2FieldPart partToAdd = null;

                    if (args[idx].GetType().IsValueType)
                    {
                        partToAdd = new ValueTypePart(args[idx].ToString());
                    }
                    else if (args[idx] is K2FieldPart)
                    {
                        partToAdd = args[idx] as K2FieldPart;
                    }
                    else if (args[idx] is string)
                    {
                        partToAdd = new ValueTypePart(args[idx] as string);
                    }
                    else
                    {
                        throw new InvalidOperationException("One of the arguments have is an unsupported type.");
                    }

                    if (field.Parts.Count >= 1 && partToAdd is ValueTypePart)
                    {
                        // If the previous field part is also a value type part
                        // merge the values
                        if (field.Parts[field.Parts.Count - 1] is ValueTypePart)
                        {
                            field.Parts[field.Parts.Count - 1].Value = string.Concat(field.Parts[field.Parts.Count - 1].Value, partToAdd.Value);
                        }
                    }
                    else
                    {
                        field.Parts.Add(partToAdd);
                    }

                    buffer = new StringBuilder();
                    state  = 0;
                    break;
                }
            }

            // process last part of the buffer
            if (buffer.Length > 0)
            {
                if (field.Parts.Count == 0)
                {
                    field.Parts.Add(new ValueTypePart(buffer.ToString()));
                }
                else if (field.Parts[field.Parts.Count - 1] is ValueTypePart)
                {
                    field.Parts[field.Parts.Count - 1].Value = string.Concat(field.Parts[field.Parts.Count - 1].Value, buffer.ToString());
                }
                else
                {
                    field.Parts.Add(new ValueTypePart(buffer.ToString()));
                }
            }

            return(field);
        }
Example #9
0
        private CodeTypeMember GenerateOutputMapMethod(VariableItem item, PowerShellEventItem powerShellEventItem, int mapNr)
        {
            CodeMemberMethod method = new CodeMemberMethod();

            CodeParameterDeclarationExpression rsParam = new CodeParameterDeclarationExpression(new CodeTypeReference("System.Management.Automation.Runspaces.Runspace"), "rs");
            CodeParameterDeclarationExpression k2Param = new CodeParameterDeclarationExpression(new CodeTypeReference("$contexttype$"), "K2");

            method.Name       = "OutputMap" + mapNr.ToString();
            method.ReturnType = new CodeTypeReference(typeof(void));
            method.Parameters.Add(k2Param);
            method.Parameters.Add(rsParam);



            method.Statements.Add(new CodeSnippetStatement(string.Format("object psVariable = rs.SessionStateProxy.GetVariable(\"{0}\");", item.Name)));
            method.Statements.Add(new CodeSnippetStatement("if (psVariable != null) {"));

            //TODO: use getsimplfy function? Check why that is there?
            K2FieldPart part = item.VariableValue.Parts[0];
            string      data = ((IRuntimeDataProvider)part).GetGetRuntimeData();


            // Some variables we need
            CodeVariableReferenceExpression k2Field    = new CodeVariableReferenceExpression("K2");
            CodeVariableReferenceExpression psVariable = new CodeVariableReferenceExpression("psVariable");


            // new object variable
            CodeVariableDeclarationStatement destVariableDeclaration = new CodeVariableDeclarationStatement(typeof(object), "destinationValue");

            method.Statements.Add(destVariableDeclaration);

            CodeVariableReferenceExpression destVariable = new CodeVariableReferenceExpression("destinationValue");


            // This creates a 'getvalue' method
            CodeFieldReferenceExpression resolverManagerProperty = new CodeFieldReferenceExpression(k2Field, "ResolverManager");
            CodeMethodInvokeExpression   getValue = new CodeMethodInvokeExpression(
                resolverManagerProperty,
                "GetValue",
                new CodeExpression[] { new CodePrimitiveExpression(data) }
                );


            // Assign the getValue to a variable.
            CodeAssignStatement assignCurrentValue = new CodeAssignStatement();

            assignCurrentValue.Right = getValue;
            assignCurrentValue.Left  = destVariable;
            method.Statements.Add(assignCurrentValue);

            //TODO: convert to statements
            method.Statements.Add(new CodeSnippetStatement("  if (psVariable.GetType() != destinationValue.GetType()) {"));
            method.Statements.Add(new CodeSnippetStatement("    K2.ProcessInstance.Logger.LogDebugMessage(\"PowerShellWizard\", \"Source and destination type of PowerShell Variable " + item.Name + " do not match. Doing conversion.\");"));


            // Do the system.Convert.ChangeType method.
            CodeTypeReferenceExpression systemConvert    = new CodeTypeReferenceExpression("System.Convert");
            CodeMethodInvokeExpression  changeTypeInvoke = new CodeMethodInvokeExpression(
                systemConvert,
                "ChangeType",
                new CodeExpression[] {
                psVariable,
                new CodeMethodInvokeExpression(destVariable, "GetType")
            });

            CodeAssignStatement convertAssign = new CodeAssignStatement();

            convertAssign.Left  = psVariable;
            convertAssign.Right = changeTypeInvoke;
            method.Statements.Add(convertAssign);


            //TODO: convert to statements
            method.Statements.Add(new CodeSnippetStatement("    if (psVariable == null) {"));
            method.Statements.Add(new CodeSnippetStatement("      throw new System.Exception(\"Conversion of variable '" + item.Name + "' failed. Please make sure the types are the same.\");"));
            method.Statements.Add(new CodeSnippetStatement("    }"));



            method.Statements.Add(new CodeSnippetStatement("  }"));



            // Create a setValue on the ResolverManager
            CodeMethodInvokeExpression setValue = new CodeMethodInvokeExpression(
                resolverManagerProperty,
                "SetValue",
                new CodeExpression[] {
                new CodePrimitiveExpression(data),
                psVariable
            });

            method.Statements.Add(setValue);

            // Commit the resolverManager
            CodeMethodInvokeExpression commit = new CodeMethodInvokeExpression(
                resolverManagerProperty,
                "Commit"
                );

            method.Statements.Add(commit);

            method.Statements.Add(new CodeSnippetStatement("}"));

            return(method);
        }