| public ReadElementContentAsDateTime ( ) : System.DateTime | ||
| return | System.DateTime | |
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <param name="preApproval"></param>
internal static void Read(XmlReader reader, PreApprovalSummary preApproval)
{
if (reader.IsEmptyElement)
{
XMLParserUtils.SkipNode(reader);
return;
}
reader.ReadStartElement(SerializerHelper.PreApproval);
reader.MoveToContent();
while (!reader.EOF)
{
if (XMLParserUtils.IsEndElement(reader, SerializerHelper.PreApproval))
{
XMLParserUtils.SkipNode(reader);
break;
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case SerializerHelper.Code:
preApproval.Code = reader.ReadElementContentAsString();
break;
case SerializerHelper.Date:
preApproval.Date = reader.ReadElementContentAsDateTime();
break;
case SerializerHelper.Reference:
preApproval.Reference = reader.ReadElementContentAsString();
break;
case SerializerHelper.TransactionStatus:
preApproval.Status = reader.ReadElementContentAsString();
break;
case SerializerHelper.LastEventDate:
preApproval.LastEventDate = reader.ReadElementContentAsDateTime();
break;
case SerializerHelper.Name:
preApproval.Name = reader.ReadElementContentAsString();
break;
case SerializerHelper.Tracker:
preApproval.Tracker = reader.ReadElementContentAsString();
break;
case SerializerHelper.Charge:
preApproval.Charge = reader.ReadElementContentAsString();
break;
default:
XMLParserUtils.SkipElement(reader);
break;
}
}
else
{
XMLParserUtils.SkipNode(reader);
}
}
}
internal Communication(XmlReader rdr)
{
rdr.ReadStartElement("communication");
this.Id = rdr.ReadElementContentAsInt("id", "");
this.Subject = rdr.ReadElementString("subject");
this.Body = rdr.ReadElementString("body");
this.Date = rdr.ReadElementContentAsDateTime("date", "ctype");
this.Ctype = rdr.ReadElementString("");
this.Tags = Tag.BuildList(rdr);
this.Comments = MegaComment.BuildList(rdr);
this.CreateAt = rdr.ReadElementContentAsDateTime("created_at", "");
this.UpdatedAt = rdr.ReadElementContentAsDateTime("updated_at", "");
rdr.ReadEndElement();
}
private DateTime ReadNextTdAsDate(XmlReader reader)
{
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name.ToLower() == "td")
{
return reader.ReadElementContentAsDateTime();
}
}
return DateTime.MinValue;
}
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <param name="result">PagSeguro AuthorizationSummary</param>
internal static void Read(XmlReader reader, AuthorizationSummary result)
{
if (reader.IsEmptyElement)
{
XMLParserUtils.SkipNode(reader);
return;
}
reader.ReadStartElement(SerializerHelper.Authorization);
reader.MoveToContent();
while (!reader.EOF)
{
if (XMLParserUtils.IsEndElement(reader, SerializerHelper.Authorization))
{
XMLParserUtils.SkipNode(reader);
break;
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case SerializerHelper.Code:
result.Code = reader.ReadElementContentAsString();
break;
case SerializerHelper.CreationDate:
result.CreationDate = reader.ReadElementContentAsDateTime();
break;
case SerializerHelper.Reference:
result.Reference = reader.ReadElementContentAsString();
break;
case SerializerHelper.Account:
AuthorizationAccountSerializer.Read(reader, result);
break;
case SerializerHelper.Permissions:
AuthorizationPermissionListSerializer.Read(reader, result.Permissions);
break;
default:
XMLParserUtils.SkipElement(reader);
break;
}
}
else
{
XMLParserUtils.SkipNode(reader);
}
}
}
internal static void Read(XmlReader reader, TransactionSearchResult result)
{
if (reader == null)
throw new ArgumentNullException("reader");
if (result == null)
throw new ArgumentNullException("result");
if (reader.IsEmptyElement)
{
SerializationHelper.SkipNode(reader);
return;
}
reader.ReadStartElement(TransactionSearchResultSerializer.TransactionSearchResult);
reader.MoveToContent();
while (!reader.EOF)
{
if (SerializationHelper.IsEndElement(reader, TransactionSearchResultSerializer.TransactionSearchResult))
{
SerializationHelper.SkipNode(reader);
break;
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case TransactionSearchResultSerializer.Date:
result.Date = reader.ReadElementContentAsDateTime();
break;
case TransactionSearchResultSerializer.CurrentPage:
result.CurrentPage = reader.ReadElementContentAsInt();
break;
case TransactionSearchResultSerializer.TotalPages:
result.TotalPages = reader.ReadElementContentAsInt();
break;
case TransactionSummaryListSerializer.Transactions:
TransactionSummaryListSerializer.Read(reader, result.Items);
break;
default:
SerializationHelper.SkipElement(reader);
break;
}
}
else
{
SerializationHelper.SkipNode(reader);
}
}
}
internal Bucket(XmlReader reader)
{
if (reader.IsEmptyElement)
throw new Exception("Expected a non-empty <Bucket> element.");
// Example:
// <Bucket>
// <Name>quotes;/Name>
// <CreationDate>2006-02-03T16:45:09.000Z</CreationDate>
// </Bucket>
reader.ReadStartElement("Bucket");
this.Name = reader.ReadElementContentAsString("Name", "");
this.CreationDate = reader.ReadElementContentAsDateTime("CreationDate", "");
reader.ReadEndElement();
}
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <param name="result"></param>
internal static void Read(XmlReader reader, PreApprovalSearchResult result)
{
if (reader.IsEmptyElement)
{
XMLParserUtils.SkipNode(reader);
return;
}
reader.ReadStartElement(PreApprovalSearchResultSerializer.PreApprovalSearchResult);
reader.MoveToContent();
while (!reader.EOF)
{
if (XMLParserUtils.IsEndElement(reader, PreApprovalSearchResultSerializer.PreApprovalSearchResult))
{
XMLParserUtils.SkipNode(reader);
break;
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case PreApprovalSearchResultSerializer.Date:
result.Date = reader.ReadElementContentAsDateTime();
break;
case PreApprovalSearchResultSerializer.CurrentPage:
result.CurrentPage = reader.ReadElementContentAsInt();
break;
case PreApprovalSearchResultSerializer.TotalPages:
result.TotalPages = reader.ReadElementContentAsInt();
break;
case PreApprovalSummaryListSerializer.PreApprovals:
PreApprovalSummaryListSerializer.Read(reader, result.PreApprovals);
break;
default:
XMLParserUtils.SkipElement(reader);
break;
}
}
else
{
XMLParserUtils.SkipNode(reader);
}
}
}
internal static void Read(XmlReader reader, PaymentRequestResponse paymentResponse)
{
if (reader == null)
throw new ArgumentNullException("reader");
if (paymentResponse == null)
throw new ArgumentNullException("paymentResponse");
if (reader.IsEmptyElement)
{
SerializationHelper.SkipNode(reader);
return;
}
string rootElement = reader.Name;
reader.ReadStartElement();
reader.MoveToContent();
while (!reader.EOF)
{
if (SerializationHelper.IsEndElement(reader, rootElement))
{
SerializationHelper.SkipNode(reader);
break;
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case PaymentRequestResponseSerializer.Date:
paymentResponse.RegistrationDate = reader.ReadElementContentAsDateTime();
break;
case PaymentRequestResponseSerializer.Code:
paymentResponse.Code = reader.ReadElementContentAsString();
break;
default:
SerializationHelper.SkipElement(reader);
break;
}
}
else
{
SerializationHelper.SkipNode(reader);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <param name="permission">PagSeguro AuthorizationPermissions</param>
internal static void Read(XmlReader reader, AuthorizationPermissions permission)
{
if (reader.IsEmptyElement)
{
XMLParserUtils.SkipNode(reader);
return;
}
reader.ReadStartElement(SerializerHelper.Permission);
reader.MoveToContent();
while (!reader.EOF)
{
if (XMLParserUtils.IsEndElement(reader, SerializerHelper.Permission))
{
XMLParserUtils.SkipNode(reader);
break;
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case SerializerHelper.Code:
permission.Code = reader.ReadElementContentAsString();
break;
case SerializerHelper.Status:
permission.Status = reader.ReadElementContentAsString();
break;
case SerializerHelper.LastUpdate:
permission.LastUpdate = reader.ReadElementContentAsDateTime();
break;
default:
XMLParserUtils.SkipElement(reader);
break;
}
}
else
{
XMLParserUtils.SkipNode(reader);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <param name="paymentResponse"></param>
internal static void Read(XmlReader reader, PaymentRequestResponse paymentResponse)
{
if (reader.IsEmptyElement)
{
XMLParserUtils.SkipNode(reader);
return;
}
string rootElement = reader.Name;
reader.ReadStartElement();
reader.MoveToContent();
while (!reader.EOF)
{
if (XMLParserUtils.IsEndElement(reader, rootElement))
{
XMLParserUtils.SkipNode(reader);
break;
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case PaymentSerializer.Date:
paymentResponse.RegistrationDate = reader.ReadElementContentAsDateTime();
break;
case PaymentSerializer.Code:
paymentResponse.Code = reader.ReadElementContentAsString();
break;
case PaymentSerializer.TransactionCode:
paymentResponse.TransactionCode = reader.ReadElementContentAsString();
break;
default:
XMLParserUtils.SkipElement(reader);
break;
}
}
else
{
XMLParserUtils.SkipNode(reader);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <param name="result">PagSeguro AuthorizationSearchResult</param>
internal static void Read(XmlReader reader, AuthorizationSearchResult result)
{
if (reader.IsEmptyElement)
{
XMLParserUtils.SkipNode(reader);
return;
}
reader.ReadStartElement(SerializerHelper.AuthorizationSearchResult);
reader.MoveToContent();
while (!reader.EOF)
{
if (XMLParserUtils.IsEndElement(reader, SerializerHelper.AuthorizationSearchResult))
{
XMLParserUtils.SkipNode(reader);
break;
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case SerializerHelper.Date:
result.Date = reader.ReadElementContentAsDateTime();
break;
case SerializerHelper.Authorizations:
AuthorizationSummaryListSerializer.Read(reader, result.Authorizations);
break;
default:
XMLParserUtils.SkipElement(reader);
break;
}
}
else
{
XMLParserUtils.SkipNode(reader);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <param name="authorization">PagSeguro AuthorizationResponse</param>
internal static void Read(XmlReader reader, AuthorizationResponse authorization)
{
if (reader.IsEmptyElement)
{
XMLParserUtils.SkipNode(reader);
return;
}
reader.ReadStartElement();
reader.MoveToContent();
while (!reader.EOF)
{
if (XMLParserUtils.IsEndElement(reader, SerializerHelper.PreApproval))
{
XMLParserUtils.SkipNode(reader);
break;
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case SerializerHelper.Code:
authorization.Code = reader.ReadElementContentAsString();
break;
case SerializerHelper.Date:
authorization.Date = reader.ReadElementContentAsDateTime();
break;
}
}
else
{
XMLParserUtils.SkipNode(reader);
}
}
}
public override DateTime ReadElementContentAsDateTime()
{
CheckAsync();
return(_coreReader.ReadElementContentAsDateTime());
}
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <param name="transaction"></param>
internal static void Read(XmlReader reader, TransactionSummary transaction)
{
if (reader.IsEmptyElement)
{
XMLParserUtils.SkipNode(reader);
return;
}
reader.ReadStartElement(SerializerHelper.Transaction);
reader.MoveToContent();
while (!reader.EOF)
{
if (XMLParserUtils.IsEndElement(reader, SerializerHelper.Transaction))
{
XMLParserUtils.SkipNode(reader);
break;
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case SerializerHelper.Code:
transaction.Code = reader.ReadElementContentAsString();
break;
case SerializerHelper.Date:
transaction.Date = reader.ReadElementContentAsDateTime();
break;
case SerializerHelper.Reference:
transaction.Reference = reader.ReadElementContentAsString();
break;
case SerializerHelper.TransactionType:
transaction.TransactionType = reader.ReadElementContentAsInt();
break;
case SerializerHelper.TransactionStatus:
transaction.TransactionStatus = reader.ReadElementContentAsInt();
break;
case SerializerHelper.GrossAmount:
transaction.GrossAmount = reader.ReadElementContentAsDecimal();
break;
case SerializerHelper.DiscountAmount:
transaction.DiscountAmount = reader.ReadElementContentAsDecimal();
break;
case SerializerHelper.FeeAmount:
transaction.FeeAmount = reader.ReadElementContentAsDecimal();
break;
case SerializerHelper.NetAmount:
transaction.NetAmount = reader.ReadElementContentAsDecimal();
break;
case SerializerHelper.ExtraAmount:
transaction.ExtraAmount = reader.ReadElementContentAsDecimal();
break;
case SerializerHelper.LastEventDate:
transaction.LastEventDate = reader.ReadElementContentAsDateTime();
break;
case PaymentMethodSerializer.PaymentMethod:
PaymentMethod paymentMethod = new PaymentMethod();
PaymentMethodSerializer.Read(reader, paymentMethod);
transaction.PaymentMethod = paymentMethod;
break;
default:
XMLParserUtils.SkipElement(reader);
break;
}
}
else
{
XMLParserUtils.SkipNode(reader);
}
}
}
public ShowItem(XmlReader reader)
{
this.SetDefaults();
reader.Read();
if (reader.Name != "ShowItem")
return; // bail out
reader.Read();
while (!reader.EOF)
{
if ((reader.Name == "ShowItem") && !reader.IsStartElement())
break; // all done
if (reader.Name == "ShowName")
{
this.CustomShowName = reader.ReadElementContentAsString();
this.UseCustomShowName = true;
}
if (reader.Name == "UseCustomShowName")
this.UseCustomShowName = reader.ReadElementContentAsBoolean();
if (reader.Name == "CustomShowName")
this.CustomShowName = reader.ReadElementContentAsString();
else if (reader.Name == "TVDBID")
this.TVDBCode = reader.ReadElementContentAsInt();
else if (reader.Name == "CountSpecials")
this.CountSpecials = reader.ReadElementContentAsBoolean();
else if (reader.Name == "ShowNextAirdate")
this.ShowNextAirdate = reader.ReadElementContentAsBoolean();
else if (reader.Name == "AutoAddNewSeasons")
this.AutoAddNewSeasons = reader.ReadElementContentAsBoolean();
else if (reader.Name == "FolderBase")
this.AutoAdd_FolderBase = reader.ReadElementContentAsString();
else if (reader.Name == "FolderPerSeason")
this.AutoAdd_FolderPerSeason = reader.ReadElementContentAsBoolean();
else if (reader.Name == "SeasonFolderName")
this.AutoAdd_SeasonFolderName = reader.ReadElementContentAsString();
else if (reader.Name == "DoRename")
this.DoRename = reader.ReadElementContentAsBoolean();
else if (reader.Name == "DoMissingCheck")
this.DoMissingCheck = reader.ReadElementContentAsBoolean();
else if (reader.Name == "DVDOrder")
this.DVDOrder = reader.ReadElementContentAsBoolean();
else if (reader.Name == "CustomSearchURL")
this.CustomSearchURL = reader.ReadElementContentAsString();
else if (reader.Name == "ForceCheckAll") // removed 2.2.0b2
this.ForceCheckNoAirdate = this.ForceCheckFuture = reader.ReadElementContentAsBoolean();
else if (reader.Name == "ForceCheckFuture")
this.ForceCheckFuture = reader.ReadElementContentAsBoolean();
else if (reader.Name == "ForceCheckNoAirdate")
this.ForceCheckNoAirdate = reader.ReadElementContentAsBoolean();
else if (reader.Name == "PadSeasonToTwoDigits")
this.PadSeasonToTwoDigits = reader.ReadElementContentAsBoolean();
else if (reader.Name == "BannersLastUpdatedOnDisk")
{
if (!reader.IsEmptyElement)
{
this.BannersLastUpdatedOnDisk = reader.ReadElementContentAsDateTime();
}else
reader.Read();
}
else if (reader.Name == "UseSequentialMatch")
this.UseSequentialMatch = reader.ReadElementContentAsBoolean();
else if (reader.Name == "IgnoreSeasons")
{
if (!reader.IsEmptyElement)
{
reader.Read();
while (reader.Name != "IgnoreSeasons")
{
if (reader.Name == "Ignore")
this.IgnoreSeasons.Add(reader.ReadElementContentAsInt());
else
reader.ReadOuterXml();
}
}
reader.Read();
}
else if (reader.Name == "AliasNames")
{
if (!reader.IsEmptyElement)
{
reader.Read();
while (reader.Name != "AliasNames")
{
if (reader.Name == "Alias")
this.AliasNames.Add(reader.ReadElementContentAsString());
else
reader.ReadOuterXml();
}
}
reader.Read();
}
else if (reader.Name == "Rules")
{
if (!reader.IsEmptyElement)
{
int snum = int.Parse(reader.GetAttribute("SeasonNumber"));
this.SeasonRules[snum] = new List<ShowRule>();
reader.Read();
while (reader.Name != "Rules")
{
if (reader.Name == "Rule")
{
this.SeasonRules[snum].Add(new ShowRule(reader.ReadSubtree()));
reader.Read();
}
}
}
reader.Read();
}
else if (reader.Name == "SeasonFolders")
{
if (!reader.IsEmptyElement)
{
int snum = int.Parse(reader.GetAttribute("SeasonNumber"));
this.ManualFolderLocations[snum] = new List<String>();
reader.Read();
while (reader.Name != "SeasonFolders")
{
if ((reader.Name == "Folder") && reader.IsStartElement())
{
string ff = reader.GetAttribute("Location");
if (this.AutoFolderNameForSeason(snum) != ff)
this.ManualFolderLocations[snum].Add(ff);
}
reader.Read();
}
}
reader.Read();
}
else
reader.ReadOuterXml();
} // while
}
internal static void Read(XmlReader reader, Transaction transaction)
{
if (reader == null)
throw new ArgumentNullException("reader");
if (transaction == null)
throw new ArgumentNullException("transaction");
if (reader.IsEmptyElement)
{
SerializationHelper.SkipNode(reader);
return;
}
reader.ReadStartElement(TransactionSerializerHelper.Transaction);
reader.MoveToContent();
while (!reader.EOF)
{
if (SerializationHelper.IsEndElement(reader, TransactionSerializerHelper.Transaction))
{
SerializationHelper.SkipNode(reader);
break;
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case TransactionSerializerHelper.Code:
transaction.Code = reader.ReadElementContentAsString();
break;
case TransactionSerializerHelper.Date:
transaction.Date = reader.ReadElementContentAsDateTime();
break;
case TransactionSerializerHelper.Reference:
transaction.Reference = reader.ReadElementContentAsString();
break;
case TransactionSerializerHelper.TransactionType:
transaction.TransactionType = reader.ReadElementContentAsInt();
break;
case TransactionSerializerHelper.TransactionStatus:
transaction.TransactionStatus = reader.ReadElementContentAsInt();
break;
case TransactionSerializerHelper.GrossAmount:
transaction.GrossAmount = reader.ReadElementContentAsDecimal();
break;
case TransactionSerializerHelper.DiscountAmount:
transaction.DiscountAmount = reader.ReadElementContentAsDecimal();
break;
case TransactionSerializerHelper.FeeAmount:
transaction.FeeAmount = reader.ReadElementContentAsDecimal();
break;
case TransactionSerializerHelper.NetAmount:
transaction.NetAmount = reader.ReadElementContentAsDecimal();
break;
case TransactionSerializerHelper.ExtraAmount:
transaction.ExtraAmount = reader.ReadElementContentAsDecimal();
break;
case TransactionSerializerHelper.LastEventDate:
transaction.LastEventDate = reader.ReadElementContentAsDateTime();
break;
case TransactionSerializerHelper.InstallmentCount:
transaction.InstallmentCount = reader.ReadElementContentAsInt();
break;
case PaymentMethodSerializer.PaymentMethod:
PaymentMethod paymentMethod = new PaymentMethod();
PaymentMethodSerializer.Read(reader, paymentMethod);
transaction.PaymentMethod = paymentMethod;
break;
case ItemListSerializer.Items:
ItemListSerializer.Read(reader, transaction.Items);
break;
case SenderSerializer.Sender:
Sender sender = new Sender();
SenderSerializer.Read(reader, sender);
transaction.Sender = sender;
break;
case ShippingSerializer.Shipping:
Shipping shipping = new Shipping();
ShippingSerializer.Read(reader, shipping);
transaction.Shipping = shipping;
break;
default:
SerializationHelper.SkipElement(reader);
break;
}
}
else
{
SerializationHelper.SkipNode(reader);
}
}
}
protected override void DeserializePropertyElement(XmlReader reader)
{
if (reader == null) throw new ArgumentNullException ("reader");
if (reader.NamespaceURI == Schemas.UpnpSchema) {
switch (reader.LocalName) {
case "channelName":
ChannelName = reader.ReadString ();
break;
case "scheduledStartTime":
scheduled_start_time_list.Add (reader.ReadElementContentAsDateTime ()); // TODO this is ISO 8601
break;
case "scheduledEndTime":
scheduled_end_time_list.Add (reader.ReadElementContentAsDateTime ());
break;
case "DVDRegionCode":
DvdRegionCode = reader.ReadElementContentAsInt ();
break;
default:
base.DeserializePropertyElement (reader);
break;
}
} else {
base.DeserializePropertyElement (reader);
}
}
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <param name="transaction"></param>
internal static void Read(XmlReader reader, Transaction transaction, bool preApproval)
{
if (reader.IsEmptyElement)
{
XMLParserUtils.SkipNode(reader);
return;
}
if (preApproval == true)
reader.ReadStartElement(TransactionSerializerHelper.PreApproval);
else
reader.ReadStartElement(TransactionSerializerHelper.Transaction);
reader.MoveToContent();
while (!reader.EOF)
{
if (preApproval == true)
{
if (XMLParserUtils.IsEndElement(reader, TransactionSerializerHelper.PreApproval))
{
XMLParserUtils.SkipNode(reader);
break;
}
}
else
{
if (XMLParserUtils.IsEndElement(reader, TransactionSerializerHelper.Transaction))
{
XMLParserUtils.SkipNode(reader);
break;
}
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case TransactionSerializerHelper.Code:
transaction.Code = reader.ReadElementContentAsString();
break;
case TransactionSerializerHelper.Date:
transaction.Date = reader.ReadElementContentAsDateTime();
break;
case TransactionSerializerHelper.Reference:
transaction.Reference = reader.ReadElementContentAsString();
break;
case TransactionSerializerHelper.TransactionType:
transaction.TransactionType = reader.ReadElementContentAsInt();
break;
case TransactionSerializerHelper.TransactionStatus:
if (preApproval == true)
transaction.Status = reader.ReadElementContentAsString();
else
transaction.TransactionStatus = reader.ReadElementContentAsInt();
break;
case TransactionSerializerHelper.GrossAmount:
transaction.GrossAmount = reader.ReadElementContentAsDecimal();
break;
case TransactionSerializerHelper.DiscountAmount:
transaction.DiscountAmount = reader.ReadElementContentAsDecimal();
break;
case TransactionSerializerHelper.FeeAmount:
transaction.FeeAmount = reader.ReadElementContentAsDecimal();
break;
case TransactionSerializerHelper.NetAmount:
transaction.NetAmount = reader.ReadElementContentAsDecimal();
break;
case TransactionSerializerHelper.ExtraAmount:
transaction.ExtraAmount = reader.ReadElementContentAsDecimal();
break;
case TransactionSerializerHelper.LastEventDate:
transaction.LastEventDate = reader.ReadElementContentAsDateTime();
break;
case TransactionSerializerHelper.InstallmentCount:
transaction.InstallmentCount = reader.ReadElementContentAsInt();
break;
case TransactionSerializerHelper.Name:
transaction.Name = reader.ReadElementContentAsString();
break;
case TransactionSerializerHelper.Tracker:
transaction.Tracker = reader.ReadElementContentAsString();
break;
case TransactionSerializerHelper.Charge:
transaction.Charge = reader.ReadElementContentAsString();
break;
case PaymentMethodSerializer.PaymentMethod:
PaymentMethod paymentMethod = new PaymentMethod();
PaymentMethodSerializer.Read(reader, paymentMethod);
transaction.PaymentMethod = paymentMethod;
break;
case ItemListSerializer.Items:
ItemListSerializer.Read(reader, transaction.Items);
break;
case SenderSerializer.Sender:
Sender sender = new Sender();
SenderSerializer.Read(reader, sender);
transaction.Sender = sender;
break;
case ShippingSerializer.Shipping:
Shipping shipping = new Shipping();
ShippingSerializer.Read(reader, shipping);
transaction.Shipping = shipping;
break;
default:
XMLParserUtils.SkipElement(reader);
break;
}
}
else
{
XMLParserUtils.SkipNode(reader);
}
}
}
object DeserializePrimitive (Type type, XmlReader reader, QName qname)
{
// It is the only exceptional type that does not serialize to string but serializes into complex element.
if (type == typeof (DateTimeOffset)) {
if (reader.IsEmptyElement) {
reader.Read ();
return default (DateTimeOffset);
}
reader.ReadStartElement ();
reader.MoveToContent ();
var date = reader.ReadElementContentAsDateTime ("DateTime", KnownTypeCollection.DefaultClrNamespaceSystem);
var off = TimeSpan.FromMinutes (reader.ReadElementContentAsInt ("OffsetMinutes", KnownTypeCollection.DefaultClrNamespaceSystem));
reader.MoveToContent ();
reader.ReadEndElement ();
return new DateTimeOffset (DateTime.SpecifyKind (date.ToUniversalTime () + off, DateTimeKind.Unspecified), off);
}
string value;
if (reader.IsEmptyElement) {
reader.Read (); // advance
if (type.IsValueType)
return Activator.CreateInstance (type);
else
// FIXME: Workaround for creating empty objects of the correct type.
value = String.Empty;
}
else
value = reader.ReadElementContentAsString ();
return KnownTypeCollection.PredefinedTypeStringToObject (value, qname.Name, reader);
}
private void ParseTerraLog(ref Geocache cache, XmlReader reader,ref bool logsChecked)
{
CacheLog log = new CacheLog();
bool breakLoop = false;
log.LogID = reader.GetAttribute("id");
log.LogKey = cache.Name + log.LogID;
while (!breakLoop && reader.Read())
{
if (reader.LocalName == "date")
{
log.LogDate = reader.ReadElementContentAsDateTime();
}
else if (reader.LocalName == "type")
{
log.LogStatus = reader.ReadElementContentAsString();
}
else if (reader.LocalName == "user")
{
log.FinderID = reader.GetAttribute("id");
log.LoggedBy = reader.ReadElementContentAsString();
if (log.FinderID == m_ownid && log.LogStatus == "find")
{
cache.Symbol = "Geocache Found";
}
else if (log.LoggedBy == m_ownid && log.LogStatus == "find")
{
cache.Symbol = "Geocache Found";
}
}
else if (reader.LocalName == "entry")
{
log.Encoded = false;
log.LogMessage = reader.ReadElementContentAsString();
log.LogMessage = log.LogMessage.Replace(">", ">");
log.LogMessage = log.LogMessage.Replace("<", "<");
log.LogMessage = log.LogMessage.Replace("&", "&");
}
else if (reader.LocalName == "log")
{
breakLoop = true;
}
}
if (!logsChecked)
{
if (log.LogStatus=="Didn't find it" || log.LogStatus == "Needs Maintenance" || log.LogStatus == "no_find")
{
cache.CheckNotes = true;
logsChecked = true;
}
else if (log.LogStatus != "Write Note" && log.LogStatus != "Note")
{
cache.CheckNotes = false;
logsChecked = true;
}
}
m_store.AddLog(cache.Name, log);
}
private void ReadXml(XmlReader r)
{
try
{
double bid, ask, high, low;
DateTime date;
RateDirection direction;
if (r.MoveToAttribute("Symbol")) { symbol = r.Value; }
r.Read();
r.Read();
bid = r.ReadElementContentAsDouble("Bid", ""); r.Read();
ask = r.ReadElementContentAsDouble("Ask", ""); r.Read();
high = r.ReadElementContentAsDouble("High", ""); r.Read();
low = r.ReadElementContentAsDouble("Low", ""); r.Read();
direction = (RateDirection)r.ReadElementContentAsInt("Direction", ""); r.Read();
date = r.ReadElementContentAsDateTime("Last", ""); r.Read();
r.Read();
RateData tempData = new RateData(bid, ask, high, low, date, direction);
data.Add(tempData);
}
catch (Exception e) { throw e; }
}
internal ObjectEntry(XmlReader reader, string searchPrefix, string delimiter)
{
if (reader.IsEmptyElement)
throw new Exception("Expected a non-empty <Contents> element.");
reader.ReadStartElement("Contents");
this.Key = reader.ReadElementContentAsString("Key", "");
this.LastModified = reader.ReadElementContentAsDateTime("LastModified", "");
this.ETag = reader.ReadElementContentAsString("ETag", "");
this.Size = reader.ReadElementContentAsLong("Size", "");
// this tag may be omitted if you don't have permission to view the owner
if (reader.Name == "Owner")
this.Owner = new Identity(reader);
// this element is meaningless
if (reader.Name == "StorageClass")
reader.Skip();
reader.ReadEndElement();
this.Name = Key;
if (!string.IsNullOrEmpty(searchPrefix))
this.Name = Name.Substring(searchPrefix.Length);
}
/*
* Recursive method to load xml plist data into plist objects.
*
*/
private PlistObjectBase LoadFromNode(XmlReader reader)
{
//Console.WriteLine("Loading data from node");
//only processes XmlNodeType.Element
bool isEmpty = reader.IsEmptyElement;
switch (reader.LocalName)
{
case "dict":
var dict = new PlistDictionary(true);
if (!isEmpty)
{
if (reader.ReadToDescendant("key"))
dict = LoadDictionaryContents(reader, dict);
reader.ReadEndElement();
}
return dict;
case "array":
return new PlistArray();
case "key":
return new PlistString(reader.ReadElementContentAsString());
case "string":
return new PlistString(reader.ReadElementContentAsString());
case "integer":
return new PlistInteger(reader.ReadElementContentAsInt());
case "real":
return new PlistInteger(reader.ReadElementContentAsInt());
case "false":
reader.ReadStartElement();
if (!isEmpty)
reader.ReadEndElement();
return new PlistBoolean(false);
case "true":
reader.ReadStartElement();
if (!isEmpty)
reader.ReadEndElement();
return new PlistBoolean(true);
case "data":
return new PlistData(reader.ReadElementContentAsString());
case "date":
return new PlistDate(reader.ReadElementContentAsDateTime());
default:
throw new XmlException(String.Format("Plist Node `{0}' is not supported", reader.LocalName));
}
}
internal static MarketplaceAppOfferNode ParseXml(XmlReader reader)
{
var node = new MarketplaceAppOfferNode();
reader.ReadStartElement();
while (reader.NodeType != XmlNodeType.EndElement)
{
switch (reader.LocalName)
{
case "offerId":
node.OfferId = reader.ReadElementContentAsUrn();
break;
case "mediaInstanceId":
node.MediaInstanceId = reader.ReadElementContentAsUrn();
break;
case "clientTypes":
node.ClientTypes = reader.ReadElementContentAsArray(x => x.ReadElementContentAsString());
break;
case "paymentTypes":
node.PaymentTypes = reader.ReadElementContentAsArray(x => x.ReadElementContentAsString());
break;
case "store":
node.Store = reader.ReadElementContentAsString();
break;
case "price":
node.Price = reader.ReadElementContentAsDouble();
break;
case "displayPrice":
node.DisplayPrice = reader.ReadElementContentAsString();
break;
case "priceCurrencyCode":
node.PriceCurrencyCode = reader.ReadElementContentAsString();
break;
case "licenseRight":
node.LicenseRight = reader.ReadElementContentAsString();
break;
case "expiration":
node.Expiration = reader.ReadElementContentAsDateTime();
break;
default:
reader.Skip();
break;
}
}
reader.ReadEndElement();
return node;
}
internal static Workspace FromXml(Repository repository, XmlReader reader)
{
string elementName = reader.Name;
string computer = reader.GetAttribute("computer");
string name = reader.GetAttribute("name");
string owner = reader.GetAttribute("owner");
string comment = "";
DateTime lastAccessDate = DateTime.Now;
List<WorkingFolder> folders = new List<WorkingFolder>();
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.EndElement && reader.Name == elementName)
break;
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "WorkingFolder":
folders.Add(WorkingFolder.FromXml(repository, reader));
break;
case "Comment":
comment = reader.ReadString();
break;
case "LastAccessDate":
lastAccessDate = reader.ReadElementContentAsDateTime();
break;
}
}
}
Workspace w = new Workspace(repository.VersionControlServer, name, owner, comment, folders.ToArray(), computer);
w.lastAccessDate = lastAccessDate;
return w;
}
protected override void DeserializePropertyElement(XmlReader reader)
{
if (reader == null) throw new ArgumentNullException ("reader");
if (reader.NamespaceURI == Schemas.UpnpSchema) {
switch (reader.LocalName) {
case "artist":
artist_list.Add (PersonWithRole.Deserialize (reader));
break;
case "album":
album_list.Add (reader.ReadString ());
break;
case "scheduledStartTime":
scheduled_start_time_list.Add (reader.ReadElementContentAsDateTime ()); // TODO is this going to work?
break;
case "scheduledEndTime":
scheduled_end_time_list.Add (reader.ReadElementContentAsDateTime ());
break;
default:
base.DeserializePropertyElement (reader);
break;
}
} else if (reader.NamespaceURI == Schemas.DublinCoreSchema) {
switch (reader.LocalName) {
case "contributor":
contributor_list.Add (reader.ReadString ());
break;
case "date":
Date = reader.ReadString ();
break;
default:
base.DeserializePropertyElement (reader);
break;
}
} else {
base.DeserializePropertyElement (reader);
}
}
private PlistObjectBase LoadFromNode(XmlReader reader)
{
//Debug.Assert(reader.NodeType == XmlNodeType.Element);
bool isEmpty = reader.IsEmptyElement;
switch (reader.LocalName)
{
case "dict":
var dict = new PlistDictionary(true);
if (!isEmpty)
{
if (reader.ReadToDescendant("key"))
dict = LoadDictionaryContents(reader, dict);
reader.ReadEndElement();
}
return dict;
case "array":
if (isEmpty)
return new PlistArray();
//advance to first node
reader.ReadStartElement();
while (reader.Read() && reader.NodeType != XmlNodeType.Element) ;
// HACK: plist data in iPods is not even valid in some cases! Way to go Apple!
// This hack checks to see if they really meant for this array to be a dict.
if (reader.LocalName == "key")
{
var ret = LoadDictionaryContents(reader, new PlistDictionary(true));
reader.ReadEndElement();
return ret;
}
var arr = new PlistArray();
do
{
if (reader.NodeType == XmlNodeType.Element)
{
var val = LoadFromNode(reader);
if (val != null)
arr.Add(val);
}
} while (reader.Read() && reader.NodeType != XmlNodeType.EndElement);
reader.ReadEndElement();
return arr;
case "key":
return new PlistString(reader.ReadElementContentAsString());
case "string":
return new PlistString(reader.ReadElementContentAsString());
case "integer":
return new PlistInteger(reader.ReadElementContentAsInt());
case "real":
return new PlistReal(reader.ReadElementContentAsDouble());
case "false":
reader.ReadStartElement();
if (!isEmpty)
reader.ReadEndElement();
return new PlistBoolean(false);
case "true":
reader.ReadStartElement();
if (!isEmpty)
reader.ReadEndElement();
return new PlistBoolean(true);
case "data":
return new PlistData(reader.ReadElementContentAsString());
case "date":
return new PlistDate(reader.ReadElementContentAsDateTime());
default:
throw new XmlException(String.Format("Plist Node `{0}' is not supported", reader.LocalName));
}
}
internal static MarketplaceAppEntryNode ParseXml(XmlReader reader)
{
var node = new MarketplaceAppEntryNode();
reader.ReadStartElement();
while (reader.NodeType != XmlNodeType.EndElement)
{
switch (reader.Name)
{
case "a:updated":
node.Updated = reader.ReadElementContentAsDateTime();
break;
case "a:title":
node.Title = MarketplaceAppContentNode.ParseXml(reader);
break;
case "a:id":
node.Id = reader.ReadElementContentAsUrn();
break;
case "version":
node.Version = reader.ReadElementContentAsString();
break;
case "payloadId":
node.PayloadId = reader.ReadElementContentAsUrn();
break;
case "skuId":
node.SkuId = reader.ReadElementContentAsUrn();
break;
case "skuLastUpdated":
node.SkuLastUpdated = reader.ReadElementContentAsDateTime();
break;
case "isAvailableInCountry":
node.IsAvailableInCountry = reader.ReadElementContentAsBoolean();
break;
case "isAvailableInStore":
node.IsAvailableInStore = reader.ReadElementContentAsBoolean();
break;
case "isClientTypeCompatible":
node.IsClientTypeCompatible = reader.ReadElementContentAsBoolean();
break;
case "isHardwareCompatible":
node.IsHardwareCompatible = reader.ReadElementContentAsBoolean();
break;
case "isBlacklisted":
node.IsBlacklisted = reader.ReadElementContentAsBoolean();
break;
case "url":
node.Url = reader.ReadElementContentAsString();
break;
case "packageSize":
node.PackageSize = reader.ReadElementContentAsInt();
break;
case "installSize":
node.InstallSize = reader.ReadElementContentAsInt();
break;
case "clientTypes":
node.ClientTypes = reader.ReadElementContentAsArray(x => x.ReadElementContentAsString());
break;
case "supportedLanguages":
node.SupportedLanguages = reader.ReadElementContentAsArray(x => x.ReadElementContentAsString());
break;
case "deviceCapabilities":
var deviceCapabilitiesString = reader.ReadElementContentAsString();
if (!string.IsNullOrEmpty(deviceCapabilitiesString))
{
deviceCapabilitiesString = string.Format("<root>{0}</root>", HttpUtility.HtmlDecode(deviceCapabilitiesString));
using (var stringReader = new StringReader(deviceCapabilitiesString))
{
using (var reader2 = XmlReader.Create(stringReader))
{
reader2.ReadStartElement();
node.DeviceCapabilities = MarketplaceAppCapabilitiesNode.ParseXml(reader2);
reader2.ReadEndElement();
}
}
}
break;
default:
reader.Skip();
break;
}
}
reader.ReadEndElement();
return node;
}
public List<Event> parseEvents(XmlReader eventsReader)
{
List<Event> eventsResult = new List<Event>();
while (eventsReader.Read())
{
if (eventsReader.NodeType == XmlNodeType.Element)
{
switch (eventsReader.Name)
{
case "artists":
XmlReader artistsReader = eventsReader.ReadSubtree();
eventsResult.Last<Event>().Artists = parseArtists(artistsReader);
break;
case "venue":
XmlReader venueReader = eventsReader.ReadSubtree();
eventsResult.Last<Event>().Venue = parseVenue(venueReader);
break;
case "events":
break;
case "event":
eventsResult.Add(new Event());
break;
case "id":
eventsResult.Last<Event>().Id = eventsReader.ReadElementContentAsInt();
break;
case "url":
eventsResult.Last<Event>().Url = eventsReader.ReadElementContentAsString();
break;
case "datetime":
eventsResult.Last<Event>().DateTime = eventsReader.ReadElementContentAsDateTime();
break;
case "ticket_url":
eventsResult.Last<Event>().Ticket_Url = eventsReader.ReadElementContentAsString() + "?affil_code=concertswp7";
break;
case "status":
eventsResult.Last<Event>().Status = eventsReader.ReadElementContentAsString();
break;
case "ticket_status":
eventsResult.Last<Event>().Ticket_Status = eventsReader.ReadElementContentAsString();
break;
case "on_sale_datetime":
eventsResult.Last<Event>().On_Sale_Date = ParseNullableDateTime(eventsReader.ReadInnerXml().ToString());
break;
}
}
}
return eventsResult;
}
internal static MarketplaceAppNode ParseXml(XmlReader reader)
{
var node = new MarketplaceAppNode();
reader.ReadStartElement();
while (reader.NodeType != XmlNodeType.EndElement)
{
switch (reader.Name)
{
case "a:updated":
node.Updated = reader.ReadElementContentAsDateTime();
break;
case "a:title":
node.Title = reader.ReadElementContentAsString();
break;
case "a:id":
node.Id = reader.ReadElementContentAsUrn();
break;
case "a:content":
node.Content = MarketplaceAppContentNode.ParseXml(reader);
break;
case "iapCount":
node.IapCount = reader.ReadElementContentAsInt();
break;
case "sortTitle":
node.SortTitle = reader.ReadElementContentAsString();
break;
case "releaseDate":
node.ReleaseDate = reader.ReadElementContentAsDateTime();
break;
case "visibilityStatus":
node.VisibilityStatus = reader.ReadElementContentAsString();
break;
case "publisher":
node.Publisher = reader.ReadElementContentAsString();
break;
case "averageUserRating":
node.AverageUserRating = reader.ReadElementContentAsDouble();
break;
case "userRatingCount":
node.UserRatingCount = reader.ReadElementContentAsInt();
break;
case "image":
node.Image = MarketplaceAppImageNode.ParseXml(reader);
break;
case "screenshots":
node.Screenshots = reader.ReadElementContentAsArray(MarketplaceAppImageNode.ParseXml);
break;
case "categories":
node.Categories = reader.ReadElementContentAsArray(MarketplaceAppCategoryNode.ParseXml);
break;
case "tags":
node.Tags = reader.ReadElementContentAsArray(x => x.ReadElementContentAsString());
break;
case "taxString":
node.TaxString = reader.ReadElementContentAsString();
break;
case "backgroundImage":
node.BackgroundImage = MarketplaceAppImageNode.ParseXml(reader);
break;
case "offers":
node.Offers = reader.ReadElementContentAsArray(MarketplaceAppOfferNode.ParseXml);
break;
case "publisherId":
node.PublisherId = reader.ReadElementContentAsString();
break;
case "publisherGuid":
node.PublisherGuid = reader.ReadElementContentAsUrn();
break;
case "a:entry":
node.Entry = MarketplaceAppEntryNode.ParseXml(reader);
break;
default:
reader.Skip();
break;
}
}
reader.ReadEndElement();
return node;
}
