Beispiel #1
0
        public static DedimaniaPlayerArriveReply Parse(object multiCallResultElement)
        {
            if (multiCallResultElement == null || !multiCallResultElement.GetType().IsArray)
            {
                return(null);
            }

            object[] rootElements = (object[])multiCallResultElement;
            if (rootElements.Length != 1 || rootElements[0].GetType() != typeof(XmlRpcStruct))
            {
                return(null);
            }

            XmlRpcStruct replyStruct = (XmlRpcStruct)rootElements[0];

            if (!replyStruct.ContainsKey("Options") || !replyStruct.ContainsKey("Nation") || !replyStruct.ContainsKey("TeamName") || !replyStruct.ContainsKey("Login") || !replyStruct.ContainsKey("Aliases"))
            {
                return(null);
            }

            DedimaniaPlayerArriveReply result = new DedimaniaPlayerArriveReply();

            result.Aliases  = new List <AliasTextTool>();
            result.Options  = new List <OptionValueTool>();
            result.Login    = Convert.ToString(replyStruct["Login"]);
            result.TeamName = Convert.ToString(replyStruct["TeamName"]);
            result.Nation   = Convert.ToString(replyStruct["Nation"]);

            return(result);
        }
Beispiel #2
0
        internal static TestPlanTotal ToTestPlanTotal(XmlRpcStruct data)
        {
            var item = new TestPlanTotal();

            item.Total_tc = ToInt(data, "total_tc");
            if (data.ContainsKey("type"))
            {
                item.Type = (string)data["type"];
            }
            if (data.ContainsKey("name"))
            {
                item.Name = (string)data["name"];
            }

            var xdetails = data["details"] as XmlRpcStruct;

            foreach (string key in xdetails.Keys)
            {
                var val = xdetails[key] as XmlRpcStruct;
                var qty = ToInt(val, "qty");
                item.Details.Add(key, qty);
            }

            return(item);
        }
Beispiel #3
0
        public static DedimaniaWarningsAndTTRReply Parse(object multiCallResultElement)
        {
            if (multiCallResultElement == null || !multiCallResultElement.GetType().IsArray)
            {
                return(null);
            }

            object[] rootObjects = (object[])multiCallResultElement;
            if (rootObjects.Length == 0 || rootObjects[0].GetType() != typeof(XmlRpcStruct))
            {
                return(null);
            }

            XmlRpcStruct rootStruct = (XmlRpcStruct)rootObjects[0];

            if (!rootStruct.ContainsKey("globalTTR") || !rootStruct.ContainsKey("methods") || !rootStruct["methods"].GetType().IsArray)
            {
                return(null);
            }

            DedimaniaWarningsAndTTRReply result = new DedimaniaWarningsAndTTRReply();

            result.GlobalTTR = Convert.ToDouble(rootStruct["globalTTR"], new CultureInfo("en-us"));

            List <DedimaniaWarningsAndTTRElement> warnings = new List <DedimaniaWarningsAndTTRElement>();

            foreach (object warningElement in (IEnumerable)rootStruct["methods"])
            {
                warnings.Add(DedimaniaWarningsAndTTRElement.Parse(warningElement));
            }

            result.Methods = warnings.ToArray();

            return(result);
        }
        public bool Ping(string name, string url)
        {
            bool result = false;

            try
            {
                XmlRpcStruct rpcstruct = Notify(name, url);
                if (rpcstruct.ContainsKey("flerror"))
                {
                    //Weblogs.com return false if there is no error
                    //I want to return true, indicating a successful notification
                    result = !(bool)rpcstruct["flerror"];
                    if (!result)
                    {
                        if (rpcstruct.ContainsKey("message"))
                        {
                            _errorMessage = (string)rpcstruct["message"];
                        }
                        else
                        {
                            _errorMessage = "Unknown Error";
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Warn("Error while Ping: " + ex.Message);
                _errorMessage = "Error: " + ex.Message;
            }
            return(result);
        }
        public void StructProperties()
        {
            string xml = @"<?xml version=""1.0""?>
<methodCall>
  <methodName>Foo</methodName>
  <params>
    <param>
      <value>
        <struct>
          <member>
            <name>member1</name>
            <value>
              <i4>1</i4>
            </value>
          </member>
          <member>
            <name>member2</name>
            <value>
              <i4>2</i4>
            </value>
          </member>
          <member>
            <name>member-3</name>
            <value>
              <i4>3</i4>
            </value>
          </member>
          <member>
            <name>member-4</name>
            <value>
              <i4>4</i4>
            </value>
          </member>
        </struct>
      </value>
    </param>
  </params>
</methodCall>";

            StringReader sr = new StringReader(xml);
            XmlRpcSerializer serializer = new XmlRpcSerializer();
            XmlRpcRequest request = serializer.DeserializeRequest(sr, null);

            Assert.AreEqual(request.args[0].GetType(), typeof(XmlRpcStruct),
              "argument is XmlRpcStruct");
            XmlRpcStruct xrs = (XmlRpcStruct)request.args[0];
            Assert.IsTrue(xrs.Count == 4, "XmlRpcStruct has 4 members");
            Assert.IsTrue(xrs.ContainsKey("member1") && (int)xrs["member1"] == 1,
              "member1");
            Assert.IsTrue(xrs.ContainsKey("member2") && (int)xrs["member2"] == 2,
              "member2");
            Assert.IsTrue(xrs.ContainsKey("member-3") && (int)xrs["member-3"] == 3,
              "member-3");
            Assert.IsTrue(xrs.ContainsKey("member-4") && (int)xrs["member-4"] == 4,
              "member-4");



        }
Beispiel #6
0
        public void NormalFailure()
        {
            XmlRpcStruct result = _client.run_keyword("NormalFail", new object[0]);

            //check continuable or fatal are not set
            Assert.IsFalse(result.ContainsKey("fatal"));
            Assert.IsFalse(result.ContainsKey("continuable"));
        }
Beispiel #7
0
        public void returnstructure()
        {
            XmlRpcStruct result = _client.run_keyword("exec noerror", new object[0]);

            Assert.IsTrue(result.ContainsKey("return"));
            Assert.IsTrue(result.ContainsKey("status"));
            Assert.IsTrue(result.ContainsKey("error"));
            Assert.IsTrue(result.ContainsKey("traceback"));
            Assert.IsTrue(result.ContainsKey("output"));
        }
Beispiel #8
0
        public void FatalFailure()
        {
            XmlRpcStruct result = _client.run_keyword("FatalFail", new object[0]);

            //check no continuable element
            Assert.IsFalse(result.ContainsKey("continuable"));
            //check there is a fatal element
            Assert.IsTrue(result.ContainsKey("fatal"));
            //check fatal is true
            Assert.IsTrue(Convert.ToBoolean(result["fatal"]));
        }
Beispiel #9
0
 internal TestCaseFromTestSuite(XmlRpcStruct data)
 {
     active       = int.Parse((string)data["active"]) == 1;
     id           = toInt(data, "id");
     name         = (string)data["name"];
     version      = toInt(data, "version");
     tcversion_id = toInt(data, "tcversion_id");
     //steps = (string)data["steps"];
     //expected_results = (string)data["expected_results"];
     external_id     = (string)data["tc_external_id"];
     testSuite_id    = toInt(data, "parent_id");
     is_open         = int.Parse((string)data["is_open"]) == 1;
     modification_ts = base.toDate(data, "modification_ts");
     updater_id      = toInt(data, "updater_id");
     execution_type  = toInt(data, "execution_type");
     summary         = (string)data["summary"];
     if (data.ContainsKey("details"))
     {
         details = (string)data["details"];
     }
     else
     {
         details = "";
     }
     author_id     = toInt(data, "author_id");
     creation_ts   = base.toDate(data, "creation_ts");
     importance    = toInt(data, "importance");
     parent_id     = toInt(data, "parent_id");
     node_type_id  = toInt(data, "node_type_id");
     node_order    = toInt(data, "node_order");
     node_table    = (string)data["node_table"];
     layout        = (string)data["layout"];
     status        = toInt(data, "status");
     preconditions = (string)data["preconditions"];
 }
Beispiel #10
0
        //protected TestCaseResultStatus ToExecStatus(XmlRpcStruct data, string name)
        //{
        //    var result = TestCaseResultStatus.undefined;
        //    if (data.ContainsKey(name))
        //    {
        //        var c = ToChar(data, name);
        //        switch (c)
        //        {
        //            case 'f':
        //            case 'F':
        //                result = TestCaseResultStatus.Failed;
        //                break;
        //            case 'b':
        //            case 'B':
        //                result = TestCaseResultStatus.Blocked;
        //                break;
        //            case 'p':
        //            case 'P':
        //                result = TestCaseResultStatus.Passed;
        //                break;
        //        }
        //    }
        //    return result;
        //}

        protected static DateTime ToDate(XmlRpcStruct data, string name)
        {
            if (data.ContainsKey(name) && DateTime.TryParse((string)data[name], out var n))
            {
                return(n);
            }
            return(DateTime.MinValue);
        }
Beispiel #11
0
 /// <summary>
 /// convert a data value to a single char
 /// </summary>
 /// <param name="data"></param>
 /// <param name="name"></param>
 /// <returns></returns>
 internal char toChar(XmlRpcStruct data, string name)
 {
     if (data.ContainsKey(name) && (data[name] is string))
     {
         string s = (string)(data[name]);
         return(s[0]);
     }
     return('\x00');
 }
Beispiel #12
0
        public static FaultInfo Parse(object multiCallResultElement)
        {
            if (multiCallResultElement == null || multiCallResultElement.GetType() != typeof(XmlRpcStruct))
            {
                return(null);
            }

            XmlRpcStruct data = (XmlRpcStruct)multiCallResultElement;

            if (!data.ContainsKey("faultCode") || !data.ContainsKey("faultString"))
            {
                return(null);
            }

            return(new FaultInfo {
                FaultCode = Convert.ToString(data["faultCode"]), FaultString = Convert.ToString(data["faultString"])
            });
        }
Beispiel #13
0
        protected object MapHashtable(IEnumerator <Node> iter, Type valType, MappingStack mappingStack,
                                      MappingAction mappingAction, out Type mappedType)
        {
            mappedType = null;
            var xmlRpcStruct = new XmlRpcStruct();

            (mappingStack).Push("struct mapped to XmlRpcStruct");
            try
            {
                while (iter.MoveNext())
                {
                    if (iter.Current is StructMember)
                    {
                        string str = (iter.Current as StructMember).Value;
                        if (xmlRpcStruct.ContainsKey(str) && !IgnoreDuplicateMembers)
                        {
                            throw new XmlRpcInvalidXmlRpcException(mappingStack.MappingType +
                                                                   " contains struct value with duplicate member " + str +
                                                                   " " + StackDump(mappingStack));
                        }
                        else
                        {
                            iter.MoveNext();
                            object obj = OnStack(string.Format("member {0}", str), mappingStack,
                                                 (() => MapValueNode(iter, null, mappingStack, mappingAction)));
                            if (!xmlRpcStruct.ContainsKey(str))
                            {
                                xmlRpcStruct[str] = obj;
                            }
                        }
                    }
                    else
                    {
                        break;
                    }
                }
            }
            finally
            {
                mappingStack.Pop();
            }
            return(xmlRpcStruct);
        }
Beispiel #14
0
 private static void verifyKeys(XmlRpcStruct m, String[] keys)
 {
     foreach (String key in keys)
     {
         if (m.ContainsKey(key) == false)
         {
             throw new BoaException("Invalid response from server: response does not contain key '" + key + "'.");
         }
     }
 }
Beispiel #15
0
        protected static char ToChar(XmlRpcStruct data, string name)
        {
            if (data.ContainsKey(name) && data[name] is string)
            {
                var s = (string)data[name];
                return(s[0]);
            }

            return('\x00');
        }
Beispiel #16
0
        internal TestPlanTotal(XmlRpcStruct data)
        {
            Total_tc = toInt(data, "total_tc");
            if (data.ContainsKey("type"))
            {
                Type = (string)data["type"];
            }
            if (data.ContainsKey("name"))
            {
                Name = (string)data["name"];
            }

            XmlRpcStruct xdetails = data["details"] as XmlRpcStruct;

            foreach (string key in xdetails.Keys)
            {
                XmlRpcStruct val = xdetails[key] as XmlRpcStruct;
                int          qty = toInt(val, "qty");
                Details.Add(key, qty);
            }
        }
Beispiel #17
0
        public static DedimaniaWarningsAndTTRElement Parse(object multiCallResultElement)
        {
            if (multiCallResultElement == null || multiCallResultElement.GetType() != typeof(XmlRpcStruct))
            {
                return(null);
            }

            XmlRpcStruct warningsStruct = (XmlRpcStruct)multiCallResultElement;

            if (!warningsStruct.ContainsKey("errors") || !warningsStruct.ContainsKey("methodName") || !warningsStruct.ContainsKey("TTR"))
            {
                return(null);
            }

            return(new DedimaniaWarningsAndTTRElement
            {
                Error = Convert.ToString(warningsStruct["errors"]),
                MethodName = Convert.ToString(warningsStruct["methodName"]),
                TTR = Convert.ToDouble(warningsStruct["TTR"], new CultureInfo("en-us"))
            });
        }
Beispiel #18
0
        private IEnumerable <SearchResult> ParseResponse(XmlRpcStruct response)
        {
            var results = new List <SearchResult>();

            var ok = ParseStatus(response);

            if (ok && response.ContainsKey("data") && !(response["data"] is bool))
            {
                results.AddRange(ParseEntry(response["data"] as Array));
            }
            return(results);
        }
        /// <summary>
        /// 将rpc信息转换为种子信息名称
        /// </summary>
        /// <param name="rpcStruct"></param>
        /// <returns></returns>
        public static string ConvertToBittorrentInfoName(XmlRpcStruct rpcStruct)
        {
            List <string> keyList   = rpcStruct.Keys as List <string>;
            List <object> valueList = rpcStruct.Values as List <object>;

            if (rpcStruct.ContainsKey("name"))
            {
                string value = valueList[0] as string;
                return(value);
            }

            return(string.Empty);
        }
Beispiel #20
0
 /// <summary>
 ///  robust convert a date string
 /// </summary>
 /// <param name="data">key value dictionary</param>
 /// <param name="name">name of field to use</param>
 /// <returns></returns>
 internal DateTime toDate(XmlRpcStruct data, string name)
 {
     if (data.ContainsKey(name))
     {
         DateTime n;
         bool     good = DateTime.TryParse((string)data[name], out n);
         if (good)
         {
             return(n);
         }
     }
     return(DateTime.MinValue);
 }
Beispiel #21
0
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="output">The output from the server request.</param>
        protected Output(XmlRpcStruct output)
        {
            if (output.ContainsKey("status"))
            {
                this.StatusString = ( string )output["status"];
            }
            else
            {
                this.StatusString = "200 OK";
            }

            this.Status  = ConvertStatusToStatusCode(StatusString);
            this.Seconds = ( double )output["seconds"];
        }
Beispiel #22
0
 /// <summary>
 /// robust convert a data bit to a bool
 /// </summary>
 /// <param name="data"></param>
 /// <param name="name"></param>
 /// <returns></returns>
 internal bool?toBool(XmlRpcStruct data, string name)
 {
     if (data.ContainsKey(name))
     {
         object val = data[name];
         if (val is string)
         {
             bool result;
             bool good = bool.TryParse(val as string, out result);
             return(result);
         }
         return(data[name] as bool?);
     }
     return(null);
 }
Beispiel #23
0
        internal static TestCaseFromTestPlan ToTestCaseFromTestPlan(XmlRpcStruct data)
        {
            var item = new TestCaseFromTestPlan();

            if (data.ContainsKey("active"))
            {
                item.active = int.Parse((string)data["active"]) == 1;
            }
            item.name             = (string)data["name"];
            item.tsuite_name      = (string)data["tsuite_name"];
            item.z                = ToInt(data, "z");
            item.type             = (string)data["type"];
            item.execution_order  = ToInt(data, "execution_order");
            item.exec_id          = ToInt(data, "exec_id");
            item.tc_id            = ToInt(data, "tc_id");
            item.tcversion_number = ToInt(data, "tcversion_number");
            item.status           = (string)data["status"];
            item.external_id      = (string)data["external_id"];
            item.exec_status      = (string)data["exec_status"];
            item.exec_on_tplan    = ToInt(data, "exec_on_tplan");
            item.executed         = ToInt(data, "executed");
            item.feature_id       = ToInt(data, "feature_id");
            item.assigner_id      = ToInt(data, "assigner_id");
            item.user_id          = ToInt(data, "user_id");
            item.active           = ToInt(data, "active") == 1;
            item.version          = ToInt(data, "version");
            item.testsuite_id     = ToInt(data, "testsuite_id");
            item.tcversion_id     = ToInt(data, "tcversion_id");
            //steps = (string)data["steps"];
            //expected_results = (string)data["expected_results"];
            item.summary            = (string)data["summary"];
            item.execution_type     = ToInt(data, "execution_type");
            item.platform_id        = ToInt(data, "platform_id");
            item.platform_name      = (string)data["platform_name"];
            item.linked_ts          = ToDate(data, "linked_ts");
            item.linked_by          = ToInt(data, "linked_by");
            item.importance         = ToInt(data, "importance");
            item.execution_run_type = (string)data["execution_run_type"];
            item.execution_ts       = (string)data["execution_ts"];
            item.tester_id          = ToInt(data, "tester_id");
            item.execution_notes    = (string)data["execution_notes"];
            item.exec_on_build      = ToInt(data, "exec_on_build");
            item.assigned_build_id  = ToInt(data, "assigned_build_id");
            item.urgency            = ToInt(data, "urgency");
            item.priority           = ToInt(data, "priority");

            return(item);
        }
Beispiel #24
0
        protected static bool?ToBool(XmlRpcStruct data, string name)
        {
            if (data.ContainsKey(name))
            {
                var val = data[name];
                if (val is string)
                {
                    bool.TryParse(val as string, out var result);
                    return(result);
                }

                return(data[name] as bool?);
            }

            return(null);
        }
Beispiel #25
0
 internal GeneralResult(XmlRpcStruct data)
 {
     operation = (string)data["operation"];
     status    = (bool)(data["status"]);
     id        = toInt(data, "id");
     message   = (string)data["message"];
     if ((data.ContainsKey("additionalInfo") &&
          (data["additionalInfo"] is XmlRpcStruct)))
     {
         additionalInfo = new AdditionalInfo(data["additionalInfo"] as XmlRpcStruct);
     }
     else
     {
         additionalInfo = null;
     }
 }
        public static T MapToObject <T>(XmlRpcStruct obj) where T : class
        {
            T instance = Activator.CreateInstance <T>();

            var destinationType = typeof(T);
            var members         = destinationType.GetFields();

            foreach (var member in members)
            {
                if (obj.ContainsKey(member.Name))
                {
                    member.SetValue(instance, obj[member.Name]);
                }
            }

            return(instance);
        }
        public static T ToObject <T>(this XmlRpcStruct source)
            where T : class, new()
        {
            try
            {
                T    someObject     = new T();
                Type someObjectType = someObject.GetType();

                foreach (var propertyInfo in someObjectType.GetProperties())
                {
                    var xmlRpcAtt = propertyInfo.CustomAttributes.SingleOrDefault(att => att.AttributeType == typeof(CookComputing.XmlRpc.XmlRpcMemberAttribute));
                    if (xmlRpcAtt == null || !xmlRpcAtt.ConstructorArguments.Any())
                    {
                        continue;
                    }

                    string xmlRpcAttName = xmlRpcAtt.ConstructorArguments[0].Value.ToString();
                    if (!source.ContainsKey(xmlRpcAttName))
                    {
                        continue;
                    }

                    var childStruct = source[xmlRpcAttName] as XmlRpcStruct;
                    if (childStruct != null)
                    {
                        var method         = typeof(ParsingExtensions).GetMethod("ToObject");
                        var genericMethod  = method.MakeGenericMethod(propertyInfo.PropertyType);
                        var convertedChild = genericMethod.Invoke(null, new object[] { childStruct });

                        propertyInfo.SetValue(someObject, convertedChild, null);
                    }
                    else
                    {
                        propertyInfo.SetValue(someObject, source[xmlRpcAttName], null);
                    }
                }

                return(someObject);
            }
            catch (Exception)
            {
                return(null);
            }
        }
Beispiel #28
0
        public static DedimaniaChallengeRaceTimesReply Parse(object multiCallResultElement)
        {
            if (multiCallResultElement == null || !multiCallResultElement.GetType().IsArray)
            {
                return(null);
            }

            object[] rootElements = (object[])multiCallResultElement;
            if (rootElements.Length != 1 || rootElements[0].GetType() != typeof(XmlRpcStruct))
            {
                return(null);
            }

            XmlRpcStruct replyStruct = (XmlRpcStruct)rootElements[0];

            if (!replyStruct.ContainsKey("Uid") || !replyStruct.ContainsKey("TotalRaces") ||
                !replyStruct.ContainsKey("TotalPlayers") || !replyStruct.ContainsKey("TimeAttackRaces") ||
                !replyStruct.ContainsKey("TimeAttackPlayers") || !replyStruct.ContainsKey("TimeAttackPlayers") ||
                !replyStruct.ContainsKey("NumberOfChecks") || !replyStruct.ContainsKey("ServerMaxRecords") ||
                !replyStruct.ContainsKey("Records"))
            {
                return(null);
            }

            return(new DedimaniaChallengeRaceTimesReply
            {
                Uid = Convert.ToString(replyStruct["Uid"]),
                TotalRaces = Convert.ToInt32(replyStruct["TotalRaces"]),
                TotalPlayers = Convert.ToInt32(replyStruct["TotalPlayers"]),
                TimeAttackRaces = Convert.ToInt32(replyStruct["TimeAttackRaces"]),
                TimeAttackPlayers = Convert.ToInt32(replyStruct["TimeAttackPlayers"]),
                NumberOfChecks = Convert.ToInt32(replyStruct["NumberOfChecks"]),
                ServerMaxRecords = Convert.ToInt32(replyStruct["ServerMaxRecords"]),
                Records = ParseRecords(replyStruct["Records"])
            });
        }
Beispiel #29
0
        public static T Cast <T>(this object input, Type t = null)
        {
            if (input == null)
            {
                return(default(T));
            }

            Type target = typeof(T);

            if (target == typeof(object) && t != null)
            {
                target = t;
            }

            var result = Activator.CreateInstance(target, false);

            XmlRpcStruct st = (XmlRpcStruct)input;

            var d = from source in target.GetMembers().ToList()
                    where source.MemberType == MemberTypes.Property
                    select source;

            PropertyInfo propertyInfo;

            foreach (MemberInfo memberInfo in d.ToList())
            {
                if (st.ContainsKey(memberInfo.Name))
                {
                    propertyInfo = target.GetProperty(memberInfo.Name);
                    object val = st[memberInfo.Name];
                    if (st[memberInfo.Name].GetType() == typeof(XmlRpcStruct))
                    {
                        //if ( == typeof(Person))
                        val = Cast <object>(val, propertyInfo.PropertyType);
                    }

                    propertyInfo.SetValue(result, val, null);
                }
            }

            return((T)result);
        }
Beispiel #30
0
        internal static GeneralResult ToGeneralResult(XmlRpcStruct data)
        {
            var item = new GeneralResult();

            item.operation = (string)data["operation"];
            item.status    = (bool)data["status"];
            item.id        = ToInt(data, "id");
            item.message   = (string)data["message"];
            if (data.ContainsKey("additionalInfo") &&
                data["additionalInfo"] is XmlRpcStruct)
            {
                item.additionalInfo = ToAdditionalInfo(data["additionalInfo"] as XmlRpcStruct);
            }
            else
            {
                item.additionalInfo = null;
            }

            return(item);
        }