public override bool Equals(Object obj)
{
if (obj.GetType() != typeof(XmlRpcStruct))
{
return(false);
}
XmlRpcStruct xmlRpcStruct = (XmlRpcStruct)obj;
if (this.Keys.Count != xmlRpcStruct.Count)
{
return(false);
}
foreach (String key in this.Keys)
{
if (!xmlRpcStruct.ContainsKey(key))
{
return(false);
}
if (!this[key].Equals(xmlRpcStruct[key]))
{
return(false);
}
}
return(true);
}
protected object MapHashtable(
IEnumerator <Node> iter,
MappingStack mappingStack,
MappingAction mappingAction,
out Type mappedType)
{
mappedType = null;
var retObj = new XmlRpcStruct();
mappingStack.Push("struct mapped to XmlRpcStruct");
try {
while (iter.MoveNext() && iter.Current is StructMember)
{
var rpcName = ((StructMember)iter.Current).Value;
if (retObj.ContainsKey(rpcName) && !IgnoreDuplicateMembers)
{
throw new XmlRpcInvalidXmlRpcException(
mappingStack.MappingType + " contains struct value with duplicate member " + rpcName + " "
+ StackDump(mappingStack));
}
iter.MoveNext();
var value = OnStack(
string.Format("member {0}", rpcName),
mappingStack,
() => MapValueNode(iter, null, mappingStack, mappingAction));
if (!retObj.ContainsKey(rpcName))
{
retObj[rpcName] = value;
}
}
}
finally {
mappingStack.Pop();
}
return(retObj);
}
/// <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;
}
/// <summary>
/// robust convert to int. can take int strings as well as ints
/// </summary>
/// <param name="data"></param>
/// <param name="name"></param>
/// <returns></returns>
internal int toInt(XmlRpcStruct data, string name)
{
if (data.ContainsKey(name))
{
int n;
object val = data[name];
if (val is string)
{
bool good = int.TryParse((string)val, out n);
if (good)
return n;
}
else if (val is int)
return (int)(val);
}
return 0;
}
private TLErrorMessage decodeSingleError(XmlRpcStruct message)
{
if (message.ContainsKey("code") && message.ContainsKey("message"))
return new TLErrorMessage(message);
else
return null;
}
public Metadata(XmlRpcStruct md)
{
if (md.ContainsKey("Artist"))
Artist = (string)md["Artist"];
if (md.ContainsKey("Album"))
Album = (string)md["Album"];
if (md.ContainsKey("Title"))
Track = (string)md["Title"];
if (md.ContainsKey("Uri"))
Uri = (string)md["Uri"];
if (md.ContainsKey("AlbumArtUri"))
AlbumArtUri = (string)md["AlbumArtUri"];
if (md.ContainsKey("PlayTime"))
PlayTime = (int)md["PlayTime"];
}
public Event(XmlRpcStruct x)
{
if (x.ContainsKey("Name"))
Name = (string)x["Name"];
Args = new List<object>();
if (x.ContainsKey("Args"))
{
object o = x["Args"];
object[] array = (object[])o;
Args.AddRange(array);
}
}
/// <summary>
/// parse an execution status
/// </summary>
/// <param name="data"></param>
/// <param name="name"></param>
/// <returns></returns>
internal TestCaseResultStatus toExecStatus(XmlRpcStruct data, string name)
{
TestCaseResultStatus result = TestCaseResultStatus.undefined;
if (data.ContainsKey(name))
{
char c = toChar(data, name);
switch (c)
{
case 'f':
case 'F': result = TestCaseResultStatus.Fail;
break;
case 'b':
case 'B': result = TestCaseResultStatus.Blocked;
break;
case 'p':
case 'P': result = TestCaseResultStatus.Pass;
break;
}
}
return result;
}
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;
}
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"];
}
/// <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';
}
/// <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;
}
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);
}
}
/// <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" ];
}
public static object AttemptStructDeserialization(XmlRpcStruct response, Type output)
{
MemberInfo[] outputMembers = output.GetMembers();
object result = Activator.CreateInstance(output);
PropertyInfo[] properties = output.GetProperties();
foreach(PropertyInfo property in properties)
{
Console.WriteLine (property.Name);
if(response.ContainsKey (property.Name))
{
Console.WriteLine("Declaring type:{0}, output type:{1}", property.PropertyType, response[property.Name].GetType());
if(Type.Equals(property.PropertyType, response[property.Name].GetType()))
{
Console.WriteLine ("Identical Type! Woot! Value is " + response[property.Name]);
property.SetValue(result, response[property.Name], null);
}
}
}
return result;
}
private static Post StructToPost(Post p, XmlRpcStruct x, bool publish)
{
/*
* 1. struct {
2. string postid;
3. DateTime dateCreated;
4. string title;
5. string description;
6. string[] categories;
7. bool publish;
8. }
*/
if (p == null)
{
p = new Post();
p.Id = x.ContainsKey("postid") ? Convert.ToInt32(x["postid"]) : 0;
}
p.Approved = publish;
p.Body = x["description"].ToString();
p.Title = x["title"].ToString();
if (x.ContainsKey("categories"))
{
IEnumerable categories = x["categories"] as IEnumerable;
if (categories != null)
{
foreach(object category in categories)
{
if (category != null)
{
Tag tag = new Tag { TagName = category.ToString() };
p.AddTag(tag);
}
}
}
}
return p;
}
