private static void ProcessNextPermissions(InventoryItemBase item, XmlReader reader)
{
item.NextPermissions = (uint)reader.ReadElementContentAsInt("NextPermissions", String.Empty);
}
private static void ProcessInvType(InventoryItemBase item, XmlReader reader)
{
item.InvType = reader.ReadElementContentAsInt("InvType", String.Empty);
}
public void ReadXml(XmlReader reader)
{
reader.ReadStartElement();
while (true)
{
if (reader.NodeType == XmlNodeType.EndElement)
{
break;
}
switch (reader.LocalName)
{
case "CampfireName":
this.CampfireName = reader.ReadElementContentAsString("CampfireName", "");
break;
case "CampfireToken":
this.CampfireToken = reader.ReadElementContentAsString("CampfireToken", "");
break;
case "DelayBeforeSmokeSignalInMinutes":
this.DelayBeforeSmokeSignalInMinutes = reader.ReadElementContentAsInt("DelayBeforeSmokeSignalInMinutes", "");
break;
case "SendNewUserEmail":
this.SendNewUserEmail = reader.ReadElementContentAsBoolean("SendNewUserEmail", "");
break;
case "ExtraEmailMessage":
this.ExtraEmailMessage = reader.ReadElementContentAsString("ExtraEmailMessage", "");
break;
default:
if (reader.NodeType == XmlNodeType.Comment)
{
reader.Read();
}
else
{
reader.ReadElementContentAsString(reader.LocalName, "");
}
break;
}
}
if (this.DelayBeforeSmokeSignalInMinutes < 1)
{
this.DelayBeforeSmokeSignalInMinutes = 1;
}
else if (this.DelayBeforeSmokeSignalInMinutes > 10)
{
this.DelayBeforeSmokeSignalInMinutes = 10;
}
//if (this.SmtpPort < 1)
//{
// this.SmtpPort = 25;
//}
//if (string.IsNullOrEmpty(this.CampfireName.Trim()) || string.IsNullOrEmpty(this.CampfireToken.Trim()))
//{
// throw new ApplicationException("Invalid SmokeSignalConfig.xml, missing CampfireName and/or CampfireToken fields");
//}
//if (string.IsNullOrEmpty(this.SmtpHost.Trim()))
//{
// throw new ApplicationException("Invalid SmokeSignalConfig.xml, missing SmtpHost and/or SmtpUserName fields");
//}
reader.ReadEndElement();
}
private static void ProcessCreationDate(InventoryItemBase item, XmlReader reader)
{
item.CreationDate = reader.ReadElementContentAsInt("CreationDate", String.Empty);
}
/// <summary>
/// Reads a JointDriver from the given XmlReader.
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
private static JointDriver ReadJointDriver_4_0(XmlReader reader)
{
JointDriver driver = null;
foreach (string name in IOUtilities.AllElements(reader))
{
switch (name)
{
case "DriveType":
// Initialize the driver.
driver = new JointDriver((JointDriverType)Enum.Parse(typeof(JointDriverType), reader.ReadElementContentAsString()));
break;
case "Port1":
// Assign a value to port1.
driver.port1 = reader.ReadElementContentAsInt();
break;
case "Port2":
// Assign a value to port2.
driver.port2 = reader.ReadElementContentAsInt();
break;
case "InputGear":
// Assign a value to InputGear
driver.InputGear = reader.ReadElementContentAsDouble();
break;
case "OutputGear":
// Assign a value to OutputGear
driver.OutputGear = reader.ReadElementContentAsDouble();
break;
case "LowerLimit":
// Assign a value to the lowerLimit.
driver.lowerLimit = float.Parse(reader.ReadElementContentAsString());
break;
case "UpperLimit":
// Assign a value to the upperLimit.
driver.upperLimit = float.Parse(reader.ReadElementContentAsString());
break;
case "SignalType":
// Assign a value to isCan.
driver.isCan = reader.ReadElementContentAsString().Equals("CAN") ? true : false;
break;
case "ElevatorDriverMeta":
// Add an ElevatorDriverMeta.
driver.AddInfo(ReadElevatorDriverMeta_4_0(reader.ReadSubtree()));
break;
case "PneumaticDriverMeta":
// Add a PneumaticsDriverMeta.
driver.AddInfo(ReadPneumaticDriverMeta_4_0(reader.ReadSubtree()));
break;
case "WheelDriverMeta":
// Add a WheelDriverMeta.
driver.AddInfo(ReadWheelDriverMeta_4_0(reader.ReadSubtree()));
break;
}
}
return(driver);
}
private int XRint()
{
return(reader.ReadElementContentAsInt());
}
public Banner(SeriesInfo ser, Season seas, int?codeHint, XmlReader r, CommandLineArgs args)
{
// <Banner>
// <id>708811</id>
// <BannerPath>seasonswide/79488-5.jpg</BannerPath>
// <BannerType>season</BannerType>
// <BannerType2>seasonwide</BannerType2>
// <Language>en</Language>
// <Rating/>
// <RatingCount>0</RatingCount>
// <Season>5</Season>
// blah blah
// </Banner>
try
{
this.SetDefaults(ser, seas);
this.SeriesID = (int)codeHint;
r.Read();
if (r.Name != "Banner")
{
return;
}
r.Read();
while (!r.EOF)
{
if ((r.Name == "Banner") && (!r.IsStartElement()))
{
break;
}
if (r.Name == "id")
{
this.BannerId = r.ReadElementContentAsInt();
}
else if (r.Name == "seriesid")
{
this.SeriesID = r.ReadElementContentAsInt(); // thetvdb series id
}
else if (r.Name == "seasonid")
{
this.SeasonID = r.ReadElementContentAsInt();
}
else if (r.Name == "BannerPath")
{
this.BannerPath = XMLHelper.ReadStringFixQuotesAndSpaces(r);
}
else if (r.Name == "BannerType")
{
this.BannerType = r.ReadElementContentAsString();
}
else if (r.Name == "LanguageId")
{
this.LanguageId = r.ReadElementContentAsInt();
}
else if (r.Name == "Resolution")
{
this.Resolution = r.ReadElementContentAsString();
}
else if (r.Name == "Rating")
{
String sn = r.ReadElementContentAsString();
double.TryParse(sn, out this.Rating);
}
else if (r.Name == "RatingCount")
{
this.RatingCount = r.ReadElementContentAsInt();
}
else if (r.Name == "Season")
{
this.SeasonID = r.ReadElementContentAsInt();
}
else if (r.Name == "ThumbnailPath")
{
this.ThumbnailPath = r.ReadElementContentAsString();
}
else
{
if ((r.IsEmptyElement) || !r.IsStartElement())
{
r.ReadOuterXml();
}
else
{
r.Read();
}
}
}
}
catch (XmlException e)
{
string message = "Error processing data from TheTVDB for a banner.";
if (this.SeriesID != -1)
{
message += "\r\nSeries ID: " + this.SeriesID;
}
if (this.BannerId != -1)
{
message += "\r\nBanner ID: " + this.BannerId;
}
if (!string.IsNullOrEmpty(this.BannerPath))
{
message += "\r\nBanner Path: " + this.BannerPath;
}
logger.Error(e, message);
throw new TheTVDB.TVDBException(e.Message);
}
}
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.ReadElementContentAsNullable <DateTime>();
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.ReadElementContentAsNullable <DateTime>();
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 override int ReadElementContentAsInt()
{
this.IsCalled = true; return(_wrappedreader.ReadElementContentAsInt());
}
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
public override void ReadXml(XmlReader reader)
{
reader.Read();
while (!reader.EOF)
{
if (reader.IsEmptyElement && !reader.HasAttributes)
{
reader.Read();
continue;
}
switch (reader.Name)
{
case RedmineKeys.ID: Id = reader.ReadElementContentAsInt(); break;
case RedmineKeys.ASSIGNED_TO: AssignedTo = new IdentifiableName(reader); break;
case RedmineKeys.ATTACHMENTS: Attachments = reader.ReadElementContentAsCollection <Attachment>(); break;
case RedmineKeys.AUTHOR: Author = new IdentifiableName(reader); break;
case RedmineKeys.CATEGORY: Category = new IdentifiableName(reader); break;
case RedmineKeys.CHANGE_SETS: ChangeSets = reader.ReadElementContentAsCollection <ChangeSet>(); break;
case RedmineKeys.CHILDREN: Children = reader.ReadElementContentAsCollection <IssueChild>(); break;
case RedmineKeys.CLOSED_ON: ClosedOn = reader.ReadElementContentAsNullableDateTime(); break;
case RedmineKeys.CREATED_ON: CreatedOn = reader.ReadElementContentAsNullableDateTime(); break;
case RedmineKeys.CUSTOM_FIELDS: CustomFields = reader.ReadElementContentAsCollection <IssueCustomField>(); break;
case RedmineKeys.DESCRIPTION: Description = reader.ReadElementContentAsString(); break;
case RedmineKeys.DONE_RATIO: DoneRatio = reader.ReadElementContentAsNullableFloat(); break;
case RedmineKeys.DUE_DATE: DueDate = reader.ReadElementContentAsNullableDateTime(); break;
case RedmineKeys.ESTIMATED_HOURS: EstimatedHours = reader.ReadElementContentAsNullableFloat(); break;
case RedmineKeys.FIXED_VERSION: FixedVersion = new IdentifiableName(reader); break;
case RedmineKeys.IS_PRIVATE: IsPrivate = reader.ReadElementContentAsBoolean(); break;
case RedmineKeys.JOURNALS: Journals = reader.ReadElementContentAsCollection <Journal>(); break;
case RedmineKeys.NOTES: Notes = reader.ReadElementContentAsString(); break;
case RedmineKeys.PARENT: ParentIssue = new IdentifiableName(reader); break;
case RedmineKeys.PRIORITY: Priority = new IdentifiableName(reader); break;
case RedmineKeys.PRIVATE_NOTES: PrivateNotes = reader.ReadElementContentAsBoolean(); break;
case RedmineKeys.PROJECT: Project = new IdentifiableName(reader); break;
case RedmineKeys.RELATIONS: Relations = reader.ReadElementContentAsCollection <IssueRelation>(); break;
case RedmineKeys.SPENT_HOURS: SpentHours = reader.ReadElementContentAsNullableFloat(); break;
case RedmineKeys.START_DATE: StartDate = reader.ReadElementContentAsNullableDateTime(); break;
case RedmineKeys.STATUS: Status = new IdentifiableName(reader); break;
case RedmineKeys.SUBJECT: Subject = reader.ReadElementContentAsString(); break;
case RedmineKeys.TOTAL_ESTIMATED_HOURS: TotalEstimatedHours = reader.ReadElementContentAsNullableFloat(); break;
case RedmineKeys.TOTAL_SPENT_HOURS: TotalSpentHours = reader.ReadElementContentAsNullableFloat(); break;
case RedmineKeys.TRACKER: Tracker = new IdentifiableName(reader); break;
case RedmineKeys.UPDATED_ON: UpdatedOn = reader.ReadElementContentAsNullableDateTime(); break;
case RedmineKeys.WATCHERS: Watchers = reader.ReadElementContentAsCollection <Watcher>(); break;
default: reader.Read(); break;
}
}
}
/// <summary>
/// Отправка SMS
/// </summary>
/// <param name="number">Номер получателя()</param>
/// <param name="message">Текст сообщения</param>
/// <param name="messageId">(не обязательно) Уникальный ключ для возможности слежения за статусом SMS</param>
/// <returns>Статус сообщения:
/// >0 — Количество отправленных SMS
/// -1 — Неправильный логин и/или пароль
/// -2 — Неправильный формат XML
/// -3 — Недостаточно кредитов на аккаунте пользователя
/// -4 — Нет верных номеров получателей
/// -5 — Ошибка подключения</returns>
public int Send(string number, string message, string messageId = "")
{
try
{
string str_msgId = "";
if (messageId != "")
{
str_msgId = $"messageID=\"{messageId}\"";
}
string XML = "XML=<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<SMS>\n" +
"<operations>\n" +
"<operation>SEND</operation>\n" +
"</operations>\n" +
"<authentification>\n" +
$"<username>{Login}</username>\n" +
$"<password>{Password}</password>\n" +
"</authentification>\n" +
"<message>\n" +
$"<sender>{m_sender}</sender>\n" +
$"<text>{message}</text>\n" +
"</message>\n" +
"<numbers>\n" +
$"<number {str_msgId}>{number}</number>\n" +
"</numbers>\n" +
"</SMS>\n";
HttpWebRequest request = WebRequest.Create("http://api.myatompark.com/members/sms/xml.php") as HttpWebRequest;
request.Method = "Post";
request.ContentType = "application/x-www-form-urlencoded";
ASCIIEncoding encoding = new ASCIIEncoding();
byte[] data = encoding.GetBytes(XML);
request.ContentLength = data.Length;
Stream dataStream = request.GetRequestStream();
dataStream.Write(data, 0, data.Length);
using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)
{
if (response.StatusCode != HttpStatusCode.OK)
{
ShowErrorMessage($"Server error (HTTP {response.StatusCode}: {response.StatusDescription}).");
return(-5);
}
StreamReader reader = new StreamReader(response.GetResponseStream());
string xmlResult = reader.ReadToEnd();
using (XmlReader xmlReader = XmlReader.Create(new StringReader(xmlResult)))
{
xmlReader.ReadToFollowing("status");
int status = xmlReader.ReadElementContentAsInt();
return(status);
}
}
}
catch (Exception e)
{
ShowErrorMessage(e.Message);
return(-5);
}
}
public void ReadXml(XmlReader reader)
{
reader.Read();
while (!reader.EOF)
{
if (reader.IsEmptyElement && !reader.HasAttributes)
{
reader.Read();
continue;
}
switch (reader.Name)
{
case "id":
Id = reader.ReadElementContentAsInt();
break;
case "project":
Project = new IdentifiableName(reader);
break;
case "tracker":
Tracker = new IdentifiableName(reader);
break;
case "status":
Status = new IdentifiableName(reader);
break;
case "priority":
Priority = new IdentifiableName(reader);
break;
case "author":
Author = new IdentifiableName(reader);
break;
case "assigned_to":
AssignedTo = new IdentifiableName(reader);
break;
case "category":
Category = new IdentifiableName(reader);
break;
case "parent":
ParentIssue = new IdentifiableName(reader);
break;
case "fixed_version":
FixedVersion = new IdentifiableName(reader);
break;
case "subject":
Subject = reader.ReadElementContentAsString();
break;
case "notes":
Notes = reader.ReadElementContentAsString();
break;
case "description":
Description = reader.ReadElementContentAsString();
break;
case "start_date":
StartDate = reader.ReadElementContentAsNullableDateTime();
break;
case "due_date":
DueDate = reader.ReadElementContentAsNullableDateTime();
break;
case "done_ratio":
DoneRatio = reader.ReadElementContentAsNullableFloat();
break;
case "estimated_hours":
EstimatedHours = reader.ReadElementContentAsNullableFloat();
break;
case "spent_hours":
SpentHours = reader.ReadElementContentAsNullableFloat();
break;
case "created_on":
CreatedOn = reader.ReadElementContentAsNullableDateTime();
break;
case "updated_on":
UpdatedOn = reader.ReadElementContentAsNullableDateTime();
break;
case "closed_on":
ClosedOn = reader.ReadElementContentAsNullableDateTime();
break;
case "custom_fields":
CustomFields =
reader.ReadElementContentAsCollection <IssueCustomField>();
break;
case "attachments":
Attachments = reader.ReadElementContentAsCollection <Attachment>();
break;
case "relations":
Relations = reader.ReadElementContentAsCollection <IssueRelation>();
break;
case "journals":
Journals = reader.ReadElementContentAsCollection <Journal>();
break;
case "changesets":
Changesets = reader.ReadElementContentAsCollection <ChangeSet>();
break;
case "children":
Children = reader.ReadElementContentAsCollection <IssueChild>();
break;
case "watchers":
Watchers = reader.ReadElementContentAsCollection <Watcher>();
break;
default:
reader.Read();
break;
}
}
}
/// <summary>
/// Reads DropletPrintStyleViewModel properties from XML and creates a DropletPrintStyleViewModel with said properties.
/// </summary>
/// <param name="xml"></param>
/// <returns></returns>
public override void DeserializePrintStyle(XmlReader xmlReader, PrintStyleViewModel printStyleViewModel)
{
DropletPrintStyleViewModel dropletPrintStyleViewModel = (DropletPrintStyleViewModel)printStyleViewModel;
//Read through each element of the XML string and populate each property of the Droplet Print Style.
while (xmlReader.Read())
{
//Skip through newlines (this program's XML Writer uses newlines).
if ((xmlReader.Name != "\n") && (!String.IsNullOrWhiteSpace(xmlReader.Name)))
{
//End method if the end of "DropletPrintStyle" element is reached.
if ((xmlReader.Name == "DropletPrintStyle") && (xmlReader.NodeType == XmlNodeType.EndElement))
{
return;
}
switch (xmlReader.Name)
{
case "MotorizedDispenseDistance":
dropletPrintStyleViewModel.MotorizedDispenseDistance = xmlReader.ReadElementContentAsDouble();
break;
case "MotorizedDispenseMaxSpeed":
dropletPrintStyleViewModel.MotorizedDispenseMaxSpeed = xmlReader.ReadElementContentAsDouble();
break;
case "MotorizedDispenseAcceleration":
dropletPrintStyleViewModel.MotorizedDispenseAcceleration = xmlReader.ReadElementContentAsDouble();
break;
case "ValveOpenTime":
dropletPrintStyleViewModel.ValveOpenTime = xmlReader.ReadElementContentAsInt();
break;
case "InterpolateDistance":
dropletPrintStyleViewModel.InterpolateDistance = xmlReader.ReadElementContentAsDouble();
break;
case "GradientShape":
dropletPrintStyleViewModel.GradientShape = (GradientShape)Enum.Parse(typeof(GradientShape), xmlReader.ReadElementContentAsString(), false);
break;
case "GradientScaling":
dropletPrintStyleViewModel.GradientScaling = (GradientScaling)Enum.Parse(typeof(GradientScaling), xmlReader.ReadElementContentAsString(), false);
break;
case "PercentPerMm":
dropletPrintStyleViewModel.PercentPerMm = xmlReader.ReadElementContentAsDouble();
break;
case "X1":
dropletPrintStyleViewModel.X1 = xmlReader.ReadElementContentAsDouble();
break;
case "Y1":
dropletPrintStyleViewModel.Y1 = xmlReader.ReadElementContentAsDouble();
break;
case "Z1":
dropletPrintStyleViewModel.Z1 = xmlReader.ReadElementContentAsDouble();
break;
case "X2":
dropletPrintStyleViewModel.X2 = xmlReader.ReadElementContentAsDouble();
break;
case "Y2":
dropletPrintStyleViewModel.Y2 = xmlReader.ReadElementContentAsDouble();
break;
case "Z2":
dropletPrintStyleViewModel.Z2 = xmlReader.ReadElementContentAsDouble();
break;
case "X3":
dropletPrintStyleViewModel.X3 = xmlReader.ReadElementContentAsDouble();
break;
case "Y3":
dropletPrintStyleViewModel.Y3 = xmlReader.ReadElementContentAsDouble();
break;
case "Z3":
dropletPrintStyleViewModel.Z3 = xmlReader.ReadElementContentAsDouble();
break;
default:
base.ReportErrorUnrecognizedElement(xmlReader);
break;
}
}
}
}
public void ParseContextSetupReply(XmlReader reader)
{
// verify node is "context_setup_reply
if (reader.Name == "context_setup_reply")
{
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "apiversion")
{
csr.apiversion = reader.ReadElementContentAsString();
//UnityEngine.Debug.Log("apiversion=" + csr.apiversion);
}
if (reader.NodeType == XmlNodeType.Element && reader.Name == "setup_request_status")
{
csr.setup_request_status = reader.ReadElementContentAsInt();
//UnityEngine.Debug.Log("setup_request_status=" + csr.setup_request_status);
}
if (reader.NodeType == XmlNodeType.Element && reader.Name == "context_uid")
{
csr.context_uid = reader.ReadElementContentAsString();
#if SHOW_INIT
QuickInfoMsg msg = new QuickInfoMsg();
msg.title = "NLU STATUS";
msg.text = "NLU Initialized : " + CmdTime + " seconds";
msg.timeout = 2.0f;
QuickInfoDialog.GetInstance().PutMessage(msg);
#endif
Initialized = true;
//UnityEngine.Debug.Log("context_uid=" + csr.context_uid);
}
}
}
}
public Episode(SeriesInfo ser, Season seas, XmlReader r, CommandLineArgs args)
{
// <Episode>
// <id>...</id>
// blah blah
// </Episode>
try
{
this.SetDefaults(ser, seas);
r.Read();
if (r.Name != "Episode")
{
return;
}
r.Read();
while (!r.EOF)
{
if ((r.Name == "Episode") && (!r.IsStartElement()))
{
break;
}
if (r.Name == "id")
{
this.EpisodeID = r.ReadElementContentAsInt();
}
else if (r.Name == "seriesid")
{
this.SeriesID = r.ReadElementContentAsInt(); // thetvdb series id
}
else if (r.Name == "seasonid")
{
this.SeasonID = r.ReadElementContentAsInt();
}
else if (r.Name == "EpisodeNumber")
{
this.EpNum = r.ReadElementContentAsInt();
}
else if (r.Name == "SeasonNumber")
{
String sn = r.ReadElementContentAsString();
int.TryParse(sn, out this.ReadSeasonNum);
}
else if (r.Name == "lastupdated")
{
this.Srv_LastUpdated = r.ReadElementContentAsInt();
}
else if (r.Name == "Overview")
{
this.Overview = XMLHelper.ReadStringFixQuotesAndSpaces(r);
}
else if (r.Name == "Rating")
{
this.EpisodeRating = XMLHelper.ReadStringFixQuotesAndSpaces(r);
}
else if (r.Name == "GuestStars")
{
this.EpisodeGuestStars = XMLHelper.ReadStringFixQuotesAndSpaces(r);
}
else if (r.Name == "EpisodeDirector")
{
this.EpisodeDirector = XMLHelper.ReadStringFixQuotesAndSpaces(r);
}
else if (r.Name == "Writer")
{
this.Writer = XMLHelper.ReadStringFixQuotesAndSpaces(r);
}
else if (r.Name == "EpisodeName")
{
this.Name = XMLHelper.ReadStringFixQuotesAndSpaces(r);
}
else if (r.Name == "FirstAired")
{
try
{
String contents = r.ReadElementContentAsString();
if (contents == "")
{
logger.Info("Please confirm, but we are assuming that " + this.Name + "(episode Id =" + this.EpisodeID + ") has no airdate");
this.FirstAired = null;
}
else
{
this.FirstAired = DateTime.ParseExact(contents, "yyyy-MM-dd", new System.Globalization.CultureInfo(""));
}
}
catch
{
this.FirstAired = null;
}
}
else
{
if ((r.IsEmptyElement) || !r.IsStartElement())
{
r.ReadOuterXml();
}
else
{
XmlReader r2 = r.ReadSubtree();
r2.Read();
string name = r2.Name;
this.Items[name] = r2.ReadElementContentAsString();
r.Read();
}
}
}
}
catch (XmlException e)
{
string message = "Error processing data from TheTVDB for an episode.";
if (this.SeriesID != -1)
{
message += "\r\nSeries ID: " + this.SeriesID;
}
if (this.EpisodeID != -1)
{
message += "\r\nEpisode ID: " + this.EpisodeID;
}
if (this.EpNum != -1)
{
message += "\r\nEpisode Number: " + this.EpNum;
}
if (!string.IsNullOrEmpty(this.Name))
{
message += "\r\nName: " + this.Name;
}
logger.Error(e, message);
throw new TVDBException(e.Message);
}
}
protected bool ReadXmlInternal(XmlReader reader, string password = null)
{
bool changed = false;
decimal version;
if (decimal.TryParse(reader.GetAttribute("version"), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out version) == true)
{
Version = version;
if (version > WinAuthConfig.CURRENTVERSION)
{
// ensure we don't overwrite a newer config
throw new WinAuthInvalidNewerConfigException(string.Format(strings.ConfigIsNewer, version));
}
}
string encrypted = reader.GetAttribute("encrypted");
this.PasswordType = Authenticator.DecodePasswordTypes(encrypted);
if (this.PasswordType != Authenticator.PasswordTypes.None)
{
// read the encrypted text from the node
string data = reader.ReadElementContentAsString();
// decrypt
YubiKey yubi = null;
if ((this.PasswordType & (Authenticator.PasswordTypes.YubiKeySlot1 | Authenticator.PasswordTypes.YubiKeySlot2)) != 0 /* && this.Yubi == null */)
{
yubi = YubiKey.CreateInstance();
}
data = Authenticator.DecryptSequence(data, this.PasswordType, password, yubi);
using (MemoryStream ms = new MemoryStream(Authenticator.StringToByteArray(data)))
{
reader = XmlReader.Create(ms);
changed = ReadXml(reader, password);
}
this.PasswordType = Authenticator.DecodePasswordTypes(encrypted);
this.Password = password;
this.Yubi = yubi;
return(changed);
}
reader.MoveToContent();
if (reader.IsEmptyElement)
{
reader.Read();
return(changed);
}
bool defaultAutoRefresh = true;
bool defaultAllowCopy = false;
bool defaultCopyOnCode = false;
bool defaultHideSerial = true;
string defaultSkin = null;
reader.Read();
while (reader.EOF == false)
{
if (reader.IsStartElement())
{
switch (reader.Name)
{
case "config":
changed = ReadXmlInternal(reader, password) || changed;
break;
// 3.2 has new layout
case "data":
{
encrypted = reader.GetAttribute("encrypted");
this.PasswordType = Authenticator.DecodePasswordTypes(encrypted);
if (this.PasswordType != Authenticator.PasswordTypes.None)
{
HashAlgorithm hasher;
string hash = reader.GetAttribute("sha1");
if (string.IsNullOrEmpty(hash) == false)
{
hasher = Authenticator.SafeHasher("SHA1");
}
else
{
// old version has md5
hash = reader.GetAttribute("md5");
hasher = Authenticator.SafeHasher("MD5");
}
// read the encrypted text from the node
string data = reader.ReadElementContentAsString();
hasher.ComputeHash(Authenticator.StringToByteArray(data));
#if !NETFX_3
hasher.Dispose();
#endif
// decrypt
YubiKey yubi = null;
if ((this.PasswordType & (Authenticator.PasswordTypes.YubiKeySlot1 | Authenticator.PasswordTypes.YubiKeySlot2)) != 0 /* && this.Yubi == null */)
{
yubi = YubiKey.CreateInstance();
}
data = Authenticator.DecryptSequence(data, this.PasswordType, password, yubi);
byte[] plain = Authenticator.StringToByteArray(data);
using (MemoryStream ms = new MemoryStream(plain))
{
var datareader = XmlReader.Create(ms);
changed = ReadXmlInternal(datareader, password) || changed;
}
this.PasswordType = Authenticator.DecodePasswordTypes(encrypted);
this.Password = password;
this.Yubi = yubi;
}
}
break;
case "alwaysontop":
_alwaysOnTop = reader.ReadElementContentAsBoolean();
break;
case "usetrayicon":
_useTrayIcon = reader.ReadElementContentAsBoolean();
break;
case "notifyaction":
string s = reader.ReadElementContentAsString();
if (string.IsNullOrEmpty(s) == false)
{
try {
_notifyAction = (NotifyActions)Enum.Parse(typeof(NotifyActions), s, true);
}
catch (Exception) { }
}
break;
case "startwithwindows":
_startWithWindows = reader.ReadElementContentAsBoolean();
break;
case "autosize":
_autoSize = reader.ReadElementContentAsBoolean();
break;
case "left":
_position.X = reader.ReadElementContentAsInt();
break;
case "top":
_position.Y = reader.ReadElementContentAsInt();
break;
case "width":
_width = reader.ReadElementContentAsInt();
break;
case "height":
_height = reader.ReadElementContentAsInt();
break;
case "shadowtype":
_shadowType = reader.ReadElementContentAsString();
break;
case "pgpkey":
_pgpKey = reader.ReadElementContentAsString();
break;
case "settings":
XmlSerializer serializer = new XmlSerializer(typeof(setting[]), new XmlRootAttribute()
{
ElementName = "settings"
});
_settings = ((setting[])serializer.Deserialize(reader)).ToDictionary(e => e.Key, e => e.Value);
break;
// previous setting used as defaults for new
case "autorefresh":
defaultAutoRefresh = reader.ReadElementContentAsBoolean();
break;
case "allowcopy":
defaultAllowCopy = reader.ReadElementContentAsBoolean();
break;
case "copyoncode":
defaultCopyOnCode = reader.ReadElementContentAsBoolean();
break;
case "hideserial":
defaultHideSerial = reader.ReadElementContentAsBoolean();
break;
case "skin":
defaultSkin = reader.ReadElementContentAsString();
break;
case "WinAuthAuthenticator":
var wa = new WinAuthAuthenticator();
changed = wa.ReadXml(reader, password) || changed;
this.Add(wa);
if (this.CurrentAuthenticator == null)
{
this.CurrentAuthenticator = wa;
}
break;
// for old 2.x configs
case "authenticator":
var waold = new WinAuthAuthenticator();
waold.AuthenticatorData = Authenticator.ReadXmlv2(reader, password);
if (waold.AuthenticatorData is BattleNetAuthenticator)
{
waold.Name = "Battle.net";
}
else if (waold.AuthenticatorData is GuildWarsAuthenticator)
{
waold.Name = "GuildWars 2";
}
else if (waold.AuthenticatorData is GuildWarsAuthenticator)
{
waold.Name = "Authenticator";
}
this.Add(waold);
this.CurrentAuthenticator = waold;
waold.AutoRefresh = defaultAutoRefresh;
waold.AllowCopy = defaultAllowCopy;
waold.CopyOnCode = defaultCopyOnCode;
waold.HideSerial = defaultHideSerial;
break;
// old 2.x auto login script
case "autologin":
var hks = new HoyKeySequence();
hks.ReadXml(reader, password);
if (hks.HotKey != 0)
{
if (this.CurrentAuthenticator.HotKey == null)
{
this.CurrentAuthenticator.HotKey = new HotKey();
}
HotKey hotkey = this.CurrentAuthenticator.HotKey;
hotkey.Action = HotKey.HotKeyActions.Inject;
hotkey.Key = hks.HotKey;
hotkey.Modifiers = hks.Modifiers;
if (hks.WindowTitleRegex == true && string.IsNullOrEmpty(hks.WindowTitle) == false)
{
hotkey.Window = "/" + Regex.Escape(hks.WindowTitle);
}
else if (string.IsNullOrEmpty(hks.WindowTitle) == false)
{
hotkey.Window = hks.WindowTitle;
}
else if (string.IsNullOrEmpty(hks.ProcessName) == false)
{
hotkey.Window = hks.ProcessName;
}
if (hks.Advanced == true)
{
hotkey.Action = HotKey.HotKeyActions.Advanced;
hotkey.Advanced = hks.AdvancedScript;
}
}
break;
default:
reader.Skip();
break;
}
}
else
{
reader.Read();
break;
}
}
return(changed);
}
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.ReadElementContentAsNullable <DateTime>();
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.ReadElementContentAsNullable <DateTime>();
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);
}
/// <summary>
/// Reads a RigidNode_Base with the given reader, list of nodes, and root node reference.
/// </summary>
/// <param name="reader"></param>
/// <param name="nodes"></param>
/// <param name="root"></param>
private static void ReadNode_4_0(XmlReader reader, List <RigidNode_Base> nodes, ref RigidNode_Base root)
{
int parentID = -1;
foreach (string name in IOUtilities.AllElements(reader))
{
switch (name)
{
case "Node":
// Adds a new node to the list of RigidNode_Bases.
nodes.Add(RigidNode_Base.NODE_FACTORY(new Guid(reader["GUID"])));
break;
case "ParentID":
// Stores this ID for later use.
parentID = reader.ReadElementContentAsInt();
if (parentID == -1) // If this is the root...
{
root = nodes[nodes.Count - 1];
}
break;
case "ModelFileName":
// Assigns the ModelFileName property to the ModelFileName element value.
nodes[nodes.Count - 1].ModelFileName = reader.ReadElementContentAsString();
break;
case "ModelID":
// Assigns the ModelFullID property to the ModelID element value.
nodes[nodes.Count - 1].ModelFullID = reader.ReadElementContentAsString();
break;
case "BallJoint":
// Reads the current element as a BallJoint.
nodes[parentID].AddChild(ReadBallJoint_4_0(reader.ReadSubtree()), nodes[nodes.Count - 1]);
break;
case "CylindricalJoint":
// Reads the current element as a CylindricalJoint.
nodes[parentID].AddChild(ReadCylindricalJoint_4_0(reader.ReadSubtree()), nodes[nodes.Count - 1]);
break;
case "LinearJoint":
// Reads the current element as a LinearJoint.
nodes[parentID].AddChild(ReadLinearJoint_4_0(reader.ReadSubtree()), nodes[nodes.Count - 1]);
break;
case "PlanarJoint":
// Reads the current element as a PlanarJoint.
nodes[parentID].AddChild(ReadPlanarJoint_4_0(reader.ReadSubtree()), nodes[nodes.Count - 1]);
break;
case "RotationalJoint":
// Reads the current elemenet as a RotationalJoint.
nodes[parentID].AddChild(ReadRotationalJoint_4_0(reader.ReadSubtree()), nodes[nodes.Count - 1]);
break;
case "JointDriver":
// Add a joint driver to the skeletal joint of the current node.
nodes[nodes.Count - 1].GetSkeletalJoint().cDriver = ReadJointDriver_4_0(reader.ReadSubtree());
break;
case "RobotSensor":
// Add a sensor to the skeletal joint of the current node.
nodes[nodes.Count - 1].GetSkeletalJoint().attachedSensors.Add(ReadRobotSensor_4_0(reader.ReadSubtree()));
break;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <param name="result"></param>
internal static void Read(XmlReader reader, TransactionSearchResult result, bool preApproval)
{
if (reader.IsEmptyElement)
{
XMLParserUtils.SkipNode(reader);
return;
}
if (preApproval == true)
{
reader.ReadStartElement(TransactionSearchResultSerializer.PreApprovalSearchResult);
}
else
{
reader.ReadStartElement(TransactionSearchResultSerializer.TransactionSearchResult);
}
reader.MoveToContent();
while (!reader.EOF)
{
if (preApproval == true)
{
if (XMLParserUtils.IsEndElement(reader, TransactionSearchResultSerializer.PreApprovalSearchResult))
{
XMLParserUtils.SkipNode(reader);
break;
}
}
else
{
if (XMLParserUtils.IsEndElement(reader, TransactionSearchResultSerializer.TransactionSearchResult))
{
XMLParserUtils.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.Transactions, preApproval);
break;
case TransactionSummaryListSerializer.PreApprovals:
TransactionSummaryListSerializer.Read(reader, result.PreApprovals, preApproval);
break;
default:
XMLParserUtils.SkipElement(reader);
break;
}
}
else
{
XMLParserUtils.SkipNode(reader);
}
}
}
public override void ReadXml(XmlReader reader)
{
reader.Read();
while (!reader.EOF)
{
if (reader.IsEmptyElement && !reader.HasAttributes)
{
reader.Read();
continue;
}
switch (reader.Name)
{
case "id":
Id = reader.ReadElementContentAsInt();
break;
case "name":
Name = reader.ReadElementContentAsString();
break;
case "project":
Project = new IdentifiableName(reader);
break;
case "description":
Description = reader.ReadElementContentAsString();
break;
case "status":
Status =
(VersionStatus)
Enum.Parse(
typeof(VersionStatus),
reader.ReadElementContentAsString(),
true);
break;
case "due_date":
DueDate = reader.ReadElementContentAsNullableDateTime();
break;
case "sharing":
Sharing =
(VersionSharing)
Enum.Parse(
typeof(VersionSharing),
reader.ReadElementContentAsString(),
true);
break;
case "created_on":
CreatedOn = reader.ReadElementContentAsNullableDateTime();
break;
case "updated_on":
UpdatedOn = reader.ReadElementContentAsNullableDateTime();
break;
case "custom_fields":
CustomFields =
reader.ReadElementContentAsCollection <IssueCustomField>();
break;
default:
reader.Read();
break;
}
}
}
private void ReadImageryMetadataResponse(XmlReader xmlReader)
{
string logoUri = null;
string imageUrl = null;
string[] imageUrlSubdomains = null;
int? zoomMin = null;
int? zoomMax = null;
do
{
if (xmlReader.NodeType == XmlNodeType.Element)
{
switch (xmlReader.Name)
{
case "BrandLogoUri":
logoUri = xmlReader.ReadElementContentAsString();
break;
case "ImageUrl":
imageUrl = xmlReader.ReadElementContentAsString();
break;
case "ImageUrlSubdomains":
imageUrlSubdomains = ReadStrings(xmlReader.ReadSubtree());
break;
case "ZoomMin":
zoomMin = xmlReader.ReadElementContentAsInt();
break;
case "ZoomMax":
zoomMax = xmlReader.ReadElementContentAsInt();
break;
default:
xmlReader.Read();
break;
}
}
else
{
xmlReader.Read();
}
}while (xmlReader.NodeType != XmlNodeType.None);
if (!string.IsNullOrEmpty(imageUrl) && imageUrlSubdomains != null && imageUrlSubdomains.Length > 0)
{
var op = Dispatcher.BeginInvoke(new Action(() =>
{
if (string.IsNullOrEmpty(Culture))
{
Culture = CultureInfo.CurrentUICulture.Name;
}
TileSource = new BingMapsTileSource(imageUrl.Replace("{culture}", Culture), imageUrlSubdomains);
if (zoomMin.HasValue && zoomMin.Value > MinZoomLevel)
{
MinZoomLevel = zoomMin.Value;
}
if (zoomMax.HasValue && zoomMax.Value < MaxZoomLevel)
{
MaxZoomLevel = zoomMax.Value;
}
if (!string.IsNullOrEmpty(logoUri))
{
LogoImage = new BitmapImage(new Uri(logoUri));
}
}));
}
}
private void FetchFromVideoNode(XmlReader reader, T item)
{
reader.MoveToContent();
reader.Read();
// Loop through each element
while (!reader.EOF && reader.ReadState == ReadState.Interactive)
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "format3d":
{
var val = reader.ReadElementContentAsString();
var video = item as Video;
if (video != null)
{
if (string.Equals("HSBS", val, StringComparison.OrdinalIgnoreCase))
{
video.Video3DFormat = Video3DFormat.HalfSideBySide;
}
else if (string.Equals("HTAB", val, StringComparison.OrdinalIgnoreCase))
{
video.Video3DFormat = Video3DFormat.HalfTopAndBottom;
}
else if (string.Equals("FTAB", val, StringComparison.OrdinalIgnoreCase))
{
video.Video3DFormat = Video3DFormat.FullTopAndBottom;
}
else if (string.Equals("FSBS", val, StringComparison.OrdinalIgnoreCase))
{
video.Video3DFormat = Video3DFormat.FullSideBySide;
}
else if (string.Equals("MVC", val, StringComparison.OrdinalIgnoreCase))
{
video.Video3DFormat = Video3DFormat.MVC;
}
}
break;
}
case "aspect":
{
var val = reader.ReadElementContentAsString();
if (item is Video video)
{
video.AspectRatio = val;
}
break;
}
case "width":
{
var val = reader.ReadElementContentAsInt();
if (item is Video video)
{
video.Width = val;
}
break;
}
case "height":
{
var val = reader.ReadElementContentAsInt();
if (item is Video video)
{
video.Height = val;
}
break;
}
case "durationinseconds":
{
var val = reader.ReadElementContentAsInt();
if (item is Video video)
{
video.RunTimeTicks = new TimeSpan(0, 0, val).Ticks;
}
break;
}
default:
reader.Skip();
break;
}
}
else
{
reader.Read();
}
}
}
/// <summary>
/// Parse the XML file and create a CatalogSubscription object.
/// </summary>
/// <param name="subscriptionFile">The file with informations to create the CatalogSubscription object.</param>
/// <returns>If the file contains all informations for creating the CatalogSubscription, return this CatalogSubscription. Otherwise return an Default CatalogSubscription.</returns>
private CatalogSubscription GetCatalogSubscription(FileInfo subscriptionFile)
{
Logger.EnteringMethod(subscriptionFile.FullName);
CatalogSubscription catalogSubscription = new CatalogSubscription();
StreamReader streamReader = null;
try
{
streamReader = new StreamReader(subscriptionFile.FullName);
XmlReader reader = XmlReader.Create(streamReader);
if (reader.ReadToFollowing("CatalogSubscription"))
{
if (reader.ReadToFollowing("IsActive"))
{
catalogSubscription.IsActive = Convert.ToBoolean(reader.ReadString());
}
if (reader.ReadToFollowing("Address"))
{
catalogSubscription.Address = reader.ReadString();
}
if (reader.ReadToFollowing("CheckEvery"))
{
catalogSubscription.CheckEvery = reader.ReadElementContentAsInt();
}
if (reader.ReadToFollowing("Unit"))
{
catalogSubscription.Unit = (CatalogSubscription.CheckingUnits)Enum.Parse(typeof(CatalogSubscription.CheckingUnits), reader.ReadString(), true);
}
if (reader.ReadToFollowing("LastCheck"))
{
catalogSubscription.LastCheckDate = Convert.ToDateTime(reader.ReadString());
}
if (reader.ReadToFollowing("LastCheckResult"))
{
catalogSubscription.LastCheckResult = Convert.ToBoolean(reader.ReadString());
}
if (reader.ReadToFollowing("CatalogName"))
{
catalogSubscription.CatalogName = reader.ReadString();
}
if (reader.ReadToFollowing("Hash"))
{
catalogSubscription.Hash = reader.ReadString();
}
if (reader.ReadToFollowing("LastDownloadDate"))
{
catalogSubscription.LastDownloadDate = Convert.ToDateTime(reader.ReadString());
}
}
}
catch (Exception ex)
{
Logger.Write("**** " + ex.Message);
}
finally
{
if (streamReader != null)
{
streamReader.Close();
}
}
return(catalogSubscription);
}
public void LoadXml(XmlReader r)
{
//<Data>
// <Series>
// <id>...</id>
// etc.
// </Series>
// <Episode>
// <id>...</id>
// blah blah
// </Episode>
// <Episode>
// <id>...</id>
// blah blah
// </Episode>
// ...
//</Data>
try
{
r.Read();
if (r.Name != "Series")
{
return;
}
r.Read();
while (!r.EOF)
{
if ((r.Name == "Series") && (!r.IsStartElement()))
{
break;
}
if (r.Name == "id")
{
this.TVDBCode = r.ReadElementContentAsInt();
}
else if (r.Name == "SeriesName")
{
this.Name = XMLHelper.ReadStringFixQuotesAndSpaces(r);
}
else if (r.Name == "lastupdated")
{
this.Srv_LastUpdated = r.ReadElementContentAsLong();
}
else if ((r.Name == "Language") || (r.Name == "language"))
{
string ignore = r.ReadElementContentAsString();
}
else if ((r.Name == "LanguageId") || (r.Name == "languageId"))
{
this.LanguageId = r.ReadElementContentAsInt();
}
else if (r.Name == "TimeZone")
{
this.ShowTimeZone = r.ReadElementContentAsString();
}
else if (r.Name == "Airs_Time")
{
this.AirsTime = DateTime.Parse("20:00");
string theTime = r.ReadElementContentAsString();
try
{
if (!string.IsNullOrEmpty(theTime))
{
this.Items["Airs_Time"] = theTime;
DateTime airsTime;
if (DateTime.TryParse(theTime, out airsTime) |
DateTime.TryParse(theTime.Replace('.', ':'), out airsTime))
{
this.AirsTime = airsTime;
}
else
{
this.AirsTime = null;
}
}
}
catch (FormatException)
{
logger.Trace("Failed to parse time: {0} ", theTime);
}
}
else if (r.Name == "FirstAired")
{
string theDate = r.ReadElementContentAsString();
try
{
this.FirstAired = DateTime.ParseExact(theDate, "yyyy-MM-dd", new System.Globalization.CultureInfo(""));
this.Items["FirstAired"] = this.FirstAired.Value.ToString("yyyy-MM-dd");
this.Items["Year"] = this.FirstAired.Value.ToString("yyyy");
}
catch
{
logger.Trace("Failed to parse date: {0} ", theDate);
this.FirstAired = null;
this.Items["FirstAired"] = "";
this.Items["Year"] = "";
}
}
else
{
string name = r.Name;
this.Items[name] = r.ReadElementContentAsString();
}
// r->ReadOuterXml(); // skip
} // while
} // try
catch (XmlException e)
{
string message = "Error processing data from TheTVDB for a show.";
if (this.TVDBCode != -1)
{
message += "\r\nTheTVDB Code: " + this.TVDBCode;
}
if (!string.IsNullOrEmpty(this.Name))
{
message += "\r\nName: " + this.Name;
}
message += "\r\nLanguage: \"" + this.LanguageId + "\"";
message += "\r\n" + e.Message;
logger.Error(e, message);
throw new TVDBException(e.Message);
}
}
public static GCHeapDump ReadGCHeapDumpFromXml(XmlReader reader)
{
if (reader.NodeType != XmlNodeType.Element)
{
throw new InvalidOperationException("Must advance to GCHeapDump element (e.g. call ReadToDescendant)");
}
var elementName = reader.Name;
var inputDepth = reader.Depth;
reader.Read(); // Advance to children
GCHeapDump ret = new GCHeapDump((MemoryGraph)null);
while (inputDepth < reader.Depth)
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "MemoryGraph":
ret.MemoryGraph = ReadMemoryGraphFromXml(reader);
break;
case "CollectionLog":
ret.CollectionLog = reader.ReadElementContentAsString();
break;
case "TimeCollected":
ret.TimeCollected = DateTime.Parse(reader.ReadElementContentAsString());
break;
case "MachineName":
ret.MachineName = reader.ReadElementContentAsString();
break;
case "ProcessName":
ret.ProcessName = reader.ReadElementContentAsString();
break;
case "ProcessID":
ret.ProcessID = reader.ReadElementContentAsInt();
break;
case "CountMultipliersByType":
var multipliers = new List <float>();
ReadCountMultipliersByTypeFromXml(reader, multipliers);
ret.CountMultipliersByType = multipliers.ToArray();
break;
case "TotalProcessCommit":
ret.TotalProcessCommit = reader.ReadElementContentAsLong();
break;
case "TotalProcessWorkingSet":
ret.TotalProcessWorkingSet = reader.ReadElementContentAsLong();
break;
default:
Debug.WriteLine("Skipping unknown element {0}", reader.Name);
reader.Skip();
break;
}
}
else if (!reader.Read())
{
break;
}
}
if (ret.MemoryGraph == null)
{
throw new ApplicationException(elementName + " does not have MemoryGraph field.");
}
return(ret);
}
private static void ProcessSalePrice(InventoryItemBase item, XmlReader reader)
{
item.SalePrice = reader.ReadElementContentAsInt("SalePrice", String.Empty);
}
void IFlickrParsable.Load(XmlReader reader)
{
while (reader.MoveToNextAttribute())
{
switch (reader.LocalName)
{
case "nsid":
case "id":
GroupId = reader.Value;
break;
case "iconserver":
IconServer = reader.Value;
break;
case "iconfarm":
IconFarm = reader.Value;
break;
case "lang":
Language = reader.Value;
break;
case "ispoolmoderated":
IsPoolModerated = reader.Value == "1";
break;
default:
UtilityMethods.CheckParsingException(reader);
break;
}
}
reader.Read();
while (reader.LocalName != "group")
{
switch (reader.LocalName)
{
case "name":
GroupName = reader.ReadElementContentAsString();
break;
case "description":
Description = reader.ReadElementContentAsString();
break;
case "members":
Members = reader.ReadElementContentAsInt();
break;
case "privacy":
Privacy = (PoolPrivacy)reader.ReadElementContentAsInt();
break;
case "blast":
BlastDateAdded = UtilityMethods.UnixTimestampToDate(reader.GetAttribute("date_blast_added"));
BlastUserId = reader.GetAttribute("user_id");
BlastHtml = reader.ReadElementContentAsString();
break;
case "throttle":
ThrottleInfo = new GroupThrottleInfo();
((IFlickrParsable)ThrottleInfo).Load(reader);
break;
case "restrictions":
Restrictions = new GroupInfoRestrictions();
((IFlickrParsable)Restrictions).Load(reader);
break;
case "roles":
MemberRoleName = reader.GetAttribute("member");
ModeratorRoleName = reader.GetAttribute("moderator");
AdminRoleName = reader.GetAttribute("admin");
reader.Read();
break;
case "rules":
Rules = reader.ReadElementContentAsString();
break;
case "pool_count":
PoolCount = reader.ReadElementContentAsInt();
break;
case "topic_count":
TopicCount = reader.ReadElementContentAsInt();
break;
default:
UtilityMethods.CheckParsingException(reader);
reader.Skip();
break;
}
}
reader.Read();
}
private static void ProcessFlags(InventoryItemBase item, XmlReader reader)
{
item.Flags = (uint)reader.ReadElementContentAsInt("Flags", String.Empty);
}
/// <summary>
/// Process the dump
/// </summary>
/// <remarks>
/// The method reads the dump, raising the events during the process. After the method call returns, the
/// dump will have been read completely.
/// </remarks>
public override void Parse()
{
xml.ReadStartElement("mediawiki");
xml.ReadStartElement("siteinfo");
while (xml.Read() && xml.NodeType != XmlNodeType.EndElement)
{
if (xml.NodeType != XmlNodeType.Element)
{
throw new XmlException("An element expected");
}
switch (xml.Name)
{
case "sitename":
if (Sitename != null)
{
throw new XmlException("Duplicate <sitename> element");
}
Sitename = xml.ReadElementContentAsString();
break;
case "base":
if (Base != null)
{
throw new XmlException("Duplicate <base> element");
}
Base = new Uri(xml.ReadElementContentAsString());
break;
case "dbname":
if (DbName != null)
{
throw new XmlException("Duplicate <dbname> element");
}
DbName = xml.ReadElementContentAsString();
break;
case "generator":
if (Generator != null)
{
throw new XmlException("Duplicate <generator> element");
}
Generator = xml.ReadElementContentAsString();
break;
case "case":
if (Case != null)
{
throw new XmlException("Duplicate <generator> element");
}
Case = xml.ReadElementContentAsString();
break;
case "namespaces":
if (Namespaces != null)
{
throw new XmlException("Duplicate <namespaces> element");
}
Namespaces = new Dictionary <int, string>();
while (xml.Read() && xml.IsStartElement("namespace"))
{
string key = xml.GetAttribute("key");
string value = xml.ReadElementContentAsString();
Namespaces.Add(Int32.Parse(key, CultureInfo.InvariantCulture), value);
}
xml.ReadEndElement();
break;
default:
throw new XmlException("Unexpected element: '" + xml.Name + "'");
}
}
if (xml.Name != "siteinfo")
{
throw new XmlException("</siteinfo> expected");
}
OnSiteInfoProcessed();
xml.Read();
while (xml.MoveToContent() == XmlNodeType.Element && xml.IsStartElement("page"))
{
string pageTitle = null;
string nsFromXml = null;
string pageId = null;
string pageSha1 = null;
string restrictions = null;
bool isRedirect = false;
xml.Read();
while (xml.MoveToContent() == XmlNodeType.Element && !xml.IsStartElement("revision"))
{
switch (xml.Name)
{
case "title":
if (pageTitle != null)
{
throw new XmlException("Duplicate <title> element");
}
pageTitle = xml.ReadElementContentAsString();
break;
case "ns":
if (nsFromXml != null)
{
throw new XmlException("Duplicate <ns> element");
}
nsFromXml = xml.ReadElementContentAsString();
break;
case "id":
if (pageId != null)
{
throw new XmlException("Duplicate <id> element");
}
pageId = xml.ReadElementContentAsString();
break;
case "sha1":
if (pageSha1 != null)
{
throw new XmlException("Duplicate <sha1> element");
}
pageSha1 = xml.ReadElementContentAsString();
break;
case "restrictions":
if (restrictions != null)
{
throw new XmlException("Duplicate <restrictions> element");
}
restrictions = xml.ReadElementContentAsString();
break;
case "redirect":
if (!xml.IsEmptyElement)
{
throw new XmlException("Unexpected contents of <redirect>");
}
isRedirect = true;
break;
default:
throw new XmlException("Unexpected element: '" + xml.Name + "'");
}
xml.Read();
}
if (pageTitle == null)
{
throw new XmlException("Required <title> element missing");
}
if (pageId == null)
{
throw new XmlException("Required <id> element missing");
}
Namespace ns;
string title;
Page.ParseTitle(pageTitle, Namespaces, out ns, out title);
var page = new Page(ns, title, Int32.Parse(pageId, CultureInfo.InvariantCulture), isRedirect);
OnPageStart(page);
while (xml.IsStartElement("revision"))
{
int? revisionId = null;
int? parentId = null;
DateTime?timestamp = null;
bool minor = false;
User contributor = null;
string comment = null;
string sha1 = null;
string text = null;
string model = null;
string format = null;
xml.Read();
while (xml.MoveToContent() != XmlNodeType.EndElement)
{
if (xml.NodeType != XmlNodeType.Element)
{
throw new XmlException("An element expected");
}
switch (xml.Name)
{
case "id":
if (revisionId != null)
{
throw new XmlException("Duplicate <id> element");
}
revisionId = xml.ReadElementContentAsInt();
break;
case "parentid":
if (parentId != null)
{
throw new XmlException("Duplicate <parentid> element");
}
parentId = xml.ReadElementContentAsInt();
break;
case "timestamp":
if (timestamp != null)
{
throw new XmlException("Duplicate <timestamp> element");
}
timestamp = xml.ReadElementContentAsDateTime();
break;
case "minor":
if (minor)
{
throw new XmlException("Duplicate <minor> element");
}
if (!xml.IsEmptyElement)
{
throw new XmlException("Unexpected contents of <minor>");
}
minor = true;
break;
case "contributor":
if (contributor != null)
{
throw new XmlException("Duplicate <contributor> element");
}
string userIp = null;
string userId = null;
string userName = null;
if (xml.HasAttributes && xml.GetAttribute("deleted") == "deleted")
{
userIp = "#deleted#";
}
else
{
xml.Read();
while (xml.MoveToContent() != XmlNodeType.EndElement)
{
if (xml.NodeType != XmlNodeType.Element)
{
throw new XmlException("An element expected");
}
switch (xml.Name)
{
case "id":
if (userId != null)
{
throw new XmlException("Duplicate <id> element");
}
userId = xml.ReadElementContentAsString();
break;
case "ip":
if (userIp != null)
{
throw new XmlException("Duplicate <ip> element");
}
userIp = xml.ReadElementContentAsString();
break;
case "username":
if (userName != null)
{
throw new XmlException("Duplicate <username> element");
}
userName = xml.ReadElementContentAsString();
break;
}
xml.Read();
}
if (xml.Name != "contributor")
{
throw new XmlException("</contributor> expected");
}
}
if (userIp != null)
{
if (userId != null || userName != null)
{
throw new XmlException("User cannot be both anonymous and registered");
}
contributor = new AnonymousUser(userIp);
}
else
{
if (userId == null || userName == null)
{
throw new XmlException("Required contributor subelements missing");
}
contributor = new RegisteredUser(userName, Int32.Parse(userId, CultureInfo.InvariantCulture));
}
break;
case "comment":
if (comment != null)
{
throw new XmlException("Duplicate <comment> element");
}
comment = xml.ReadElementContentAsString();
break;
case "sha1":
if (sha1 != null)
{
throw new XmlException("Duplicate <sha1> element");
}
sha1 = xml.ReadElementContentAsString();
break;
case "model":
if (model != null)
{
throw new XmlException("Duplicate <model> element");
}
model = xml.ReadElementContentAsString();
break;
case "format":
if (format != null)
{
throw new XmlException("Duplicate <format> element");
}
format = xml.ReadElementContentAsString();
break;
case "text":
if (text != null)
{
throw new XmlException("Duplicate <text> element");
}
text = xml.ReadElementContentAsString();
break;
default:
throw new XmlException("Unexpected element: '" + xml.Name + "'");
}
xml.Read();
}
if (xml.Name != "revision")
{
throw new XmlException("</revision> expected");
}
if (revisionId == null)
{
throw new XmlException("Required <id> element missing");
}
if (contributor == null)
{
throw new XmlException("Required <contributor> element missing");
}
if (text == null)
{
throw new XmlException("Required <text> element missing");
}
if (timestamp == null)
{
throw new XmlException("Required <timestamp> element missing");
}
OnRevisionComplete(new Revision(page, revisionId.Value, parentId ?? 0, (DateTime)timestamp, minor, contributor, comment, model, format, text));
xml.Read();
}
if (xml.NodeType != XmlNodeType.EndElement || xml.Name != "page")
{
throw new XmlException("</page> expected");
}
OnPageComplete(page);
xml.Read();
}
if (xml.Name != "mediawiki" || xml.NodeType != XmlNodeType.EndElement)
{
throw new XmlException("</mediawiki> expected");
}
while (xml.Read())
{
if (xml.NodeType != XmlNodeType.Whitespace)
{
throw new XmlException("Unexpected contents");
}
}
}
public bool GetLanguages()
{
this.Say("TheTVDB Languages");
byte[] p = this.GetPage("languages.xml", true, typeMaskBits.tmMainSite, false);
if (p == null)
{
return(false);
}
MemoryStream ms = new MemoryStream(p);
XmlReaderSettings settings = new XmlReaderSettings
{
IgnoreComments = true,
IgnoreWhitespace = true
};
XmlReader reader = XmlReader.Create(ms, settings);
reader.Read();
if (reader.Name != "xml")
{
return(false);
}
reader.Read();
if (reader.Name != "Languages")
{
return(false);
}
reader.Read(); // move forward one
this.LanguageList.Clear();
while (!reader.EOF)
{
if (reader.Name == "Languages" && !reader.IsStartElement())
{
break; // end of mirror whatsit
}
if (reader.Name != "Language")
{
return(false);
}
XmlReader r = reader.ReadSubtree();
r.Read(); // puts us on "Language"
int ID = -1;
string name = "";
string abbrev = "";
r.Read(); // get onto the first thingy
while (!r.EOF)
{
if (r.Name == "Language" && !r.IsStartElement())
{
if ((ID != -1) && (!string.IsNullOrEmpty(name)) && (!string.IsNullOrEmpty(abbrev)))
{
this.LanguageList[abbrev] = name;
}
break; // end of language whatsit
}
if (r.Name == "id")
{
ID = r.ReadElementContentAsInt();
}
else if (r.Name == "name")
{
name = r.ReadElementContentAsString();
}
else if (r.Name == "abbreviation")
{
abbrev = r.ReadElementContentAsString();
}
else
{
r.ReadOuterXml(); // skip unknown element
}
}
reader.Read(); // move forward one
}
return(true);
}
public void load(XmlReader reader)
{
this.SetToDefaults();
reader.Read();
if (reader.Name != "Settings")
{
return; // bail out
}
reader.Read();
while (!reader.EOF)
{
if ((reader.Name == "Settings") && !reader.IsStartElement())
{
break; // all done
}
if (reader.Name == "Searcher")
{
string srch = reader.ReadElementContentAsString(); // and match it based on name...
this.TheSearchers.CurrentSearch = srch;
}
else if (reader.Name == "TheSearchers")
{
this.TheSearchers = new Searchers(reader.ReadSubtree());
reader.Read();
}
else if (reader.Name == "BGDownload")
{
this.BGDownload = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "OfflineMode")
{
this.OfflineMode = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "Replacements" && !reader.IsEmptyElement)
{
this.Replacements.Clear();
reader.Read();
while (!reader.EOF)
{
if ((reader.Name == "Replacements") && (!reader.IsStartElement()))
{
break;
}
if (reader.Name == "Replace")
{
this.Replacements.Add(new Replacement(reader.GetAttribute("This"),
reader.GetAttribute("That"),
reader.GetAttribute("CaseInsensitive") == "Y"));
reader.Read();
}
else
{
reader.ReadOuterXml();
}
}
reader.Read();
}
else if (reader.Name == "ExportWTWRSS" && !reader.IsEmptyElement)
{
this.ExportWTWRSS = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "ExportWTWRSSTo")
{
this.ExportWTWRSSTo = reader.ReadElementContentAsString();
}
else if (reader.Name == "ExportWTWXML")
{
this.ExportWTWXML = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "ExportWTWXMLTo")
{
this.ExportWTWXMLTo = reader.ReadElementContentAsString();
}
else if (reader.Name == "WTWRecentDays")
{
this.WTWRecentDays = reader.ReadElementContentAsInt();
}
else if (reader.Name == "StartupTab")
{
int n = reader.ReadElementContentAsInt();
if (n == 6)
{
this.StartupTab = 2; // WTW is moved
}
else if ((n >= 1) && (n <= 3)) // any of the three scans
{
this.StartupTab = 1;
}
else
{
this.StartupTab = 0; // otherwise, My Shows
}
}
else if (reader.Name == "StartupTab2")
{
this.StartupTab = TabNumberFromName(reader.ReadElementContentAsString());
}
else if (reader.Name == "DefaultNamingStyle") // old naming style
{
this.NamingStyle.StyleString = CustomName.OldNStyle(reader.ReadElementContentAsInt());
}
else if (reader.Name == "NamingStyle")
{
this.NamingStyle.StyleString = reader.ReadElementContentAsString();
}
else if (reader.Name == "NotificationAreaIcon")
{
this.NotificationAreaIcon = reader.ReadElementContentAsBoolean();
}
else if ((reader.Name == "GoodExtensions") || (reader.Name == "VideoExtensions"))
{
this.VideoExtensionsString = reader.ReadElementContentAsString();
}
else if (reader.Name == "OtherExtensions")
{
this.OtherExtensionsString = reader.ReadElementContentAsString();
}
else if (reader.Name == "ExportRSSMaxDays")
{
this.ExportRSSMaxDays = reader.ReadElementContentAsInt();
}
else if (reader.Name == "ExportRSSMaxShows")
{
this.ExportRSSMaxShows = reader.ReadElementContentAsInt();
}
else if (reader.Name == "ExportRSSDaysPast")
{
this.ExportRSSDaysPast = reader.ReadElementContentAsInt();
}
else if (reader.Name == "KeepTogether")
{
this.KeepTogether = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "LeadingZeroOnSeason")
{
this.LeadingZeroOnSeason = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "ShowInTaskbar")
{
this.ShowInTaskbar = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "RenameTxtToSub")
{
this.RenameTxtToSub = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "ShowEpisodePictures")
{
this.ShowEpisodePictures = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "AutoSelectShowInMyShows")
{
this.AutoSelectShowInMyShows = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "SpecialsFolderName")
{
this.SpecialsFolderName = reader.ReadElementContentAsString();
}
else if (reader.Name == "SABAPIKey")
{
this.SABAPIKey = reader.ReadElementContentAsString();
}
else if (reader.Name == "CheckSABnzbd")
{
this.CheckSABnzbd = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "SABHostPort")
{
this.SABHostPort = reader.ReadElementContentAsString();
}
else if (reader.Name == "PreferredLanguage")
{
this.PreferredLanguage = reader.ReadElementContentAsString();
}
else if (reader.Name == "WTWDoubleClick")
{
this.WTWDoubleClick = (WTWDoubleClickAction)reader.ReadElementContentAsInt();
}
else if (reader.Name == "ExportMissingXML")
{
this.ExportMissingXML = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "ExportMissingXMLTo")
{
this.ExportMissingXMLTo = reader.ReadElementContentAsString();
}
else if (reader.Name == "ExportMissingCSV")
{
this.ExportMissingCSV = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "ExportMissingCSVTo")
{
this.ExportMissingCSVTo = reader.ReadElementContentAsString();
}
else if (reader.Name == "ExportRenamingXML")
{
this.ExportRenamingXML = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "ExportRenamingXMLTo")
{
this.ExportRenamingXMLTo = reader.ReadElementContentAsString();
}
else if (reader.Name == "ExportFOXML")
{
this.ExportFOXML = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "ExportFOXMLTo")
{
this.ExportFOXMLTo = reader.ReadElementContentAsString();
}
else if (reader.Name == "ForceLowercaseFilenames")
{
this.ForceLowercaseFilenames = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "IgnoreSamples")
{
this.IgnoreSamples = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "SampleFileMaxSizeMB")
{
this.SampleFileMaxSizeMB = reader.ReadElementContentAsInt();
}
else if (reader.Name == "ParallelDownloads")
{
this.ParallelDownloads = reader.ReadElementContentAsInt();
}
else if (reader.Name == "uTorrentPath")
{
this.uTorrentPath = reader.ReadElementContentAsString();
}
else if (reader.Name == "ResumeDatPath")
{
this.ResumeDatPath = reader.ReadElementContentAsString();
}
else if (reader.Name == "SearchRSS")
{
this.SearchRSS = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "EpImgs")
{
this.EpTBNs = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "NFOs")
{
this.NFOs = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "XBMCImages")
{
this.XBMCImages = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "pyTivoMeta")
{
this.pyTivoMeta = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "pyTivoMetaSubFolder")
{
this.pyTivoMetaSubFolder = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "FolderJpg")
{
this.FolderJpg = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "FolderJpgIs")
{
this.FolderJpgIs = (FolderJpgIsType)reader.ReadElementContentAsInt();
}
else if (reader.Name == "MonitoredFoldersScanType")
{
this.MonitoredFoldersScanType = (ScanType)reader.ReadElementContentAsInt();
}
else if (reader.Name == "SelectedXBMCType")
{
this.SelectedXBMCType = (XBMCType)reader.ReadElementContentAsInt();
}
else if (reader.Name == "RenameCheck")
{
this.RenameCheck = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "CheckuTorrent")
{
this.CheckuTorrent = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "MissingCheck")
{
this.MissingCheck = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "SearchLocally")
{
this.SearchLocally = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "LeaveOriginals")
{
this.LeaveOriginals = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "LookForDateInFilename")
{
LookForDateInFilename = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "MonitorFolders")
{
this.MonitorFolders = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "EpJPGs")
{
this.EpJPGs = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "SeriesJpg")
{
this.SeriesJpg = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "Mede8erXML")
{
this.Mede8erXML = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "ShrinkLargeMede8erImages")
{
this.ShrinkLargeMede8erImages = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "FanArtJpg")
{
this.FanArtJpg = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "DeleteEmpty")
{
this.Tidyup.DeleteEmpty = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "DeleteEmptyIsRecycle")
{
this.Tidyup.DeleteEmptyIsRecycle = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "EmptyIgnoreWords")
{
this.Tidyup.EmptyIgnoreWords = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "EmptyIgnoreWordList")
{
this.Tidyup.EmptyIgnoreWordList = reader.ReadElementContentAsString();
}
else if (reader.Name == "EmptyIgnoreExtensions")
{
this.Tidyup.EmptyIgnoreExtensions = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "EmptyIgnoreExtensionList")
{
this.Tidyup.EmptyIgnoreExtensionList = reader.ReadElementContentAsString();
}
else if (reader.Name == "EmptyMaxSizeCheck")
{
this.Tidyup.EmptyMaxSizeCheck = reader.ReadElementContentAsBoolean();
}
else if (reader.Name == "EmptyMaxSizeMB")
{
this.Tidyup.EmptyMaxSizeMB = reader.ReadElementContentAsInt();
}
else if (reader.Name == "FNPRegexs" && !reader.IsEmptyElement)
{
this.FNPRegexs.Clear();
reader.Read();
while (!reader.EOF)
{
if ((reader.Name == "FNPRegexs") && (!reader.IsStartElement()))
{
break;
}
if (reader.Name == "Regex")
{
string s = reader.GetAttribute("Enabled");
bool en = s == null || bool.Parse(s);
this.FNPRegexs.Add(new FilenameProcessorRE(en, reader.GetAttribute("RE"),
bool.Parse(reader.GetAttribute("UseFullPath")),
reader.GetAttribute("Notes")));
reader.Read();
}
else
{
reader.ReadOuterXml();
}
}
reader.Read();
}
else if (reader.Name == "RSSURLs" && !reader.IsEmptyElement)
{
this.RSSURLs.Clear();
reader.Read();
while (!reader.EOF)
{
if ((reader.Name == "RSSURLs") && (!reader.IsStartElement()))
{
break;
}
if (reader.Name == "URL")
{
this.RSSURLs.Add(reader.ReadElementContentAsString());
}
else
{
reader.ReadOuterXml();
}
}
reader.Read();
}
else if (reader.Name == "ShowStatusTVWColors" && !reader.IsEmptyElement)
{
this.ShowStatusColors = new ShowStatusColoringTypeList();
reader.Read();
while (!reader.EOF)
{
if ((reader.Name == "ShowStatusTVWColors") && (!reader.IsStartElement()))
{
break;
}
if (reader.Name == "ShowStatusTVWColor")
{
ShowStatusColoringType type = null;
try
{
string showStatus = reader.GetAttribute("ShowStatus");
bool isMeta = bool.Parse(reader.GetAttribute("IsMeta"));
bool isShowLevel = bool.Parse(reader.GetAttribute("IsShowLevel"));
type = new ShowStatusColoringType(isMeta, isShowLevel, showStatus);
}
catch
{
}
string color = reader.GetAttribute("Color");
if (type != null && !string.IsNullOrEmpty(color))
{
try
{
System.Drawing.Color c = System.Drawing.ColorTranslator.FromHtml(color);
this.ShowStatusColors.Add(type, c);
}
catch
{
}
}
reader.Read();
}
else
{
reader.ReadOuterXml();
}
}
reader.Read();
}
else
{
reader.ReadOuterXml();
}
}
}
public void ParseUtteranceReply(XmlReader reader)
{
pur = new process_utterance_reply();
// verify node is "context_setup_reply
if (reader.Name == "process_utterance_reply")
{
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "utterance_request_status")
{
pur.utterance_request_status = reader.ReadElementContentAsInt();
#if DEBUG_REPLY
UnityEngine.Debug.Log("utterance status=" + pur.utterance_request_status);
#endif
// report error
if (pur.utterance_request_status < 0 && errorCallback != null)
{
//'utterance_request_status' indicates if utterance process is final or NLU server starts
// 0: OK. the 'match_record' list contains the simulation command(s) for the utterance
// 1: NLU server executes 'clarifying NLU sub-session' (see "SiTEL-SMS API Reqs & Specs" document)
//-1: cannot process utterance
//-2: MLU not ready for utterance processing
//-3: missing utterance text
string error="none";
switch (pur.utterance_request_status)
{
case -1:
error = "error -1: cannot process utterance";
break;
case -2:
error = "error -2: MLU not ready for utterance processing";
break;
case -3:
error = "error -3: missing utterance text";
break;
}
errorCallback(error);
}
}
if (reader.NodeType == XmlNodeType.Element && reader.Name == "match_records")
{
List<sim_command_param> parameters=null;
List<missing_sim_command_param> missing = null;
match_record record = null;
while (reader.Read())
{
#if DEBUG_REPLY
if (reader.NodeType == XmlNodeType.Element)
UnityEngine.Debug.Log("NODE_NAME=" + reader.Name + ", NODE_TYPE=" + reader.NodeType.ToString());
else if (reader.NodeType == XmlNodeType.EndElement)
UnityEngine.Debug.Log("NODE_END=" + reader.Name + ", NODE_TYPE=" + reader.NodeType.ToString());
else
UnityEngine.Debug.Log("NODE_TYPE=" + reader.NodeType.ToString());
#endif
// match START element
if (reader.NodeType == XmlNodeType.Element && reader.Name == "match")
{
if (reader.IsEmptyElement == false)
{
record = new match_record();
if ( reader.MoveToAttribute("index") == false )
UnityEngine.Debug.Log("CAN'T FIND INDEX!");
record.index = reader.ReadContentAsInt();
if ( reader.MoveToAttribute("sim_command") == false )
UnityEngine.Debug.Log("CAN'T FIND SIM_COMMAND!");
record.sim_command = reader.ReadContentAsString();
if ( reader.MoveToAttribute("score") == false )
UnityEngine.Debug.Log("CAN'T FIND SCORE!");
record.score = reader.ReadContentAsFloat();
if ( reader.MoveToAttribute("input") == false )
UnityEngine.Debug.Log("CAN'T FIND INPUT!");
record.input = reader.ReadContentAsString();
#if DEBUG_REPLY
UnityEngine.Debug.Log("START MATCH : sim_command=" + record.sim_command);
#endif
}
}
// match END element
if (reader.NodeType == XmlNodeType.EndElement && reader.Name == "match")
{
if (reader.IsEmptyElement == false)
{
#if DEBUG_REPLY
UnityEngine.Debug.Log("END MATCH");
#endif
pur.match_records.Add(record);
// do callback here, we have a valid match!!
if (utteranceCallback != null)
utteranceCallback(record);
record.Debug();
}
}
// sim command parameters
if (reader.NodeType == XmlNodeType.Element && reader.Name == "sim_command_params")
{
record.parameters = new List<sim_command_param>();
if (reader.IsEmptyElement == false)
{
#if DEBUG_REPLY
UnityEngine.Debug.Log("SIM_COMMAND_PARAMS");
#endif
}
}
// sc_param
if (reader.NodeType == XmlNodeType.Element && reader.Name == "sc_param")
{
sim_command_param sc_param = new sim_command_param();
if (reader.IsEmptyElement == false)
{
if (reader.MoveToAttribute("mandatory") == false)
UnityEngine.Debug.Log("CAN'T FIND MANDATORY!");
sc_param.mandatory = reader.ReadContentAsString();
if ( reader.MoveToAttribute("name") == false )
UnityEngine.Debug.Log("CAN'T FIND NAME!");
sc_param.name = reader.ReadContentAsString();
// value
reader.Read();
sc_param.value = reader.Value.Trim();
// add it
record.parameters.Add(sc_param);
sc_param.Debug();
}
}
if (reader.NodeType == XmlNodeType.Element && reader.Name == "missing_sim_command_params")
{
record.missing_parameters = new List<missing_sim_command_param>();
if (reader.IsEmptyElement == false)
{
#if DEBUG_REPLY
UnityEngine.Debug.Log("MISSING_SIM_COMMAND_PARAMS");
#endif
}
}
if (reader.NodeType == XmlNodeType.Element && reader.Name == "missing_sc_param")
{
if (reader.IsEmptyElement == false)
{
missing_sim_command_param sc_param = new missing_sim_command_param();
#if DEBUG_REPLY
if (reader.MoveToAttribute("mandatory") == false)
UnityEngine.Debug.Log("MISSING CAN'T FIND MANDATORY!");
sc_param.mandatory = reader.ReadContentAsString();
if (reader.MoveToAttribute("name") == false)
UnityEngine.Debug.Log("MISSING CAN'T FIND NAME!");
#endif
sc_param.name = reader.ReadContentAsString();
record.missing_parameters.Add(sc_param);
sc_param.Debug();
}
}
if (reader.NodeType == XmlNodeType.Element && reader.Name == "readback")
{
if (reader.IsEmptyElement == false)
{
reader.Read();
record.readback = reader.Value.Trim();
#if DEBUG_REPLY
UnityEngine.Debug.Log("READBACK=<" + record.readback + ">");
#endif
}
}
if (reader.NodeType == XmlNodeType.Element && reader.Name == "feedback")
{
if (reader.IsEmptyElement == false)
{
reader.Read();
record.feedback = reader.Value.Trim();
#if DEBUG_REPLY
UnityEngine.Debug.Log("FEEDBACK=<" + record.feedback + ">");
#endif
}
}
if (reader.NodeType == XmlNodeType.Element && reader.Name == "command_subject")
{
if (reader.IsEmptyElement == false)
{
reader.Read();
record.command_subject = reader.Value.Trim();
#if DEBUG_REPLY
UnityEngine.Debug.Log("SUBJECT=<" + record.command_subject + ">");
#endif
}
}
}
}
}
}
}
protected virtual void LoadStatus (XmlReader reader) {
reader.ReadToFollowing ("Status");
reader.ReadToDescendant ("HP");
HP = reader.ReadElementContentAsInt ();
}
